┌─────────────────────────────────────────────────────────┐
│                    用户界面层                              │
│  ┌──────────┐  ┌──────────┐  ┌─────────────────┐        │
│  │   TUI    │  │   Exec   │  │   MCP Server    │        │
│  │ (终端UI)  │  │ (无头模式) │  │  (协议服务器)    │        │
│  └──────────┘  └──────────┘  └─────────────────┘        │
└─────────────────────────────────────────────────────────┘
                        ↓
┌─────────────────────────────────────────────────────────┐
│                  提交/事件协议层                           │
│           Submission Queue / Event Queue                │
│         (异步双向通信,解耦请求和处理)                        │
└─────────────────────────────────────────────────────────┘
                        ↓
┌─────────────────────────────────────────────────────────┐
│                    核心引擎层                              │
│  ┌──────────────────────────────────────────────┐       │
│  │          codex-core (Rust Workspace)         │       │
│  │                                              │       │
│  │  • Session 管理(会话状态)                      │       │
│  │  • TurnContext(单轮上下文)                     │       │
│  │  • Agent Loop(主循环逻辑)                      │       │
│  │  • Model Integration(模型交互)                 │       │
│  │  • Tool Execution(工具执行)                    │       │
│  └──────────────────────────────────────────────┘       │
└─────────────────────────────────────────────────────────┘
                        ↓
┌─────────────────────────────────────────────────────────┐
│                    工具与服务层                            │
│  ┌────────────┐  ┌──────────┐  ┌──────────────┐        │
│  │  Sandbox   │  │   MCP    │  │  File Ops    │        │
│  │  (沙箱)     │  │ (协议)    │  │  (文件操作)   │        │
│  └────────────┘  └──────────┘  └──────────────┘        │
│                                                         │
│  ┌────────────┐  ┌──────────┐  ┌──────────────┐        │
│  │   Auth     │  │  Config  │  │  Responses   │        │
│  │  (认证)     │  │  (配置)   │  │  API         │        │
│  └────────────┘  └──────────┘  └──────────────┘        │
└─────────────────────────────────────────────────────────┘

codex-rs/
├── cli/                 # CLI 入口和命令分发
├── core/                # 核心引擎(Session, Agent Loop)
├── tui/                 # 终端 UI (使用 Ratatui)
├── exec/                # 无头执行模式
├── mcp-server/          # MCP 服务器实现
├── protocol/            # 通信协议定义
├── login/               # 认证系统
├── sandbox/             # 沙箱抽象层
├── macos-seatbelt/      # macOS 沙箱实现
├── linux-sandbox/       # Linux Landlock + seccomp
├── responses-api-proxy/ # API 代理服务器
├── process-hardening/   # 进程加固
└── config/              # 配置管理

┌─────────────────────────────────────────────────────────┐
│                  Agent Loop (单循环)                       │
│                                                           │
│  1. 接收用户输入                                           │
│  2. 构建上下文(System Prompt + 历史 + 用户消息)              │
│  3. 调用 Responses API (流式响应)                          │
│  4. 处理模型输出:                                          │
│     ├─ reasoning (推理过程)                                │
│     ├─ message (文本消息)                                  │
│     └─ function_call (工具调用)                            │
│  5. 执行工具 → 获取结果 → 追加到历史                         │
│  6. 回到步骤 2,继续循环                                     │
│  7. 直到任务完成或用户中断                                  │
└─────────────────────────────────────────────────────────┘

You are Codex, based on GPT-5. You are running as a coding agent
in the Codex CLI on a user's computer.

## General

- The arguments to `shell` will be passed to execvp()
- Most terminal commands should be prefixed with ["bash", "-lc"]
- Always set the `workdir` param when using the shell function
- When searching, prefer `rg` over `grep` (faster)

## Tools

1. **shell** - Execute shell commands
2. **apply_patch** - Apply unified diffs to files

## Coding Guidelines

- Minimal, surgical diffs (avoid full file rewrites)
- Run tests to verify changes
- Use project's existing patterns
- Check linter/formatter output

