Update app.py

app.py

@@ -195,99 +195,104 @@ def init_game(weeks=DEFAULT_WEEKS):
 def step_game(state: dict, distributor_order: int):
     """
     Apply one week's dynamics.
-    Order of events (typical simplification):
-    1. Customer demand hits retailer this week.
-    2. Deliveries that are at pipeline[front] arrive to each role this week.
-    3. Roles fulfill incoming orders from downstream (if backlog arises).
-    4. Human (distributor) order is recorded; LLMs decide orders for their roles.
-    5. Place orders into upstream's pipeline so they will arrive after TRANSPORT_DELAY.
-    6. Log everything.
+    Defensive: ensure 'pipeline' exists and lists are padded; safe pops and appends.
     """
-    week = state["week"]
+    # Defensive defaults
+    if "roles" not in state:
+        state["roles"] = ["retailer", "wholesaler", "distributor", "factory"]
     roles = state["roles"]
 
+    # Ensure pipeline structure exists and each role has a list of length >= TRANSPORT_DELAY
+    if "pipeline" not in state or not isinstance(state["pipeline"], dict):
+        state["pipeline"] = {r: [0] * TRANSPORT_DELAY for r in roles}
+    else:
+        for r in roles:
+            state["pipeline"].setdefault(r, [0] * TRANSPORT_DELAY)
+            if len(state["pipeline"][r]) < TRANSPORT_DELAY:
+                state["pipeline"][r].extend([0] * (TRANSPORT_DELAY - len(state["pipeline"][r])))
+
+    week = state.get("week", 1)
+
     # 1) Customer demand for this week to retailer
-    demand = state["customer_demand"][week - 1]  # week is 1-indexed
+    demand = state.get("customer_demand", [])[week - 1] if (state.get("customer_demand") and week - 1 < len(state["customer_demand"])) else 0
+    state.setdefault("incoming_orders", {})
     state["incoming_orders"]["retailer"] = demand
 
-    # 2) Shipments arrive (front of pipeline)
+    # 2) Shipments arrive (front of pipeline) -- safe pop
     arriving = {}
     for r in roles:
-        # Pop front arrival if exists
         arr = 0
-        if len(state["pipeline"][r]) > 0:
-            arr = state["pipeline"][r].pop(0)
+        pl = state["pipeline"].get(r, [])
+        if len(pl) > 0:
+            try:
+                arr = pl.pop(0)
+            except Exception:
+                arr = 0
+        # ensure inventory keys
+        state.setdefault("inventory", {})
+        state["inventory"].setdefault(r, 0)
         state["inventory"][r] += arr
         arriving[r] = arr
 
-    # 3) Fulfill incoming orders from downstream (downstream -> this role)
-    # For each role, the incoming_order is whatever downstream ordered last turn.
-    # For first week, incoming_orders maybe zero for non-retailer; that's fine.
+    # 3) Fulfill incoming orders from downstream
+    state.setdefault("backlog", {})
+    state.setdefault("shipments_history", {r: [] for r in roles})
     shipments_out = {}
     for r in roles:
-        incoming = state["incoming_orders"].get(r, 0) or 0
-        inv = state["inventory"].get(r, 0) or 0
+        incoming = state.get("incoming_orders", {}).get(r, 0) or 0
+        inv = state.get("inventory", {}).get(r, 0) or 0
         shipped = min(inv, incoming)
-        state["inventory"][r] -= shipped
-        # any unfilled becomes backlog
+        state["inventory"][r] = inv - shipped
         unfilled = incoming - shipped
         if unfilled > 0:
+            state["backlog"].setdefault(r, 0)
             state["backlog"][r] += unfilled
         shipments_out[r] = shipped
-        state["shipments_history"][r].append(shipped)
+        state["shipments_history"].setdefault(r, []).append(shipped)
 
-    # 4) Record human distributor order (this week's order placed by distributor)
-    # distributor_order is the order placed to wholesaler by the distributor this week
-    # Save to orders_history for distributor
-    state["orders_history"]["distributor"].append(int(distributor_order))
-    # Also set downstream->upstream linking: the upstream (wholesaler) will see distributor_order as incoming next period
+    # 4) Record human distributor order
+    state.setdefault("orders_history", {r: [] for r in roles})
+    state["orders_history"].setdefault("distributor", []).append(int(distributor_order))
+    # set incoming_orders for upstream relation
     state["incoming_orders"]["wholesaler"] = int(distributor_order)
 
     # 5) LLM decisions for AI roles (retailer, wholesaler, factory)
     demand_history_visible = []
-    if state["info_sharing"] and state["info_history_weeks"] > 0:
-        start_idx = max(0, (week - 1) - state["info_history_weeks"])
-        demand_history_visible = state["customer_demand"][start_idx: (week - 1)]
+    if state.get("info_sharing") and state.get("info_history_weeks", 0) > 0:
+        start_idx = max(0, (week - 1) - state.get("info_history_weeks", 0))
+        demand_history_visible = state.get("customer_demand", [])[start_idx: (week - 1)]
 
     llm_outputs = {}
     for role in ["retailer", "wholesaler", "factory"]:
-        order_val, raw = call_llm_for_order(role, state_snapshot_for_prompt(state), state["info_sharing"], demand_history_visible)
+        order_val, raw = call_llm_for_order(role, state_snapshot_for_prompt(state), state.get("info_sharing", False), demand_history_visible)
         order_val = max(0, int(order_val))
-        state["orders_history"][role].append(order_val)
+        state["orders_history"].setdefault(role, []).append(order_val)
         llm_outputs[role] = {"order": order_val, "raw": raw}
