# JPMorgan COiN 核心流水线架构（简化示意）
class ContractAgent:
    def __init__(self):
        self.stages = [
            DocumentParser(),      # PDF/扫描件→结构化
            ClauseClassifier(),    # 300+条款类型分类
            AnomalyDetector(),     # 异常条款识别
            RiskScorer(),          # 风险评分模型
            HumanReviewGate(threshold=0.85)  # 置信度<85%→人工
        ]

    async def process(self, contract):
        context = {"raw": contract, "confidence": 1.0}
        for stage in self.stages:
            context = await stage.execute(context)
            if context["confidence"] < 0.85:
                await self.escalate_to_human(context)
                return
        await self.commit_decision(context)

graph TD
    A[Klarna Agent时间线] --> B[2024Q2: 暂停招聘]
    B --> C[2024Q4: AI客服上线<br>替代700名客服]
    C --> D[2025Q1: 峰值<br>2/3咨询由AI处理]
    D --> E[2025Q2: CSAT降22%<br>复杂场景失灵]
    E --> F[2025Q3: 社交媒体<br>信任危机爆发]
    F --> G[2026Q1: 重新招聘<br>人工客服回归]
    G --> H[2026Q2: 混合模式<br>AI处理简单case<br>人处理复杂case]

    style E fill:#ff6b6b
    style F fill:#ff6b6b
    style H fill:#51cf66

# OpenHands CodeAct 核心循环
class CodeActAgent:
    async def step(self, observation):
        # 1. 观察环境状态（文件、终端输出、错误信息）
        action = await self.llm.plan(observation)

        if action.type == "code":
            # 2. 生成代码并在沙箱中执行
            result = await self.sandbox.execute(action.code)

            # 3. 用执行结果作为下一步的观察
            if result.exit_code == 0:
                observation = f"执行成功:\n{result.stdout}"
            else:
                observation = f"执行失败:\n{result.stderr}"

            # 4. 关键：失败的执行结果直接反馈给LLM
            #    不需要额外的"反思"步骤
            return observation

        elif action.type == "finish":
            return self.compile_patch()

graph LR
    A[用户任务] --> B[规划模块<br>任务分解]
    B --> C[浏览器模块<br>网页搜索抓取]
    B --> D[代码执行模块<br>沙箱Python]
    B --> E[文件处理模块<br>PDF/Excel分析]
    C --> F[综合推理模块<br>整合结果]
    D --> F
    E --> F
    F --> G[输出验证<br>交叉检查]
    G --> H[最终答案]

    style B fill:#4dabf7
    style F fill:#4dabf7
    style G fill:#ffa94d

# 六层自愈框架核心实现
class SelfHealingAgent:
    def __init__(self):
        self.checkpoint_store = RedisCheckpointStore()
        self.tool_fallbacks = {
            "web_search": ["duckduckgo", "brave_search", "serpapi"],
            "code_exec": ["docker_sandbox", "local_python", "repl"],
        }

    async def execute_with_healing(self, task):
        # L2: 执行前保存状态快照
        await self.checkpoint_store.save(task.id, self.context)

        try:
            result = await self.run_step(task)
            return result
        except ToolExecutionError as e:
            # L3: 工具降级
            for fallback in self.tool_fallbacks[e.tool_name]:
                try:
                    result = await self.run_with_tool(fallback, task)
                    return result
                except:
                    continue
            # L4: 计划回滚
            await self.rollback_plan(task)
        except ContextOverflowError:
            # L5: 上下文压缩
            self.context = await self.compress_context(
                self.context,
                keep=["task_goal", "critical_state", "pending_actions"]
            )
        except AllRecoveryFailedError:
            # L6: 人类升级
            await self.escalate_to_human(task, self.context)

graph TD
    subgraph "企业Agent真实成本结构"
        A[初始开发 35%] --> A1[Prompt工程 10%]
        A --> A2[工具集成 15%]
        A --> A3[测试验证 10%]
        B[护栏开发 30%] --> B1[输入验证 8%]
        B --> B2[输出过滤 7%]
        B --> B3[行动白名单 8%]
        B --> B4[速率限制 7%]
        C[监控运维 20%] --> C1[Agent专用APM 10%]
        C --> C2[告警与回滚 5%]
        C --> C3[人工升级流程 5%]
        D[持续维护 15%] --> D1[模型漂移适配 8%]
        D --> D2[工具更新 4%]
        D --> D3[用例扩展 3%]
    end

    style B fill:#ffd43b
    style C fill:#ffd43b

# 生产级置信度门控实现
class ConfidenceGatedAgent:
    def __init__(self):
        self.thresholds = {
            "auto_execute": 0.90,    # >90%: 全自动
            "auto_with_log": 0.75,   # 75-90%: 执行但记录
            "human_approve": 0.50,   # 50-75%: 需人工批准
            "human_takeover": 0.00,  # <50%: 人工接管
        }
        self.action_risk = {
            "查询余额": "low",       # 低风险动作
            "修改地址": "medium",    # 中风险
            "发起退款": "high",      # 高风险
            "关闭账户": "critical",  # 关键操作
        }

    async def execute(self, action, confidence):
        risk = self.action_risk[action.type]

        # 关键操作无论置信度都需人工批准
        if risk == "critical":
            return await self.human_approve(action)

        # 根据风险级别调整阈值
        adjusted = self.adjust_threshold(confidence, risk)

        if adjusted >= self.thresholds["auto_execute"]:
            return await self.auto_execute(action)
        elif adjusted >= self.thresholds["human_approve"]:
            return await self.queue_for_approval(action)
        else:
            return await self.human_takeover(action)

graph TD
    A[是否需要Agent?] --> B{任务频率?}
    B -->|高频 >100次/天| C{任务边界?}
    B -->|中频 10-100次/天| D{错误容忍度?}
    B -->|低频 <10次/天| E[用ChatGPT手动做<br>不值得工程化]

    C -->|明确| F[全自动Agent<br>如:合同审查]
    C -->|模糊| D

    D -->|高容忍| G[半自动Agent<br>如:内容生成]
    D -->|低容忍| H{错误后果?}

    H -->|可逆| G
    H -->|不可逆| I[人工为主+Agent辅助<br>如:医疗诊断]

    style F fill:#51cf66
    style G fill:#ffd43b
    style I fill:#ff6b6b
    style E fill:#adb5bd