## Workflow

1. Read files to understand context (cat, rg, find)
2. Make minimal changes (apply_patch)
3. Verify changes (run tests, linters)
4. Iterate until success

// 工具定义
{
  "name": "shell",
  "description": "Execute shell command in sandbox",
  "parameters": {
    "cmd": ["string"],      // 命令数组
    "workdir": "string",    // 工作目录
    "env": {"key": "value"} // 环境变量(可选)
  }
}

// 特殊格式的补丁
*** Begin Patch
*** Update File: src/main.rs
@@
-fn main() {
-    println!("Hello");
+fn main() {
+    println!("Hello, World!");
}
*** End Patch

fn can_auto_approve(cmd: &[String], policy: ApprovalMode) -> bool {
    match policy {
        ApprovalMode::Suggest => {
            // 只允许读操作
            is_read_only_command(cmd)
        }
        ApprovalMode::AutoEdit => {
            // 允许读操作 + 文件写入
            is_read_only_command(cmd) || is_file_write(cmd)
        }
        ApprovalMode::FullAuto => {
            // 允许所有操作(在沙箱内)
            true
        }
    }
}

fn is_read_only_command(cmd: &[String]) -> bool {
    matches!(cmd[0].as_str(), "cat" | "ls" | "head" | "tail" | "rg" | "find")
}

┌──────────────────────────────────────────────────┐
│ Layer 1: 审批策略 (Application-Level Controls)    │
│  • 命令分类(读/写/执行)                            │
│  • 用户确认流程                                   │
│  • 命令黑名单                                     │
└──────────────────────────────────────────────────┘
                    ↓
┌──────────────────────────────────────────────────┐
│ Layer 2: OS 级沙箱 (OS-Level Sandboxing)         │
│  macOS:    Apple Seatbelt (sandbox-exec)        │
│  Linux:    Landlock + seccomp-bpf               │
└──────────────────────────────────────────────────┘
                    ↓
┌──────────────────────────────────────────────────┐
│ Layer 3: 网络隔离 (Network Isolation)             │
│  • 默认禁用网络                                   │
│  • 白名单:仅允许 OpenAI API                       │
│  • iptables/ipset 防火墙规则                      │
└──────────────────────────────────────────────────┘
                    ↓
┌──────────────────────────────────────────────────┐
│ Layer 4: 文件系统限制 (Filesystem Restrictions)   │
│  • 只读:系统目录                                  │
│  • 读写:$PWD (项目目录)                           │
│  • 读写:$TMPDIR (临时目录)                        │
└──────────────────────────────────────────────────┘

// 使用 Apple Seatbelt
fn create_sandbox_profile() -> String {
    r#"
    (version 1)
    (deny default)
    (allow file-read*)
    (allow file-write*
        (subpath (param "PWD"))
        (subpath (param "TMPDIR")))
    (deny network*)
    (allow network-outbound
        (remote ip "api.openai.com:443"))
    "#
}

fn run_in_sandbox(cmd: &[String]) -> Result<Output> {
    Command::new("sandbox-exec")
        .arg("-p")
        .arg(create_sandbox_profile())
        .args(cmd)
        .output()
}

// 使用 Landlock (Linux 5.13+)
use landlock::*;

fn create_landlock_ruleset() -> Result<Ruleset> {
    Ruleset::default()
        .handle_access(AccessFs::from_all(ABI::V2))?
        .add_rule(PathBeneath::new(&pwd, AccessFs::from_all(ABI::V2)))?
        .add_rule(PathBeneath::new("/tmp", AccessFs::from_all(ABI::V2)))?
        .restrict_self()?
}

// seccomp-bpf 限制系统调用
fn apply_seccomp_filter() {
    let filter = SeccompFilter::new()
        .allow_syscall("read")
        .allow_syscall("write")
        // ... 白名单其他必要系统调用
        .deny_default();
    filter.load().unwrap();
}

┌─────────────────────────────────────────────────────────┐
│ Step 1: CLI 入口                                         │
│  • 解析命令行参数                                         │
│  • 加载配置文件 (~/.codex/config.toml)                   │
│  • 检查认证状态                                          │
│  • 初始化 TUI 或 Exec 模式                               │
└─────────────────────────────────────────────────────────┘
                        ↓
┌─────────────────────────────────────────────────────────┐
│ Step 2: 上下文构建                                        │
│  • 读取项目文档 (AGENTS.md, codex.md)                    │
│  • 读取全局指令 (~/.codex/instructions.md)               │
│  • 检查 Git 状态                                         │
│  • 组装 System Prompt                                    │
└─────────────────────────────────────────────────────────┘
                        ↓
┌─────────────────────────────────────────────────────────┐
│ Step 3: 提交到核心引擎                                    │
│  • 创建 Submission: Op::StartTurn { prompt, ... }       │
│  • 发送到 Submission Queue                               │
│  • 核心引擎接收并处理                                     │
└─────────────────────────────────────────────────────────┘
                        ↓
┌─────────────────────────────────────────────────────────┐
│ Step 4: Agent Loop 执行                                  │
│  ┌─────────────────────────────────────────────┐        │
│  │ 4.1 调用 Responses API                       │        │
│  │  POST /v1/responses                         │        │
│  │  {                                          │        │
│  │    "model": "gpt-5-codex",                  │        │
│  │    "messages": [...],                       │        │
│  │    "tools": [{"name": "shell"}, ...],       │        │
│  │    "stream": true                           │        │
│  │  }                                          │        │
│  └─────────────────────────────────────────────┘        │
│                        ↓                                 │
│  ┌─────────────────────────────────────────────┐        │
│  │ 4.2 处理流式响应                              │        │
│  │  • response.reasoning (内部推理)             │        │
│  │  • response.message (文本输出)               │        │
│  │  • response.function_call (工具调用)         │        │
│  └─────────────────────────────────────────────┘        │
│                        ↓                                 │
│  ┌─────────────────────────────────────────────┐        │
│  │ 4.3 执行工具调用                              │        │
│  │  假设模型输出:                                │        │
│  │  {                                          │        │
│  │    "name": "shell",                         │        │
│  │    "arguments": {                           │        │
│  │      "cmd": ["cat", "src/main.rs"]          │        │
│  │    }                                        │        │
│  │  }                                          │        │
│  │                                             │        │
│  │  → 检查审批策略                              │        │
│  │  → 在沙箱中执行 cat src/main.rs              │        │
│  │  → 返回文件内容给模型                         │        │
│  └─────────────────────────────────────────────┘        │
│                        ↓                                 │
│  ┌─────────────────────────────────────────────┐        │
│  │ 4.4 模型生成补丁                              │        │
│  │  {                                          │        │
│  │    "name": "shell",                         │        │
│  │    "arguments": {                           │        │
│  │      "cmd": ["apply_patch", "*** ..."]      │        │
│  │    }                                        │        │
│  │  }                                          │        │
│  │                                             │        │
│  │  → 解析补丁                                  │        │
│  │  → 显示彩色 diff                             │        │
│  │  → 请求用户确认(如果不是 Full-Auto)           │        │
│  │  → 应用补丁到文件                             │        │
│  └─────────────────────────────────────────────┘        │
│                        ↓                                 │
│  ┌─────────────────────────────────────────────┐        │
│  │ 4.5 验证更改                                  │        │
│  │  模型可能执行:                                │        │
│  │  • cargo check (语法检查)                    │        │
│  │  • cargo test (运行测试)                     │        │
│  │  • git diff (查看更改)                       │        │
│  └─────────────────────────────────────────────┘        │
│                        ↓                                 │
│  ┌─────────────────────────────────────────────┐        │
│  │ 4.6 完成或继续迭代                            │        │
│  │  • 如果测试通过 → 输出完成消息                 │        │
│  │  • 如果测试失败 → 继续循环修复                 │        │
│  └─────────────────────────────────────────────┘        │
└─────────────────────────────────────────────────────────┘
                        ↓
┌─────────────────────────────────────────────────────────┐
│ Step 5: 事件返回                                         │
│  • 通过 Event Queue 发送事件给 UI                         │
│  • EventMsg::Reasoning - 显示推理过程                    │
│  • EventMsg::Message - 显示文本输出                      │
│  • EventMsg::ToolCall - 显示工具调用和结果                │
│  • EventMsg::TurnComplete - 任务完成                     │
└─────────────────────────────────────────────────────────┘

// 提交类型
enum Op {
    StartTurn {
        prompt: String,
        images: Vec<PathBuf>,
        context: TurnContext,
    },
    Cancel {
        submission_id: u64,
    },
    // ...
}

// 事件类型
enum EventMsg {
    Reasoning {
        text: String,
    },
    Message {
        content: String,
    },
    ToolCall {
        tool: String,
        args: serde_json::Value,
    },
    ToolResult {
        output: String,
    },
    TurnComplete,
    Error {
        message: String,
    },
}

// 核心循环
async fn submission_loop(
    mut rx: mpsc::Receiver<Op>,
    tx: mpsc::UnboundedSender<EventMsg>,
) {
    while let Some(op) = rx.recv().await {
        match op {
            Op::StartTurn { prompt, context, .. } => {
                // 调用 Agent Loop
                execute_turn(&prompt, &context, &tx).await;
            }
            Op::Cancel { .. } => {
                // 取消执行
                break;
            }
        }
    }
}

1. 命令行参数 (最高优先级)
   codex -c model=gpt-5-codex -c approval_mode=full-auto

2. 环境变量
   export CODEX_MODEL=gpt-5-codex

3. 项目配置 (.codex/config.toml)
   [default]
   model = "gpt-5-codex"
   approval_mode = "auto-edit"

4. 用户全局配置 (~/.codex/config.toml)
   [default]
   model = "gpt-5"

5. 内置默认值 (最低优先级)

# ~/.codex/config.toml

[default]
model = "gpt-5-codex"
model_provider = "openai"
approval_mode = "auto-edit"
sandbox = "workspace-write"
max_turns = 50

[profiles.strict]
approval_mode = "suggest"
sandbox = "read-only"

[profiles.ci]
approval_mode = "full-auto"
quiet = true

[mcp_servers.filesystem]
command = "mcp-server-filesystem"
args = ["--allowed-dirs", "/home/user/projects"]

[mcp_servers.github]
command = "mcp-server-github"
env = { GITHUB_TOKEN = "ghp_xxx" }

# 配置 MCP 服务器
codex mcp add filesystem --command mcp-server-filesystem
codex mcp add github --command mcp-server-github

Codex CLI  →  [MCP Protocol]  →  MCP Server (filesystem)
                                   ↓
                              读取文件/目录

# 启动 MCP 服务器模式
codex mcp

# 或者通过 npx
npx codex mcp

from agents import Agent
from agents.mcp import MCPServerStdio

async with MCPServerStdio(
    name="Codex CLI",
    params={
        "command": "npx",
        "args": ["-y", "codex", "mcp"]
    },
    client_session_timeout_seconds=360000
) as codex_mcp_server:

    agent = Agent(
        name="Developer",
        instructions="You are a coding assistant",
        mcp_servers=[codex_mcp_server]
    )

    # Agent 现在可以调用 Codex 的能力
    result = await agent.run("Refactor this code")

{
  "tools": [
    {
      "name": "codex_execute",
      "description": "Execute a coding task in Codex CLI",
      "inputSchema": {
        "type": "object",
        "properties": {
          "prompt": {
            "type": "string",
            "description": "Task description"
          },
          "approval-policy": {
            "type": "string",
            "enum": ["suggest", "auto-edit", "full-auto", "never"]
          },
          "sandbox": {
            "type": "string",
            "enum": ["read-only", "workspace-write", "danger-full-access"]
          }
        },
        "required": ["prompt"]
      }
    }
  ]
}

# Python 示例
import openai
import asyncio
from typing import List, Dict

class CodingAgent:
    def __init__(self, model="gpt-4"):
        self.model = model
        self.history: List[Dict] = []
        self.system_prompt = """
        You are a coding assistant. You can:
        1. Execute shell commands using the 'shell' tool
        2. Apply patches to files using the 'apply_patch' tool

        Always verify your changes by running tests.
        """

    async def run(self, user_prompt: str):
        # 添加用户消息
        self.history.append({
            "role": "user",
            "content": user_prompt
        })

        # 主循环
        while True:
            # 调用 LLM
            response = await openai.chat.completions.create(
                model=self.model,
                messages=[
                    {"role": "system", "content": self.system_prompt},
                    *self.history
                ],
                tools=[
                    {
                        "type": "function",
                        "function": {
                            "name": "shell",
                            "description": "Execute shell command",
                            "parameters": {
                                "type": "object",
                                "properties": {
                                    "cmd": {
                                        "type": "array",
                                        "items": {"type": "string"}
                                    }
                                },
                                "required": ["cmd"]
                            }
                        }
                    },
                    # ... 其他工具
                ]
            )

            message = response.choices[0].message

            # 处理工具调用
            if message.tool_calls:
                for tool_call in message.tool_calls:
                    result = await self.execute_tool(tool_call)

                    # 添加工具结果到历史
                    self.history.append({
                        "role": "tool",
                        "tool_call_id": tool_call.id,
                        "content": result
                    })

                # 继续循环
                continue
            else:
                # 没有工具调用,任务完成
                print(message.content)
                break

    async def execute_tool(self, tool_call):
        tool_name = tool_call.function.name
        args = json.loads(tool_call.function.arguments)

        if tool_name == "shell":
            return await self.run_shell(args["cmd"])
        elif tool_name == "apply_patch":
            return await self.apply_patch(args["patch"])

    async def run_shell(self, cmd: List[str]):
        # 实现沙箱执行
        import subprocess
        result = subprocess.run(
            cmd,
            capture_output=True,
            text=True,
            timeout=30
        )
        return f"stdout: {result.stdout}\nstderr: {result.stderr}"

# 简单的 Linux 沙箱示例
import subprocess
import tempfile
import os

class Sandbox:
    def __init__(self, work_dir: str):
        self.work_dir = work_dir

    def run_command(self, cmd: List[str]) -> str:
        # 使用 firejail 作为简单沙箱
        sandbox_cmd = [
            "firejail",
            "--quiet",
            "--private=" + self.work_dir,
            "--net=none",  # 禁用网络
            "--",
            *cmd
        ]

        result = subprocess.run(
            sandbox_cmd,
            capture_output=True,
            text=True,
            timeout=30
        )

        return result.stdout + result.stderr

class ApprovalPolicy:
    SUGGEST = "suggest"
    AUTO_EDIT = "auto_edit"
    FULL_AUTO = "full_auto"

    def __init__(self, mode: str):
        self.mode = mode

    def should_approve(self, tool: str, args: dict) -> bool:
        if self.mode == self.FULL_AUTO:
            return True

        if self.mode == self.AUTO_EDIT:
            # 自动批准读操作和写文件
            if tool == "shell":
                cmd = args["cmd"][0]
                return cmd in ["cat", "ls", "find", "grep"]
            elif tool == "apply_patch":
                return True

        # Suggest 模式:都需要确认
        return False

    def request_approval(self, tool: str, args: dict) -> bool:
        print(f"\n🔔 Approval needed:")
        print(f"Tool: {tool}")
        print(f"Args: {args}")

        response = input("Approve? (y/n): ")
        return response.lower() == 'y'

from mcp import Server, Tool

class CodexMCPServer:
    def __init__(self):
        self.server = Server()
        self.agent = CodingAgent()

        @self.server.tool()
        async def codex_execute(
            prompt: str,
            approval_policy: str = "suggest"
        ) -> str:
            """Execute a coding task"""
            self.agent.approval_mode = approval_policy
            result = await self.agent.run(prompt)
            return result

    async def run(self):
        await self.server.run(transport="stdio")

# 启动 MCP 服务器
if __name__ == "__main__":
    server = CodexMCPServer()
    asyncio.run(server.run())

my-coding-agent/
├── src/
│   ├── main.py              # CLI 入口
│   ├── agent.py             # Agent Loop
│   ├── tools.py             # 工具实现
│   ├── sandbox.py           # 沙箱封装
│   ├── approval.py          # 审批系统
│   ├── config.py            # 配置管理
│   └── mcp_server.py        # MCP 服务器
├── prompts/
│   └── system_prompt.txt    # System Prompt
├── config.toml              # 默认配置
├── requirements.txt
└── README.md

┌────────────────────────────────────────────────────────────────┐
│                         用户层                                   │
│                                                                 │
│    ┌──────────┐      ┌──────────┐      ┌──────────────┐       │
│    │  开发者   │      │   CI/CD  │      │  其他 Agent  │       │
│    └────┬─────┘      └────┬─────┘      └──────┬───────┘       │
│         │                 │                    │                │
│         ↓                 ↓                    ↓                │
└────────────────────────────────────────────────────────────────┘
         │                 │                    │
         ↓                 ↓                    ↓
┌────────────────────────────────────────────────────────────────┐
│                      接口层                                      │
│                                                                 │
│    ┌──────────┐      ┌──────────┐      ┌──────────────┐       │
│    │   TUI    │      │   Exec   │      │  MCP Server  │       │
│    │(终端界面) │      │(无头模式) │      │ (stdio协议)   │       │
│    └────┬─────┘      └────┬─────┘      └──────┬───────┘       │
│         │                 │                    │                │
│         └─────────────────┼────────────────────┘                │
│                           ↓                                     │
└────────────────────────────────────────────────────────────────┘
                            │
                            ↓
┌────────────────────────────────────────────────────────────────┐
│                  异步通信层 (SQ/EQ)                              │
│                                                                 │
│    ┌───────────────────────────────────────────────────┐       │
│    │  Submission Queue  ←→  Event Queue                │       │
│    │  (提交队列)             (事件队列)                  │       │
│    └───────────────────────────────────────────────────┘       │
└────────────────────────────────────────────────────────────────┘
                            │
                            ↓
┌────────────────────────────────────────────────────────────────┐
│                      核心引擎 (codex-core)                       │
│                                                                 │
│    ┌─────────────────────────────────────────────────┐         │
│    │            Agent Loop (主循环)                   │         │
│    │                                                 │         │
│    │  while not done:                                │         │
│    │    1. 调用 Responses API                         │         │
│    │    2. 处理 reasoning/message/function_call      │         │
│    │    3. 执行工具                                   │         │
│    │    4. 追加结果到历史                             │         │
│    │    5. 检查完成条件                               │         │
│    └─────────────────────────────────────────────────┘         │
│                           │                                     │
│    ┌──────────────────────┴─────────────────────────┐          │
│    │                                                │          │
│    ↓                                                ↓          │
│  ┌─────────────┐                          ┌─────────────┐     │
│  │  Session    │                          │ TurnContext │     │
│  │  (会话管理)  │                          │  (单轮上下文) │     │
│  └─────────────┘                          └─────────────┘     │
└────────────────────────────────────────────────────────────────┘
                            │
                            ↓
┌────────────────────────────────────────────────────────────────┐
│                       工具执行层                                 │
│                                                                 │
│    ┌──────────┐    ┌──────────┐    ┌──────────────┐           │
│    │  Shell   │    │  Patch   │    │   MCP 客户端  │           │
│    │  执行器   │    │  应用器   │    │   (外部工具)  │           │
│    └────┬─────┘    └────┬─────┘    └──────┬───────┘           │
│         │               │                  │                   │
│         └───────────────┼──────────────────┘                   │
│                         ↓                                       │
└────────────────────────────────────────────────────────────────┘
                         │
                         ↓
┌────────────────────────────────────────────────────────────────┐
│                      安全沙箱层                                  │
│                                                                 │
│    ┌─────────────────────────────────────────────┐             │
│    │            审批策略检查                       │             │
│    │  • Suggest: 所有写操作需确认                 │             │
│    │  • Auto-Edit: 自动应用文件更改                │             │
│    │  • Full-Auto: 完全自动化                     │             │
│    └─────────────────────────────────────────────┘             │
│                         ↓                                       │
│    ┌─────────────────────────────────────────────┐             │
│    │          OS 级沙箱 (Seatbelt/Landlock)       │             │
│    │  • 文件系统限制: 仅 $PWD + $TMPDIR 可写      │             │
│    │  • 网络隔离: 仅允许 api.openai.com          │             │
│    │  • 系统调用过滤 (Linux seccomp)              │             │
│    └─────────────────────────────────────────────┘             │
└────────────────────────────────────────────────────────────────┘
                         │
                         ↓
┌────────────────────────────────────────────────────────────────┐
│                     外部服务层                                   │
│                                                                 │
│    ┌──────────────┐    ┌──────────────┐    ┌──────────┐       │
│    │ OpenAI API   │    │   文件系统    │    │   Git    │       │
│    │ (Responses)  │    │   (读/写)     │    │  (版本控制)│       │
│    └──────────────┘    └──────────────┘    └──────────┘       │
└────────────────────────────────────────────────────────────────┘

        ┌──────────────────────┐
        │    用户输入提示       │
        │  "Add error handling" │
        └──────────┬───────────┘
                   ↓
        ┌──────────────────────┐
        │   构建上下文          │
        │ • System Prompt      │
        │ • 历史消息           │
        │ • 项目文档(AGENTS.md) │
        └──────────┬───────────┘
                   ↓
        ┌──────────────────────┐
        │  调用 Responses API   │
        │  (流式响应)           │
        └──────────┬───────────┘
                   ↓
        ┌──────────────────────┐
        │  解析响应类型         │
        └──────────┬───────────┘
                   ↓
         ┌─────────┴─────────┐
         ↓                   ↓
┌────────────────┐    ┌──────────────┐
│   Reasoning    │    │   Message    │
│   (推理过程)    │    │  (文本输出)   │
└────────────────┘    └──────────────┘
         ↓                   ↓
    (显示推理)           (显示消息)
         ↓                   ↓
         └─────────┬─────────┘
                   ↓
        ┌──────────────────────┐
        │   Function Call?     │
        │   (工具调用)          │
        └──────────┬───────────┘
                   ↓
              ┌────┴────┐
              │  是否?   │
              └────┬────┘
                   ↓
            ┌──────┴──────┐
            ↓             ↓
          【是】         【否】
            ↓             ↓
┌──────────────────┐  ┌──────────────┐
│   解析工具调用    │  │  任务完成     │
│ • shell          │  │  输出结果     │
│ • apply_patch    │  └──────────────┘
└─────────┬────────┘
          ↓
┌──────────────────┐
│  检查审批策略     │
│ • 需要确认?      │
│ • 自动批准?      │
└─────────┬────────┘
          ↓
    ┌─────┴─────┐
    ↓           ↓
【需确认】   【自动批准】
    ↓           ↓
┌─────────┐   │
│ 显示 UI │   │
│ 等待确认│   │
└────┬────┘   │
     ↓        ↓
  ┌──┴────────┴──┐
  │  在沙箱中执行  │
  │  获取输出     │
  └──────┬────────┘
         ↓
  ┌──────────────┐
  │  追加到历史   │
  │ • Tool Call  │
  │ • Tool Result│
  └──────┬───────┘
         ↓
  ┌──────────────┐
  │  继续循环     │
  │  (回到 API)  │
  └──────────────┘
         ↓
    (返回顶部)

┌─────────────────────────────────────────────────┐
│          模型生成工具调用                         │
│  {                                              │
│    "name": "shell",                            │
│    "arguments": {"cmd": ["cat", "main.rs"]}    │
│  }                                              │
└────────────────────┬────────────────────────────┘
                     ↓
┌─────────────────────────────────────────────────┐
│            工具分发器 (Tool Dispatcher)          │
│  • 识别工具类型                                  │
│  • 解析参数                                      │
└────────────────────┬────────────────────────────┘
                     ↓
              ┌──────┴──────┐
              │   工具类型?  │
              └──────┬──────┘
                     ↓
        ┌────────────┴────────────┐
        ↓                         ↓
  ┌──────────┐            ┌──────────────┐
  │  shell   │            │ apply_patch  │
  └────┬─────┘            └──────┬───────┘
       ↓                         ↓
┌──────────────┐          ┌──────────────┐
│ 分类命令类型  │          │  解析补丁     │
│ • 读操作     │          │  格式         │
│ • 写操作     │          └──────┬───────┘
│ • 危险操作   │                 ↓
└──────┬───────┘          ┌──────────────┐
       ↓                  │  生成 diff   │
┌──────────────┐          │  预览        │
│ 审批策略检查  │          └──────┬───────┘
│              │                 ↓
│ Suggest:     │          ┌──────────────┐
│  所有需确认   │          │  审批检查     │
│              │          └──────┬───────┘
│ Auto-Edit:   │                 ↓
│  读自动批准   │          ┌──────┴───────┐
│  写需确认     │          ↓              ↓
│              │      【需确认】      【自动】
│ Full-Auto:   │          ↓              ↓
│  全自动      │    ┌──────────┐        │
└──────┬───────┘    │ 显示 UI  │        │
       ↓            │ 等待输入 │        │
   ┌───┴───┐        └────┬─────┘        │
   ↓       ↓             ↓              ↓
【需确认】【自动】      ┌─────────────────┴──┐
   ↓       ↓          │   应用文件更改      │
   │       │          │   (fs 操作)        │
   │       │          └─────────┬──────────┘
   ↓       ↓                    ↓
┌──┴───────┴──┐          ┌──────────────┐
│ 显示确认 UI  │          │  返回结果     │
│ • 命令内容   │          │  给模型       │
│ • 风险评估   │          └──────────────┘
└──────┬──────┘
       ↓
  ┌────┴────┐
  │ 用户决定 │
  └────┬────┘
       ↓
   ┌───┴───┐
   ↓       ↓
【批准】  【拒绝】
   ↓       ↓
   │    ┌──────┐
   │    │返回错误│
   │    └──────┘
   ↓
┌──────────────────┐
│  在沙箱中执行     │
│                 │
│ macOS:          │
│  sandbox-exec   │
│                 │
│ Linux:          │
│  Landlock       │
│  + seccomp      │
└────────┬─────────┘
         ↓
┌──────────────────┐
│  捕获输出         │
│ • stdout        │
│ • stderr        │
│ • exit code     │
└────────┬─────────┘
         ↓
┌──────────────────┐
│  格式化结果       │
│  返回给 Agent    │
└──────────────────┘

# Responses API 请求
POST /v1/responses
{
  "model": "gpt-5-codex",
  "messages": [...],
  "tools": [...],
  "stream": true,
  "previous_response_id": "resp_abc123"  # 用于续传
}

# 流式响应事件
event: response.output_item.done
data: {
  "type": "reasoning",
  "content": "I need to read the file first..."
}

event: response.output_item.done
data: {
  "type": "function_call",
  "name": "shell",
  "arguments": "{\"cmd\": [\"cat\", \"main.rs\"]}"
}

codex-rs/cli
├── codex-rs/core
│   ├── codex-rs/protocol
│   ├── codex-rs/login
│   ├── codex-rs/config
│   └── codex-rs/sandbox
│       ├── codex-rs/macos-seatbelt
│       └── codex-rs/linux-sandbox
├── codex-rs/tui
└── codex-rs/exec