-        # set incoming_orders for upstream relation: upstream will see this order next period
-        # e.g., if retailer orders X, upstream (distributor) incoming_orders will be X
+        # set incoming_orders mapping for next period
         if role == "retailer":
             state["incoming_orders"]["distributor"] = order_val
         elif role == "wholesaler":
             state["incoming_orders"]["factory"] = order_val
-        # factory's upstream is the supplier/external: we don't model beyond factory
-
-    # 6) Place orders into pipelines: these are shipments that will be sent upstream now and arrive after TRANSPORT_DELAY
-    # In the simple Beer Game, the shipped amounts are based on inventories; but orders placed lead to upstream shipments in future after they process.
-    # We'll model that orders placed this week translate into future shipments arriving after TRANSPORT_DELAY at the ordering party.
+        # factory's upstream beyond model
+
+    # 6) Place orders into pipelines: append to downstream partner's pipeline tail
+    downstream_map = {
+        "factory": "wholesaler",
+        "wholesaler": "distributor",
+        "distributor": "retailer",
+        "retailer": None
+    }
     for role in roles:
-        # Determine the order placed by this role this week:
         if role == "distributor":
             placed_order = int(distributor_order)
         else:
-            # role in orders_history last appended
-            placed_order = state["orders_history"][role][-1] if state["orders_history"][role] else 0
-
-        # For the downstream partner (the entity that will receive the shipment), we append to that partner's pipeline tail
-        # Example: distributor placed order to wholesaler -> wholesaler will receive shipment after TRANSPORT_DELAY
-        # Map role -> downstream partner (who receives shipments from role)
-        # shipments flow downstream: factory -> wholesaler -> distributor -> retailer
-        downstream_map = {
-            "factory": "wholesaler",
-            "wholesaler": "distributor",
-            "distributor": "retailer",
-            "retailer": None
-        }
+            placed_order = int(state["orders_history"].get(role, [0])[-1] if state["orders_history"].get(role) else 0)
+
         downstream = downstream_map.get(role)
         if downstream:
-            # append zeros if pipeline too short to ensure correct index, then append placed_order at tail
-            # We want the placed_order to be delivered to downstream after TRANSPORT_DELAY weeks (so push at tail)
+            # ensure downstream pipeline exists
+            state["pipeline"].setdefault(downstream, [0] * TRANSPORT_DELAY)
+            # append placed_order at tail (arrival after TRANSPORT_DELAY)
             state["pipeline"][downstream].append(placed_order)
 
     # 7) Log the week's summary
@@ -299,35 +304,49 @@ def step_game(state: dict, distributor_order: int):
         "shipments_out": shipments_out,
         "orders_submitted": {
             "distributor": int(distributor_order),
-            "retailer": state["orders_history"]["retailer"][-1] if state["orders_history"]["retailer"] else None,
-            "wholesaler": state["orders_history"]["wholesaler"][-1] if state["orders_history"]["wholesaler"] else None,
-            "factory": state["orders_history"]["factory"][-1] if state["orders_history"]["factory"] else None,
+            "retailer": state["orders_history"].get("retailer", [None])[-1],
+            "wholesaler": state["orders_history"].get("wholesaler", [None])[-1],
+            "factory": state["orders_history"].get("factory", [None])[-1],
         },
-        "inventory": dict(state["inventory"]),
-        "backlog": dict(state["backlog"]),
-        "info_sharing": state["info_sharing"],
-        "info_history_weeks": state["info_history_weeks"],
+        "inventory": dict(state.get("inventory", {})),
+        "backlog": dict(state.get("backlog", {})),
+        "info_sharing": state.get("info_sharing", False),
+        "info_history_weeks": state.get("info_history_weeks", 0),
         "llm_raw": {k: v["raw"] for k, v in llm_outputs.items()}
     }
-    state["logs"].append(log_entry)
+    state.setdefault("logs", []).append(log_entry)
 
     # 8) Advance week
-    state["week"] += 1
+    state["week"] = state.get("week", 1) + 1
 
     return state
 
 def state_snapshot_for_prompt(state):
     """
     Prepare a compact snapshot of state for LLM prompt (avoid sending huge objects).
-    We'll include week, inventory and backlog for each role and incoming_orders for this week.
+    Robust to missing 'pipeline' key or missing role entries.
     """
+    roles = state.get("roles", ["retailer", "wholesaler", "distributor", "factory"])
+    # Ensure pipeline exists and has at least TRANSPORT_DELAY entries per role
+    pipeline = state.get("pipeline", {})
+    for r in roles:
+        if r not in pipeline:
+            pipeline[r] = [0] * TRANSPORT_DELAY
+        else:
+            # if pipeline exists but is shorter than transport delay, pad with zeros
+            if len(pipeline[r]) < TRANSPORT_DELAY:
+                pipeline[r] = pipeline[r] + [0] * (TRANSPORT_DELAY - len(pipeline[r]))
+
     snap = {
-        "week": state["week"],
-        "inventory": state["inventory"].copy(),
-        "backlog": state["backlog"].copy(),
-        "incoming_orders": state["incoming_orders"].copy(),
-        # pipeline front (arriving next week)
-        "incoming_shipments_next_week": {r: (state["pipeline"][r][0] if state["pipeline"][r] else 0) for r in state["roles"]}
+        "week": state.get("week", 1),
+        "inventory": state.get("inventory", {}).copy(),
+        "backlog": state.get("backlog", {}).copy(),
+        "incoming_orders": state.get("incoming_orders", {}).copy(),
+        # pipeline front (arriving next week) -- safe access
+        "incoming_shipments_next_week": {
+            r: (pipeline.get(r, [0])[0] if pipeline.get(r) and len(pipeline.get(r)) > 0 else 0)
+            for r in roles
+        }
     }
     return snap