Update app.py

app.py

@@ -1,534 +1,371 @@
 # app.py
-"""
-Beer Game — Robust full Streamlit app (fixed pipeline/Retailer KeyError)
-- Uses old openai SDK style (openai==0.28.0) to avoid proxies/new-client issues on Spaces
-- Only uploads logs to HF at end of game
-- Ensures missing keys are initialized for backward compatibility
-- Unified lowercase role keys: 'retailer','wholesaler','distributor','factory'
-"""
+# @title 啤酒游戏最终整合版 (Streamlit 交互应用 + Hugging Face 日志上传)
 
-import os
-import re
+# -----------------------------------------------------------------------------
+# 1. 导入必要的库
+# -----------------------------------------------------------------------------
+import streamlit as st
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+from collections import deque
 import time
-import uuid
+import openai
+import re
 import random
-import json
-import traceback
-from datetime import datetime
+import uuid
+import os
 from pathlib import Path
+from datetime import datetime
+from huggingface_hub import HfApi, upload_file
 
-import streamlit as st
-import pandas as pd
-import openai   # expects openai==0.28.0 in requirements.txt
-from huggingface_hub import upload_file, HfApi
-
-# ---------------------------
-# CONFIG
-# ---------------------------
-DEFAULT_WEEKS = 36          # 24 或 36 可选，默认 36
-
-# Lead times
-ORDER_LEAD_TIME = 1         # Time for orders to reach supplier
-SHIPPING_LEAD_TIME = 2      # Time for shipments to arrive
-PRODUCTION_LEAD_TIME = 2    # Time for factory to produce goods
-
+# -----------------------------------------------------------------------------
+# 2. 配置游戏核心参数和API密钥
+# -----------------------------------------------------------------------------
+# --- 游戏参数 ---
+WEEKS = 24
 INITIAL_INVENTORY = 12
 INITIAL_BACKLOG = 0
-
-
-OPENAI_MODEL = "gpt-4o-mini"   
-
+ORDER_PASSING_DELAY = 1
+SHIPPING_DELAY = 2
+FACTORY_LEAD_TIME = 1
+FACTORY_SHIPPING_DELAY = 1
+HOLDING_COST = 0.5
+BACKLOG_COST = 1.0
+
+# --- 模型和日志配置 ---
+OPENAI_MODEL = "gpt-4o-mini"
 LOCAL_LOG_DIR = Path("logs")
-LOCAL_LOG_DIR.mkdir(exist_ok=True)
-
-# HF settings (via Secrets)
-HF_TOKEN = os.getenv("HF_TOKEN")
-HF_REPO_ID = os.getenv("HF_REPO_ID")  # e.g. "Lilli98/beer-game-logs"
-hf_api = HfApi()
-
-# OpenAI key (old SDK usage)
-openai.api_key = os.getenv("OPENAI_API_KEY")
-
-# ---------------------------
-# HELPERS
-# ---------------------------
-def now_iso():
-    return datetime.utcnow().isoformat(timespec="milliseconds") + "Z"
-
-def make_classic_demand(weeks: int):
-    # first 4 weeks: 4, from week 5 onwards: 8 (classic shock)
-    demand = []
-    for t in range(weeks):
-        if t < 4:
-            demand.append(4)
-        else:
-            demand.append(8)
-    return demand
-
-def fmt(o):
-    try:
-        return json.dumps(o, ensure_ascii=False)
-    except:
-        return str(o)
-
-# ---------------------------
-# STATE COMPATIBILITY (关键：保证 pipeline / orders 等键存在)
-# ---------------------------
-def ensure_state_compat(state: dict):
-    """
-    Ensure a state dict has all required keys and sensible defaults.
-    This protects against old/incomplete session_state entries.
-    """
-    roles = state.get("roles", ["retailer", "wholesaler", "distributor", "factory"])
-    state.setdefault("roles", roles)
-    state.setdefault("weeks_total", state.get("weeks_total", DEFAULT_WEEKS))
-    state.setdefault("week", state.get("week", 1))
-
-    # inventories/backlogs
-    state.setdefault("inventory", {r: INITIAL_INVENTORY for r in roles})
-    state.setdefault("backlog", {r: INITIAL_BACKLOG for r in roles})
-
-    # pipeline: ensure lists and proper length >= SHIPPING_LEAD_TIME
-    if "pipeline" not in state:
-        state["pipeline"] = {r: [4] * SHIPPING_LEAD_TIME for r in roles}
-    else:
-        for r in roles:
-            state["pipeline"].setdefault(r, [4] * SHIPPING_LEAD_TIME)
-            # pad if shorter than SHIPPING_LEAD_TIME
-            if len(state["pipeline"][r]) < SHIPPING_LEAD_TIME:
-                state["pipeline"][r] = state["pipeline"][r] + [4] * (SHIPPING_LEAD_TIME - len(state["pipeline"][r]))
-
-    # incoming_orders, orders_history, shipments_history
-    state.setdefault("incoming_orders", {r: 0 for r in roles})
-    state.setdefault("orders_history", {r: [] for r in roles})
-    state.setdefault("shipments_history", {r: [] for r in roles})
-    state.setdefault("logs", [])
-    state.setdefault("info_sharing", False)
-    state.setdefault("info_history_weeks", 0)
-    # demand
-    if "customer_demand" not in state:
-        state["customer_demand"] = make_classic_demand(state["weeks_total"])
+LOCAL_LOG_DIR.mkdir(exist_ok=True) # Ensure the log directory exists
+
+# --- API & Secrets 配置 (从 Streamlit Secrets 读取) ---
+try:
+    # OpenAI
+    client = openai.OpenAI(api_key=st.secrets["OPENAI_API_KEY"])
+    # Hugging Face
+    HF_TOKEN = st.secrets.get("HF_TOKEN")
+    HF_REPO_ID = st.secrets.get("HF_REPO_ID") # e.g., "YourUser/beer-game-logs"
+    if HF_TOKEN:
+        hf_api = HfApi()
     else:
-        # if demand exists but wrong length, regenerate
-        if len(state["customer_demand"]) < state["weeks_total"]:
-            state["customer_demand"] = make_classic_demand(state["weeks_total"])
-
-    # ensure week in bounds
-    if state["week"] < 1:
-        state["week"] = 1
-    if state["week"] > state["weeks_total"] + 1:
-        state["week"] = state["weeks_total"] + 1
-
-    return state
-
-# ---------------------------
-# LLM call (old openai SDK)
-# ---------------------------
-def call_llm_for_order(role: str, local_state: dict, info_sharing_visible: bool, demand_history: list, max_tokens=40, temperature=0.7):
-    """
-    role must be lowercase key matching state dicts (e.g., 'retailer').
-    Returns (order_int, raw_text)
-    """
-    # safety: ensure pipeline/inventory keys exist
-    pipeline_next = local_state.get("pipeline", {}).get(role, [0])[0] if local_state.get("pipeline", {}).get(role) else 0
-    inventory = local_state.get("inventory", {}).get(role, 0)
-    backlog = local_state.get("backlog", {}).get(role, 0)
-    incoming_order = local_state.get("incoming_orders", {}).get(role, 0)
-
-    visible_history = demand_history if info_sharing_visible else []
-
-    # build prompt (concise)
-    prompt = (
-        f"You are the {role.title()} in a 4-player Beer Game (Retailer -> Wholesaler -> Distributor -> Factory).\n"
-        f"Your objective is to minimize the **total weekly cost**, defined as:\n"
-        f"- Holding cost: $0.50 per unit of positive inventory per week.\n"
-        f"- Shortage cost: $1.00 per unit of backlog (unfilled orders) per week.\n\n"
-        f"Current state:\n"
-        f"- Week: {local_state.get('week')} / {local_state.get('weeks_total')}\n"
-        f"- Inventory on hand: {inventory}\n"
-        f"- Backlog (unfilled demand): {backlog}\n"
-        f"- Incoming shipment next week: {pipeline_next}\n"
-        f"- Incoming order this week: {incoming_order}\n"
-    )
-    if visible_history:
-        prompt += (
-            f"- Recent customer demand history (visible): {visible_history}\n"
-        )
-
-    prompt += (
-        "\nWhen deciding your order, consider that orders take time to arrive "
-        "(1 week to reach upstream supplier + 2 weeks shipping + 2 weeks production for factory). "
-        "Avoid blindly following last week's demand. Try to balance the trade-off between "
-        "avoiding stockouts (backlog cost) and avoiding overstock (inventory cost).\n\n"
-        "Decide one **non-negative integer** order quantity to place to your upstream supplier "
-        "this week to minimize expected total cost. Reply with an integer only."
-    )
-
-    try:
-        resp = openai.ChatCompletion.create(
-            model=OPENAI_MODEL,
-            messages=[
-                {"role": "system", "content": "You are an automated Beer Game agent."},
-                {"role": "user", "content": prompt},
-            ],
-            max_tokens=max_tokens,
-            temperature=temperature,
-            n=1
-        )
-        raw = resp.choices[0].message.get("content", "").strip()
-    except Exception as e:
-        raw = f"OPENAI_ERROR: {e}"
-        # fallback later
-
-    # parse first integer
-    m = re.search(r"(-?\d+)", raw or "")
-    order = None
-    if m:
-        try:
-            order = int(m.group(1))
-            if order < 0:
-                order = 0
-        except:
-            order = None
-
-    if order is None:
-        # fallback heuristic
-        incoming = incoming_order or 0
-        target = INITIAL_INVENTORY + incoming
-        order = max(0, target - inventory)
-        raw = (raw + " | PARSE_FALLBACK").strip()
-
-    return int(order), raw
-
-# ---------------------------
-# GAME LOGIC (uses lowercase role keys)
-# ---------------------------
-def init_game(weeks=DEFAULT_WEEKS):
-    roles = ["retailer", "wholesaler", "distributor", "factory"]
-    state = {
-        "participant_id": None,
-        "week": 1,
-        "weeks_total": weeks,
-        "roles": roles,
-        "inventory": {r: INITIAL_INVENTORY for r in roles},
-        "backlog": {r: INITIAL_BACKLOG for r in roles},
-        "pipeline": {r: [4] * SHIPPING_LEAD_TIME for r in roles},
-        "incoming_orders": {r: 0 for r in roles},
-        "orders_history": {r: [] for r in roles},
-        "shipments_history": {r: [] for r in roles},
-        "logs": [],
-        "info_sharing": False,
-        "info_history_weeks": 0,
-        "customer_demand": make_classic_demand(weeks),
-    }
-    return state
-
-def state_snapshot_for_prompt(state: dict):
-    # safe snapshot (keys lowercase)
-    return {
-        "week": state.get("week"),
-        "weeks_total": state.get("weeks_total"), 
-        "inventory": state.get("inventory", {}).copy(),
-        "backlog": state.get("backlog", {}).copy(),
-        "incoming_orders": state.get("incoming_orders", {}).copy(),
-        "incoming_shipments_next_week": {r: (state.get("pipeline", {}).get(r, [0])[0] if state.get("pipeline", {}).get(r) else 0) for r in state.get("roles", [])}
+        hf_api = None
+except Exception as e:
+    st.error(f"启动时读取Secrets出错: {e}")
+    st.info("请确保在Streamlit的Secrets中设置了 OPENAI_API_KEY。可选设置 HF_TOKEN 和 HF_REPO_ID 用于上传日志。")
+    client = None
+    HF_TOKEN = None
+    HF_REPO_ID = None
+    hf_api = None
+
+
+# -----------------------------------------------------------------------------
+# 3. 游戏核心逻辑函数 (大部分源自代码1, 并为Streamlit适配)
+# -----------------------------------------------------------------------------
+
+def get_customer_demand(week: int) -> int:
+    """定义终端客户需求函数"""
+    return 4 if week <= 4 else 8
+
+def init_game_state(llm_personality: str, info_sharing: str):
+    """初始化或重置游戏状态，并储存在 st.session_state 中"""
+    roles = ["Retailer", "Wholesaler", "Distributor", "Factory"]
+    human_role = random.choice(roles)
+    participant_id = str(uuid.uuid4())[:8] # Generate a unique ID for this game session
+
+    st.session_state.game_state = {
+        'game_running': True,
+        'participant_id': participant_id,
+        'week': 1,
+        'human_role': human_role,
+        'llm_personality': llm_personality,
+        'info_sharing': info_sharing,
+        'logs': [], # Changed from 'history' to 'logs' for more detailed logging
+        'echelons': {},
+        'factory_production_pipeline': deque([0] * FACTORY_LEAD_TIME, maxlen=FACTORY_LEAD_TIME),
     }
 
-def step_game(state: dict, distributor_order: int):
-    # defensive: ensure compatible keys
-    ensure_state_compat(state)
-
-    week = state["week"]
-    roles = state["roles"]
-
-    if week > state["weeks_total"]:
-        # already finished; do not advance further
-        return state
-
-    # 1) customer demand hits retailer
-    demand = state["customer_demand"][week - 1]
-    state["incoming_orders"]["retailer"] = demand
-
-    # 2) shipments arrive (front of each pipeline)
-    arriving = {}
-    for r in roles:
-        arr = 0
-        if state.get("pipeline", {}).get(r):
-            # pop front safely
-            try:
-                arr = state["pipeline"][r].pop(0)
-            except Exception:
-                arr = 0
-        state["inventory"][r] = state["inventory"].get(r, 0) + (arr or 0)
-        arriving[r] = arr
-
-    # 3) fulfill incoming orders (downstream -> this role)
-    shipments_out = {}
-    for r in roles:
-        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] = inv - shipped
-        unfilled = incoming - shipped
-        if unfilled > 0:
-            state["backlog"][r] = state.get("backlog", {}).get(r, 0) + unfilled
-        shipments_out[r] = shipped
-        state["shipments_history"].setdefault(r, []).append(shipped)
-
-    # 4) record human distributor order
-    state["orders_history"]["distributor"].append(int(distributor_order))
-    state["incoming_orders"]["wholesaler"] = int(distributor_order)
-
-    # 5) LLM decisions
-    demand_history_visible = []
-    if state.get("info_sharing") and state.get("info_history_weeks", 0) > 0:
-        start_idx = max(0, (week - 1) - state["info_history_weeks"])
-        demand_history_visible = state["customer_demand"][start_idx:(week - 1)]
-
-    llm_outputs = {}
-    for role in ["retailer", "wholesaler", "factory", "distributor"]:
-        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))
-        llm_outputs[role] = {"order": order_val, "raw": raw}
-
-        if role != "distributor":  # AI 决策直接生效
-            state["orders_history"][role].append(order_val)
-            if role == "retailer":
-                state["incoming_orders"]["distributor"] = order_val
-            elif role == "wholesaler":
-                state["incoming_orders"]["factory"] = order_val
-
-    # 人类 distributor 的真实 order 后面会覆盖
-    state["orders_history"]["distributor"].append(int(distributor_order))
-    state["incoming_orders"]["wholesaler"] = int(distributor_order)
-
-    # 6) place orders into pipelines (will arrive after SHIPPING_LEAD_TIME)
-    downstream_map = {"factory": "wholesaler", "wholesaler": "distributor", "distributor": "retailer", "retailer": None}
-    for role in roles:
-        placed_order = state["orders_history"][role][-1] if state["orders_history"].get(role) else 0
-        if role == "distributor":
-            placed_order = int(distributor_order)
-        downstream = downstream_map.get(role)
-        if downstream:
-            state["pipeline"].setdefault(downstream, [0]*SHIPPING_LEAD_TIME)
-            state["pipeline"][downstream].append(placed_order)
-
-    # 6.5) cost calculation
-    if "cost" not in state:
-        state["cost"] = {r: 0.0 for r in roles}
-
-    for r in roles:
-        inv = state["inventory"].get(r, 0)
-        backlog = state["backlog"].get(r, 0)
-        inv_cost = inv * 0.5     # 每单位库存成本
-        back_cost = backlog * 1.0  # 每单位缺货成本
-        state["cost"][r] = state["cost"].get(r, 0) + inv_cost + back_cost
-        
-    # 7) logging
+    # 为每个角色初始化状态
+    for i, name in enumerate(roles):
+        upstream = roles[i + 1] if i + 1 < len(roles) else None
+        downstream = roles[i - 1] if i - 1 >= 0 else None
+        if name == "Distributor": shipping_weeks = FACTORY_SHIPPING_DELAY
+        elif name == "Factory": shipping_weeks = 0
+        else: shipping_weeks = SHIPPING_DELAY
+
+        st.session_state.game_state['echelons'][name] = {
+            'name': name, 'upstream_name': upstream, 'downstream_name': downstream,
+            'inventory': INITIAL_INVENTORY, 'backlog': INITIAL_BACKLOG,
+            'order_pipeline': deque([0] * ORDER_PASSING_DELAY, maxlen=ORDER_PASSING_DELAY),
+            'incoming_shipments': deque([0] * shipping_weeks, maxlen=shipping_weeks),
+            'incoming_order': 0, 'order_placed': 0, 'shipment_sent': 0,
+            'weekly_cost': 0, 'total_cost': 0,
+        }
+    st.info(f"新游戏开始！AI模式: **{llm_personality} / {info_sharing}**。您的角色: **{human_role}**。本次游戏ID: `{participant_id}`")
+
+
+def get_llm_order_decision(prompt: str, echelon_name: str, current_week: int, personality: str) -> (int, str):
+    """调用 OpenAI API 获取决策，并返回决策和原始文本"""
+    if not client:
+        st.warning("API Key未设置，LLM将使用默认值8。")
+        return 8, "NO_API_KEY_DEFAULT"
+
+    with st.spinner(f"正在为 {echelon_name} 获取AI决策..."):
+        temp = 0.1 if personality == 'perfect_rational' else 0.7
+        try:
+            response = client.chat.completions.create(
+                model=OPENAI_MODEL,
+                messages=[
+                    {"role": "system", "content": "You are a supply chain manager playing the Beer Game. Your response must be only an integer number representing your order quantity and nothing else. For example: 8"},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=temp,
+                max_tokens=10
+            )
+            raw_text = response.choices[0].message.content.strip()
+            match = re.search(r'\d+', raw_text)
+            if match:
+                return int(match.group(0)), raw_text
+            else:
+                st.warning(f"LLM for {echelon_name} 未返回有效数字，将使用默认值 8。原始返回: '{raw_text}'")
+                return 8, raw_text
+        except Exception as e:
+            st.error(f"API调用失败 for {echelon_name}。错误: {e}。将使用默认值 8。")
+            return 8, f"API_ERROR: {e}"
+
+def get_llm_prompt(echelon_state: dict, week: int, llm_personality: str, info_sharing: str, all_echelons_state: dict) -> str:
+    """生成LLM的提示词 (核心逻辑完全来自代码1)"""
+    # (此函数内容与上一版完全相同，为简洁省略，实际代码中应完整保留)
+    base_info = f"""
+Your Current Status at the **{echelon_state['name']}** for **Week {week}**:
+- On-hand inventory: {echelon_state['inventory']} units.
+- Backlog (unfilled orders): {echelon_state['backlog']} units.
+- Incoming order this week (from your customer): {echelon_state['incoming_order']} units.
+- Shipments on the way to you: {list(echelon_state['incoming_shipments'])}
+- Orders you have placed being processed by your supplier: {list(echelon_state['order_pipeline'])}
+"""
+    # 场景 1: 完美理性 x 完全信息
+    if llm_personality == 'perfect_rational' and info_sharing == 'full':
+        stable_demand = 8; total_lead_time = ORDER_PASSING_DELAY + SHIPPING_DELAY; safety_stock = 4
+        target_inventory_level = (stable_demand * total_lead_time) + safety_stock
+        inventory_position = (echelon_state['inventory'] - echelon_state['backlog'] + sum(echelon_state['incoming_shipments']) + sum(echelon_state['order_pipeline']))
+        optimal_order = max(0, int(target_inventory_level - inventory_position))
+        return f"**You are a perfectly rational supply chain AI with full system visibility.**\nYour only goal is to maintain stability and minimize costs based on mathematical optimization.\n**System Analysis:**\n* **Known Stable End-Customer Demand:** {stable_demand} units/week.\n* **Your Current Total Inventory Position:** {inventory_position} units.\n* **Optimal Target Inventory Level:** {target_inventory_level} units.\n* **Mathematically Optimal Order:** The optimal order is **{optimal_order} units**.\n**Your Task:** Confirm this optimal quantity. Respond with a single integer."
+    # 场景 2: 完美理性 x 本地信息
+    elif llm_personality == 'perfect_rational' and info_sharing == 'local':
+        safety_stock = 4; anchor_demand = echelon_state['incoming_order']
+        inventory_correction = safety_stock - (echelon_state['inventory'] - echelon_state['backlog'])
+        supply_line = sum(echelon_state['incoming_shipments']) + sum(echelon_state['order_pipeline'])
+        calculated_order = anchor_demand + inventory_correction - supply_line
+        rational_local_order = max(0, int(calculated_order))
+        return f"**You are a perfectly rational supply chain AI with ONLY LOCAL information.**\nYou must use a logical heuristic to make a stable decision. A proven method is \"Anchoring and Adjustment\".\n\n{base_info}\n\n**Rational Calculation (Anchoring & Adjustment):**\n1.  **Anchor on Demand:** Your best guess for future demand is your last incoming order: **{anchor_demand} units**.\n2.  **Adjust for Inventory:** You want to hold a safety stock of {safety_stock} units. Your current stock is {echelon_state['inventory'] - echelon_state['backlog']}. You need to order an extra **{inventory_correction} units** to correct this.\n3.  **Account for Supply Line:** You already have **{supply_line} units** in transit or being processed. These should be subtracted from your new order.\n\n**Final Calculation:**\n* Order = (Anchor Demand) + (Inventory Adjustment) - (Supply Line)\n* Order = {anchor_demand} + {inventory_correction} - {supply_line} = **{rational_local_order} units**.\n\n**Your Task:** Confirm this locally rational quantity. Respond with a single integer."
+    # 场景 3: 类人 x 完全信息
+    elif llm_personality == 'human_like' and info_sharing == 'full':
+        full_info_str = f"\n**Full Supply Chain Information:**\n- End-Customer Demand this week: {get_customer_demand(week)} units.\n"
+        for name, e_state in all_echelons_state.items():
+            if name != echelon_state['name']: full_info_str += f"- {name}: Inventory={e_state['inventory']}, Backlog={e_state['backlog']}\n"
+        return f"**You are a supply chain manager with full visibility across the entire system.**\nYou can see everyone's inventory and the real customer demand. Your goal is to use this information to make a smart, coordinated decision. However, you are still human and might get anxious about your own stock levels.\n{base_info}\n{full_info_str}\n**Your Task:** Look at the full picture, especially the stable end-customer demand. Try to avoid causing the bullwhip effect. However, also consider your own inventory pressure. What quantity should you order this week? Respond with a single integer."
+    # 场景 4: 类人 x 本地信息
+    elif llm_personality == 'human_like' and info_sharing == 'local':
+        return f"**You are a reactive supply chain manager for the {echelon_state['name']}.** You have a limited view and tend to over-correct based on fear.\n\n**Your Mindset: **Your top priority is try to not have a backlog.\n\n{base_info}\n\n**Your Task:** You just saw your own inventory and a new order coming. Your gut instinct is to panic and order enough to ensure you are never caught with a backlog again.\n\n**React emotionally.** What is your knee-jerk order quantity? Respond with a single integer."
+
+def step_game(human_final_order: int):
+    """推进一周的游戏进程，并记录详细日志"""
+    state = st.session_state.game_state
+    week = state['week']
+    echelons = state['echelons']
+    human_role = state['human_role']
+    llm_personality = state['llm_personality']
+    info_sharing = state['info_sharing']
+    echelon_order = ["Retailer", "Wholesaler", "Distributor", "Factory"]
+    llm_raw_responses = {}
+
+    # --- 游戏流程 ---
+    # 1. 工厂生产完成 & 2. 各环节接收货物
+    factory_state = echelons["Factory"]
+    if state['factory_production_pipeline']: factory_state['inventory'] += state['factory_production_pipeline'].popleft()
+    for name in ["Retailer", "Wholesaler", "Distributor"]:
+        if echelons[name]['incoming_shipments']: echelons[name]['inventory'] += echelons[name]['incoming_shipments'].popleft()
+    # 3. 各环节接收订单
+    for name in echelon_order:
+        if name == "Retailer": echelons[name]['incoming_order'] = get_customer_demand(week)
+        else:
+            downstream = echelons[name]['downstream_name']
+            if downstream and echelons[downstream]['order_pipeline']:
+                echelons[name]['incoming_order'] = echelons[downstream]['order_pipeline'].popleft()
+    # 4. 满足订单并发货
+    for name in echelon_order:
+        e = echelons[name]
+        demand = e['incoming_order'] + e['backlog']
+        e['shipment_sent'] = min(e['inventory'], demand)
+        e['inventory'] -= e['shipment_sent']
+        e['backlog'] = demand - e['shipment_sent']
+    # 5. 发货在途
+    for sender in ["Factory", "Distributor", "Wholesaler"]:
+        receiver = echelons[sender]['downstream_name']
+        if receiver: echelons[receiver]['incoming_shipments'].append(echelons[sender]['shipment_sent'])
+
+    # 6. 各环节下订单
+    for name in echelon_order:
+        e = echelons[name]
+        if name == human_role:
+            order_amount, raw_resp = human_final_order, "HUMAN_INPUT"
+            st.sidebar.write(f"✔️ 你 ({name}) 的最终订单: {order_amount}")
+        else:
+            prompt = get_llm_prompt(e, week, llm_personality, info_sharing, echelons)
+            order_amount, raw_resp = get_llm_order_decision(prompt, name, week, llm_personality)
+            st.sidebar.write(f"🤖 AI ({name}) 的订单: {order_amount}")
+        llm_raw_responses[name] = raw_resp
+        e['order_placed'] = max(0, order_amount)
+        if name != "Factory": e['order_pipeline'].append(e['order_placed'])
+
+    # 7. 工厂安排生产
+    state['factory_production_pipeline'].append(echelons["Factory"]['order_placed'])
+
+    # 8. 更新成本
+    for name in echelon_order:
+        e = echelons[name]
+        e['weekly_cost'] = (e['inventory'] * HOLDING_COST) + (e['backlog'] * BACKLOG_COST)
+        e['total_cost'] += e['weekly_cost']
+
+    # 9. 记录详细日志
     log_entry = {
-        "timestamp": now_iso(),
-        "week": week,
-        "demand": demand,
-        "arriving": arriving,
-        "shipments_out": shipments_out,
-        "orders_submitted": {r: (state["orders_history"].get(r, [None])[-1] if state["orders_history"].get(r) else None) for r in roles},
-        "inventory": {r: state["inventory"].get(r, 0) for r in roles},
-        "backlog": {r: state["backlog"].get(r, 0) for r in roles},
-        "cost": {r: state["cost"].get(r, 0) for r in roles},
-        "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()}
+        'timestamp': datetime.utcnow().isoformat() + "Z", 'week': week,
+        'participant_id': state['participant_id'], 'human_role': human_role,
+        'llm_personality': llm_personality, 'info_sharing': info_sharing,
+        'customer_demand': get_customer_demand(week),
     }
-    state["logs"].append(log_entry)
-
-    # 8) advance week
-    state["week"] = state.get("week", 1) + 1
-
-    return state
-
-# ---------------------------
-# Persistence helpers
-# ---------------------------
-def save_logs_local(state: dict, participant_id: str):
-    df = pd.json_normalize(state.get("logs", []))
-    fname = LOCAL_LOG_DIR / f"logs_{participant_id}_{int(time.time())}.csv"
+    for name in echelon_order:
+        e = echelons[name]
+        log_entry[f'{name}.inventory'] = e['inventory']
+        log_entry[f'{name}.backlog'] = e['backlog']
+        log_entry[f'{name}.incoming_order'] = e['incoming_order']
+        log_entry[f'{name}.order_placed'] = e['order_placed']
+        log_entry[f'{name}.shipment_sent'] = e['shipment_sent']
+        log_entry[f'{name}.weekly_cost'] = e['weekly_cost']
+        log_entry[f'{name}.total_cost'] = e['total_cost']
+        log_entry[f'{name}.llm_raw_response'] = llm_raw_responses.get(name, "")
+    state['logs'].append(log_entry)
+
+    # 10. 推进周数
+    state['week'] += 1
+    if state['week'] > WEEKS:
+        state['game_running'] = False
+
+def plot_results(df: pd.DataFrame, title: str):
+    """绘制结果图表 (源自代码1)"""
+    fig, axes = plt.subplots(3, 1, figsize=(12, 16)); fig.suptitle(title, fontsize=16)
+    echelons = ['Retailer', 'Wholesaler', 'Distributor', 'Factory']
+    # 提取用于绘图的数据
+    plot_data = []
+    for _, row in df.iterrows():
+        for e in echelons:
+            plot_data.append({
+                'week': row['week'], 'echelon': e,
+                'inventory': row[f'{e}.inventory'], 'order_placed': row[f'{e}.order_placed'],
+                'total_cost': row[f'{e}.total_cost']
+            })
+    plot_df = pd.DataFrame(plot_data)
+    # 绘图逻辑 (与之前版本相同)
+    inventory_pivot = plot_df.pivot(index='week', columns='echelon', values='inventory').reindex(columns=echelons)
+    inventory_pivot.plot(ax=axes[0], kind='line', marker='o', markersize=4); axes[0].set_title('Inventory Levels'); axes[0].grid(True, linestyle='--')
+    order_pivot = plot_df.pivot(index='week', columns='echelon', values='order_placed').reindex(columns=echelons)
+    order_pivot.plot(ax=axes[1], style='--'); axes[1].plot(range(1, WEEKS + 1), [get_customer_demand(w) for w in range(1, WEEKS + 1)], label='Customer Demand', color='black', lw=2.5); axes[1].set_title('Order Quantities (Bullwhip Effect)'); axes[1].grid(True, linestyle='--'); axes[1].legend()
+    total_costs = plot_df.groupby('echelon')['total_cost'].max().reindex(echelons)
+    total_costs.plot(kind='bar', ax=axes[2], rot=0); axes[2].set_title('Total Cumulative Cost')
+    plt.tight_layout(rect=[0, 0, 1, 0.96]); return fig
+
+def save_logs_and_upload(state: dict):
+    """在游戏结束后，保存日志到本地并尝试上传到Hugging Face"""
+    if not state.get('logs'):
+        st.warning("没有可保存的日志。")
+        return
+
+    participant_id = state['participant_id']
+    df = pd.json_normalize(state['logs'])
+    fname = LOCAL_LOG_DIR / f"log_{participant_id}_{int(time.time())}.csv"
     df.to_csv(fname, index=False)
-    return fname
-
-def upload_log_to_hf_at_end(local_file: Path, participant_id: str):
-    """
-    Only call this at the end of the game to upload final CSV to HF dataset.
-    """
-    if not HF_TOKEN or not HF_REPO_ID:
-        return None
-    dest = f"logs/{participant_id}/{local_file.name}"
-    try:
-        upload_file(path_or_fileobj=str(local_file), path_in_repo=dest, repo_id=HF_REPO_ID, repo_type="dataset", token=HF_TOKEN)
-        return f"https://huggingface.co/datasets/{HF_REPO_ID}/resolve/main/{dest}"
-    except Exception as e:
-        st.error(f"HF upload failed: {e}")
-        return None
-
-# ---------------------------
-# STREAMLIT UI & session mgmt
-# ---------------------------
-st.set_page_config(page_title="Beer Game (Distributor + LLMs)", layout="wide")
-st.title("🍺 Beer Game — Human Distributor vs LLM agents")
-
-# participant id via query param or input
-qp = st.query_params
-pid_from_q = qp.get("participant_id", [None])[0] if qp else None
-pid_input = st.text_input("Participant ID (leave blank to auto-generate or use ?participant_id=ID)", value=pid_from_q or "")
-participant_id = pid_input.strip() if pid_input else st.session_state.setdefault("auto_pid", str(uuid.uuid4())[:8])
-st.sidebar.markdown(f"**Participant ID:** `{participant_id}`")
-
-# sessions container
-if "sessions" not in st.session_state:
-    st.session_state["sessions"] = {}
-
-# reset button for debugging / clearing old sessions
-if st.sidebar.button("Reset session (clear saved state)"):
-    if participant_id in st.session_state["sessions"]:
-        del st.session_state["sessions"][participant_id]
-    st.experimental_rerun()
+    st.success(f"日志已成功保存到本地: `{fname}`")
 
-# create or ensure session state
-if participant_id not in st.session_state["sessions"]:
-    st.session_state["sessions"][participant_id] = init_game(DEFAULT_WEEKS)
-    st.session_state["sessions"][participant_id]["participant_id"] = participant_id
+    # 提供下载按钮
+    with open(fname, "rb") as f:
+        st.download_button("📥 下载日志CSV文件", data=f, file_name=fname.name, mime="text/csv")
 
-# retrieve and ensure compatibility immediately
-state = st.session_state["sessions"][participant_id]
-state = ensure_state_compat(state)
-st.session_state["sessions"][participant_id] = state  # write back
-
-# sidebar controls
-st.sidebar.header("Experiment controls")
-state["info_sharing"] = st.sidebar.checkbox("Enable Information Sharing (share demand)", value=state.get("info_sharing", False))
-state["info_history_weeks"] = st.sidebar.slider("Weeks of demand history to share (0 = none)", 0, 8, value=state.get("info_history_weeks", 0))
-st.sidebar.markdown("---")
-st.sidebar.write("Model for LLM agents:")
-st.sidebar.write(OPENAI_MODEL)
-st.sidebar.markdown("---")
-st.sidebar.write("HF upload settings:")
-st.sidebar.write(f"- HF_REPO_ID: {HF_REPO_ID or 'NOT SET'}")
-st.sidebar.write(f"- HF_TOKEN: {'SET' if HF_TOKEN else 'NOT SET'}")
-
-# main UI
-col_main, col_side = st.columns([3,1])
-with col_main:
-    st.header(f"Week {state['week']} / {state['weeks_total']}")
-    demand_display = state["customer_demand"][state["week"] - 1] if 0 <= (state["week"] - 1) < len(state["customer_demand"]) else None
-    st.subheader(f"Customer demand (retailer receives this week): {demand_display}")
-
-    # role panels
-    roles = state["roles"]
-    panels = st.columns(len(roles))
-    for i, role in enumerate(roles):
-        with panels[i]:
-            st.markdown(f"### {role.title()}")
-            st.metric("Inventory", state["inventory"].get(role, 0))
-            st.metric("Backlog", state["backlog"].get(role, 0))
-            incoming = state["incoming_orders"].get(role, 0)
-            st.write(f"Incoming order (this week): **{incoming}**")
-            next_ship = state["pipeline"].get(role, [0])[0] if state["pipeline"].get(role) else 0
-            st.write(f"Incoming shipment next week: **{next_ship}**")
-
-    st.markdown("---")
-    # Distributor form
-    with st.form(key=f"order_form_{participant_id}", clear_on_submit=False):
-        st.write("### Your (Distributor) decision this week")
-
-        # 如果有 LLM 给的建议，就显示出来
-        last_log = state["logs"][-1] if state.get("logs") else None
-        if last_log and "llm_raw" in last_log and "distributor" in last_log["llm_raw"]:
-            suggestion = last_log["llm_raw"]["distributor"]
-            st.info(f"💡 AI suggests you order: **{suggestion}** units (you can follow or override)")
-        else:
-            st.info("💡 AI suggestion will appear after the first processed week.")
-
-        default_val = state["incoming_orders"].get("distributor", 4) or 4
-        distributor_order = st.number_input("Order to place to upstream (Wholesaler):", min_value=0, step=1, value=default_val)
-        submitted = st.form_submit_button("Submit Order (locks your decision)")
-        if submitted:
-            st.session_state.setdefault("pending_orders", {})
-            st.session_state["pending_orders"][participant_id] = int(distributor_order)
-            st.success(f"Order submitted: {distributor_order}. Now click 'Next Week' to process the week.")
-
-    st.markdown("---")
-    pending = st.session_state.get("pending_orders", {}).get(participant_id, None)
-    if pending is None:
-        st.info("Please submit your order first to enable Next Week processing.")
-    else:
-        if st.button("Next Week — process week and invoke LLM agents"):
-            # Guard: don't step if game finished
-            if state["week"] > state["weeks_total"]:
-                st.info("Game already finished for this participant.")
-            else:
-                try:
-                    state = step_game(state, pending)
-                    # write back
-                    st.session_state["sessions"][participant_id] = state
-                    # remove pending
-                    del st.session_state["pending_orders"][participant_id]
-                    st.success(f"Week processed. Advanced to week {state['week']}.")
-                except Exception as e:
-                    # show traceback for debugging
-                    tb = traceback.format_exc()
-                    st.error(f"Error during Next Week processing: {e}")
-                    st.text_area("Traceback", tb, height=300)
-
-    st.markdown("### Recent logs")
-    if state.get("logs"):
-        df = pd.json_normalize(state["logs"][-6:])
-        st.dataframe(df, use_container_width=True)
-    else:
-        st.write("No logs yet. Submit your first order and press Next Week.")
-
-with col_side:
-    st.subheader("Information Sharing (preview)")
-    st.write(f"Sharing {state.get('info_history_weeks', 0)} weeks of history (0 = only current).")
-    if state.get("info_sharing"):
-        h = state.get("info_history_weeks", 0)
-        start = max(0, (state["week"] - 1) - h)
-        hist = state["customer_demand"][start: state["week"]]
-        st.write("Demand visible to agents:", hist)
-
-    st.markdown("---")
-    st.subheader("Admin / Debug")
-    if st.button("Test LLM connection"):
-        if not openai.api_key:
-            st.error("OpenAI API key missing (set OPENAI_API_KEY in secrets).")
-        else:
+    # 尝试上传到Hugging Face
+    if HF_TOKEN and HF_REPO_ID and hf_api:
+        with st.spinner("正在上传日志到 Hugging Face Hub..."):
             try:
-                test_prompt = "Reply with 42."
-                resp = openai.ChatCompletion.create(model=OPENAI_MODEL, messages=[{"role":"user","content":test_prompt}], max_tokens=10)
-                st.write("LLM raw:", resp.choices[0].message.get("content"))
+                dest_path = f"logs/{fname.name}"
+                url = hf_api.upload_file(
+                    path_or_fileobj=str(fname),
+                    path_in_repo=dest_path,
+                    repo_id=HF_REPO_ID,
+                    repo_type="dataset",
+                    token=HF_TOKEN
+                )
+                st.success(f"✅ 日志已成功上传到 Hugging Face! [查看文件]({url})")
             except Exception as e:
-                st.error(f"LLM test failed: {e}")
-
-    if st.button("Save logs now (manual)"):
-        if not state.get("logs"):
-            st.info("No logs to save.")
-        else:
-            local_file = save_logs_local(state, participant_id)
-            st.success(f"Saved local file: {local_file}")
-
-# ---------------------------
-# End-of-game upload (only when finished)
-# ---------------------------
-# Note: check strictly greater than weeks_total (we advanced after final week)
-if state.get("week", 1) > state.get("weeks_total", DEFAULT_WEEKS):
-    st.success("Game completed for this participant.")
-    final_csv = save_logs_local(state, participant_id)
-    with open(final_csv, "rb") as f:
-        st.download_button("Download final logs CSV", data=f, file_name=final_csv.name, mime="text/csv")
-    if HF_TOKEN and HF_REPO_ID:
-        url = upload_log_to_hf_at_end(final_csv, participant_id)
-        if url:
-            st.write(f"Final logs uploaded to HF Hub: {url}")
+                st.error(f"上传到 Hugging Face 失败: {e}")
+    else:
+        st.info("未配置Hugging Face的 HF_TOKEN 或 HF_REPO_ID, 将跳过上传。")
+
+# -----------------------------------------------------------------------------
+# 4. Streamlit UI 界面
+# -----------------------------------------------------------------------------
+st.set_page_config(page_title="啤酒游戏-人机协作版", layout="wide")
+st.title("🍺 啤酒游戏：人机协作挑战")
+st.markdown("你将扮演供应链中的一个角色，与另外三个由大语言模型（LLM）驱动的AI代理合作。")
+
+# --- 游戏设置和初始化 ---
+if 'game_state' not in st.session_state or not st.session_state.game_state.get('game_running', False):
+    st.header("🎮 开始新游戏")
+    col1, col2 = st.columns(2)
+    with col1:
+        llm_personality = st.selectbox("AI '性格'", ('human_like', 'perfect_rational'), format_func=lambda x: x.replace('_', ' ').title())
+    with col2:
+        info_sharing = st.selectbox("信息共享", ('local', 'full'), format_func=lambda x: x.title())
+    if st.button("🚀 开始游戏", type="primary"):
+        init_game_state(llm_personality, info_sharing)
+        st.rerun()
+
+# --- 游戏主界面 ---
+elif 'game_state' in st.session_state and st.session_state.game_state.get('game_running'):
+    state = st.session_state.game_state
+    week, human_role, echelons = state['week'], state['human_role'], state['echelons']
+    st.header(f"第 {week} 周 / 共 {WEEKS} 周")
+    st.subheader(f"你的角色: **{human_role}** | AI模式: **{state['llm_personality'].replace('_', ' ')}** | 信息: **{state['info_sharing']}**")
+    cols = st.columns(4)
+    for i, name in enumerate(["Retailer", "Wholesaler", "Distributor", "Factory"]):
+        with cols[i]:
+            e, title_icon = echelons[name], "👤" if name == human_role else "🤖"
+            st.markdown(f"### {title_icon} {name} {'(你)' if name == human_role else '(AI)'}")
+            st.metric("库存", e['inventory']); st.metric("缺货/积压", e['backlog'])
+            st.write(f"本周收到订单: **{e['incoming_order']}**")
+            st.write(f"下周到货: **{list(e['incoming_shipments'])[0] if e['incoming_shipments'] else 0}**")
+    st.markdown("---")
+    st.header("你的决策")
+    human_echelon_state = echelons[human_role]
+    prompt_sugg = get_llm_prompt(human_echelon_state, week, state['llm_personality'], state['info_sharing'], echelons)
+    ai_suggestion, _ = get_llm_order_decision(prompt_sugg, f"{human_role} (Suggestion)", week, state['llm_personality'])
+    st.info(f"💡 AI建议你 ({human_role}) 本周向上游订购 **{ai_suggestion}** 单位。")
+    with st.form(key="order_form"):
+        final_order = st.number_input("请输入你的最终订单数量:", min_value=0, step=1, value=ai_suggestion)
+        if st.form_submit_button(label="✅ 提交订单并进入下一周"):
+            step_game(int(final_order)); st.rerun()
+    st.sidebar.header("游戏信息")
+    st.sidebar.markdown(f"**游戏ID**: `{state['participant_id']}`")
+    st.sidebar.markdown(f"**当前周**: {week-1} (已完成)")
+    if st.sidebar.button("🔄 重置游戏"):
+        del st.session_state.game_state; st.rerun()
+
+# --- 游戏结束界面 ---
+if 'game_state' in st.session_state and not st.session_state.game_state.get('game_running', False) and st.session_state.game_state['week'] > WEEKS:
+    st.header("🎉 游戏结束！")
+    state = st.session_state.game_state
+    logs_df = pd.json_normalize(state['logs'])
+    title = f"Beer Game (Human: {state['human_role']})\n(AI: {state['llm_personality'].replace('_', ' ').title()} | Info: {state['info_sharing'].title()})"
+    fig = plot_results(logs_df, title)
+    st.pyplot(fig)
+    # 保存并上传日志
+    save_logs_and_upload(state)
+    if st.button("✨ 开始一局新游戏"):
+        del st.session_state.game_state; st.rerun()