python-codex 0.1.2__tar.gz → 0.1.4__tar.gz

python_codex-0.1.4/.github/workflows/test.yml

@@ -0,0 +1,82 @@
+name: test
+
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches:
+      - main
+
+jobs:
+  pytest-modern:
+    name: pytest (Python ${{ matrix.python-version }})
+    runs-on: ubuntu-22.04
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version:
+          - "3.7"
+          - "3.8"
+          - "3.10"
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Sync dependencies
+        run: uv sync --dev
+
+      - name: Run pytest
+        run: uv run pytest
+
+  pytest-py36:
+    name: pytest (Python 3.6)
+    runs-on: ubuntu-22.04
+    container:
+      image: python:3.6.15-slim-bullseye
+    steps:
+      - name: Install system dependencies
+        run: |
+          apt-get update
+          apt-get install -y --no-install-recommends git nodejs npm
+
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Mark workspace as safe for git
+        run: git config --global --add safe.directory "$PWD"
+
+      - name: Show runtime versions
+        run: |
+          python --version
+          pip --version
+          git --version
+          node --version
+
+      - name: Install Python 3.6 compatibility dependencies
+        run: |
+          python -m pip install -i https://pypi.org/simple \
+            "dataclasses>=0.8" \
+            "typing_extensions>=4.1.1,<4.2" \
+            "importlib_metadata>=4.8.3,<5" \
+            "tomli>=1.2.3,<2" \
+            "requests>=2.27.1" \
+            "prompt-toolkit>=3.0.36,<3.1" \
+            "loguru>=0.7.3,<1" \
+            "cryptography>=40.0.2,<41" \
+            "fastapi>=0.83,<0.84" \
+            "uvicorn>=0.16,<0.17" \
+            "pytest>=6.2.5,<7" \
+            "pytest-asyncio>=0.16,<0.17"
+
+      - name: Run Python 3.6 pytest
+        env:
+          PYTHONPATH: ${{ github.workspace }}
+        run: python -m pytest -c /dev/null

{python_codex-0.1.2 → python_codex-0.1.4}/AGENTS.md

@@ -9,12 +9,16 @@
 - 会话协议先收敛到 4 类 item：`UserMessage`、`AssistantMessage`、`ToolCall`、`ToolResult`；只有这层稳定后再扩 richer event model。
 - 优先保持主循环可测试、可替换：模型侧通过 `ModelClient` 协议接入；测试专用的 `ScriptedModelClient` 放在 `tests/fakes.py`，不要放进运行时包。
 - `ResponsesModelClient` 直接复用 `~/.codex/config.toml` 的 provider 配置；当前已验证这里的 responses provider 需要 `stream = true`，否则会返回 `400` 和 `Stream must be set to true`。
+- 现在 `ResponsesModelClient` 默认会对流式断连做 provider 级自动重试（`stream_max_retries` 默认 5）；写 CLI/REPL 测试时如果断言“先向用户报错，再靠下一句 `go on` 继续”，必须在测试 provider 配置里显式设 `stream_max_retries = 0`，否则测试可能一直等不到预期错误而卡住。
 - `responses_server` compat 层应透传请求里的 `model`；不要再做 “取 downstream /models 第一个 id 并强制覆盖请求模型” 这种兜底兼容。
 - 对 `model_provider = "vllm"`，`responses_server` 仍然走 `/v1/chat/completions` compat 路径，但要保留 reasoning：把 chat chunk 里的 `reasoning` / `reasoning_content` 翻回 Responses `reasoning` item，并把历史里的 Responses `reasoning` item 回放成下游 assistant message 的 `reasoning` 字段。
 - `responses_server` 的 provider-specific chat payload 定制统一放在 `responses_server/payload_processors.py`：使用 `CompatServerConfig.model_provider` 选择 `provider_name -> proc_fn(outcomming_request)` 映射，并且只在真正发出 downstream `/v1/chat/completions` 前 post-process；`StreamRouter` 内部继续保留 canonical payload，避免 tool hydration / mock web_search follow-up 被 provider 改写污染。
 - `pycodex` 默认是最小交互 CLI；无 prompt 时进入 REPL，并通过 `AgentRuntime` 跑外层提交循环。当前会显示最小事件流、assistant 流式输出、简单 title/history（`/title`, `/history`），并默认注册一组与原版一一对应的本地工具子集。
 - 交互 CLI 的事件流展示优先表达用户可感知的阶段（例如工具开始/完成、模型回看工具结果），不要直接把内部 `iteration` 计数暴露成主要状态文案；`iterations` 应继续保留在 `TurnResult` 等程序化结果里。
 - prompt/context 相关逻辑统一放在 `pycodex/context.py`：`AgentLoop` 只维护真实会话历史；每轮请求前由 `ContextManager` 注入 base instructions、developer message、`AGENTS.md` 指令和 `<environment_context>`，且这些注入项不写回 history。
+- 对需要 model-specific prompt 的本地 model slug，直接在 vendored `pycodex/prompts/models.json` 补条目；当前 `step-3.5-flash` / `step-3.5-flash-2603` 已按这个方式接入。
+- 交互 REPL 的 context 用量提示也应尽量贴近上游语义：展示“剩余 context 百分比”而不是原始 token 数；计算时按上游同款 `BASELINE_TOKENS=12000` 做归一化，并在模型元数据只有 `context_window` 时默认按 `95%` effective window 处理。只要当前模型能解析出 context window，初始 prompt 就先显示 `100%`，等首个 usage 回来后再刷新成真实值。
+- 对交互 REPL 的 context 指示器，`model_context_window` 的取值优先级也要贴近上游：先吃 `config.toml` / profile 里的 `model_context_window` override，再回退到 vendored `models.json` 的 `context_window`；effective percent 继续沿用模型元数据，没有时默认 `95%`。
 - `AgentLoop` 的 turn-loop 语义要跟上游 `codex-rs/core/src/codex.rs` 一致：按 follow-up / tool handoff 自然收敛，不要加固定 12 轮之类的 hard cap，也不要保留本地专用的 iteration-limit 参数。
 - `README.md` 和 `docs/` 属于对齐工作的一部分：只要实现状态、对齐结论或使用方式发生实质变化，就应及时更新，不要让文档滞后于当前代码。
 - 新工具必须继承 `BaseTool`，然后通过 `ToolRegistry.register(tool_instance)` 接入；不要再给 registry 传散装 name/description/handler 参数。
@@ -42,3 +46,5 @@
 - `--put` 的 CLI UX 现在约定为“先打印打包文件清单和上传目标，再打印结果”，并且最后一行保留为可直接执行的 `pycodex --call SECRET-CALLID@<host:port>` 一键启动命令；后续如果再改输出，尽量保留这个末行语义。
 - `--put` 现在不是“只上传就结束”：上传成功后还会立刻跑一次真实的 `--call` 下载/解包 round-trip 测试，只有这个测试也成功才算整个 `--put` 成功。排障时如果上传成功但 CLI 仍退出非零，要继续看 call 路径而不只看 put 端。
 - `--put` 现在会先做 `/healthz` preflight，再开始扫描/压缩目录；如果用户报“卡死”，先看目标 `host:port` 是否真有 storage server 在监听。默认打包策略也已经切到白名单：只带 `config.toml`、`.env`、`AGENTS.md`、`AGENTS.override.md`、`skills/**`，以及 config 里相对引用的 `model_instructions_file`，所以像 `sessions/` 这类运行态目录不会再靠黑名单排除。
+- 对接真实 `~/.codex/sessions/.../rollout-*.jsonl` 时，不要假设它一定是严格的一行一个 JSON object：本机样本可能包含 pretty-printed 多行对象，且文件尾部偶尔带未完成记录。恢复历史时用 concatenated-JSON 方式读取，并容忍尾部残缺。
+- `pycodex` 本地 session 保存现在也按上游思路走：新 session 一开始就分配稳定的 uuidv7 thread/session id，并把历史增量追加到 `CODEX_HOME/sessions/.../rollout-*.jsonl`；`/resume` 列表应只展示至少有真实 user message 的 rollout，避免空白新 session 污染恢复列表。

{python_codex-0.1.2 → python_codex-0.1.4}/PKG-INFO

@@ -1,16 +1,22 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: python-codex
-Version: 0.1.2
+Version: 0.1.4
 Summary: A minimal Python extraction of Codex's main agent loop
 License-File: LICENSE
-Requires-Python: >=3.10
-Requires-Dist: cryptography>=3.4
-Requires-Dist: fastapi>=0.115
+Requires-Python: >=3.6.2
+Requires-Dist: cryptography<41,>=40.0.2; python_version < '3.7'
+Requires-Dist: cryptography>=40.0.2; python_version >= '3.7'
+Requires-Dist: dataclasses>=0.8; python_version < '3.7'
+Requires-Dist: fastapi<0.84,>=0.83.0; python_version < '3.7'
+Requires-Dist: fastapi>=0.83.0; python_version >= '3.7'
+Requires-Dist: importlib-metadata>=4.8.3; python_version < '3.8'
 Requires-Dist: loguru>=0.7.3
-Requires-Dist: prompt-toolkit>=3.0
-Requires-Dist: requests>=2.31
-Requires-Dist: tomli>=2.0; python_version < '3.11'
-Requires-Dist: uvicorn>=0.32
+Requires-Dist: prompt-toolkit>=3.0.36
+Requires-Dist: requests>=2.27.1
+Requires-Dist: tomli<2,>=1.2.3; python_version < '3.11'
+Requires-Dist: typing-extensions>=4.1.1; python_version < '3.8'
+Requires-Dist: uvicorn<0.17,>=0.16.0; python_version < '3.7'
+Requires-Dist: uvicorn>=0.16.0; python_version >= '3.7'
 Description-Content-Type: text/markdown
 
 # pycodex
@@ -66,7 +72,7 @@ Intentionally not included yet:
 
 - TUI / streaming incremental rendering
 - MCP / connectors / sandbox / approvals
-- memory / compact / hooks / review mode
+- memory / compact / review mode
 - a full production OpenAI adapter surface
 
 All of those can be layered on later. For now, the project is focused on
@@ -168,9 +174,24 @@ Current behavior:
 - interactive mode shows a compact event stream for user-visible phases such as
   tool execution and model follow-up after tool results
 - assistant text is printed from streaming deltas directly
-- interactive mode supports `/history`, `/title`, and `/model`
+- interactive mode supports `/history`, `/title`, `/model`, `/resume`, and `/compact`
 - `/model <name>` switches the model used by later turns in the current
   interactive session; `/model` shows the current model and available choices
+- `/resume` with no argument lists the currently resumable sessions by their
+  first user-message preview; `/resume 1` resumes the first listed session
+- `/resume <number>` replaces the in-memory history with the selected recorded
+  Codex rollout from `CODEX_HOME/sessions`
+- `/compact` synthesizes a local handoff summary, replaces the in-memory
+  conversation history with the compacted view, and appends a compacted-history
+  entry to the rollout so later `/resume` sees the same state
+- new sessions are now recorded under `CODEX_HOME/sessions/.../rollout-*.jsonl`
+  with a stable session/thread id and per-item append+flush semantics so
+  `/resume` reads back the same rollout format
+- if `TURN_HOOK.md` exists in the workspace root and is non-empty, each
+  completed turn also forks the just-finished history into a temporary,
+  non-persisted follow-up session and submits the file contents as the next
+  user instruction; this is intended for side-effect follow-ups such as
+  Feishu notifications
 - steer is enabled by default in interactive mode: normal input goes into the
   runtime steer path, the current request stops at the next safe boundary, and
   later steer text is appended to the next model request's `input` in order;

{python_codex-0.1.2 → python_codex-0.1.4}/README.md

@@ -51,7 +51,7 @@ Intentionally not included yet:
 
 - TUI / streaming incremental rendering
 - MCP / connectors / sandbox / approvals
-- memory / compact / hooks / review mode
+- memory / compact / review mode
 - a full production OpenAI adapter surface
 
 All of those can be layered on later. For now, the project is focused on
@@ -153,9 +153,24 @@ Current behavior:
 - interactive mode shows a compact event stream for user-visible phases such as
   tool execution and model follow-up after tool results
 - assistant text is printed from streaming deltas directly
-- interactive mode supports `/history`, `/title`, and `/model`
+- interactive mode supports `/history`, `/title`, `/model`, `/resume`, and `/compact`
 - `/model <name>` switches the model used by later turns in the current
   interactive session; `/model` shows the current model and available choices
+- `/resume` with no argument lists the currently resumable sessions by their
+  first user-message preview; `/resume 1` resumes the first listed session
+- `/resume <number>` replaces the in-memory history with the selected recorded
+  Codex rollout from `CODEX_HOME/sessions`
+- `/compact` synthesizes a local handoff summary, replaces the in-memory
+  conversation history with the compacted view, and appends a compacted-history
+  entry to the rollout so later `/resume` sees the same state
+- new sessions are now recorded under `CODEX_HOME/sessions/.../rollout-*.jsonl`
+  with a stable session/thread id and per-item append+flush semantics so
+  `/resume` reads back the same rollout format
+- if `TURN_HOOK.md` exists in the workspace root and is non-empty, each
+  completed turn also forks the just-finished history into a temporary,
+  non-persisted follow-up session and submits the file contents as the next
+  user instruction; this is intended for side-effect follow-ups such as
+  Feishu notifications
 - steer is enabled by default in interactive mode: normal input goes into the
   runtime steer path, the current request stops at the next safe boundary, and
   later steer text is appended to the next model request's `input` in order;

{python_codex-0.1.2 → python_codex-0.1.4}/README_ZH.md

@@ -47,7 +47,7 @@ uv run pycodex
 
 - TUI / 流式增量渲染
 - MCP / connectors / sandbox / approvals
-- memory / compact / hooks / review mode
+- memory / compact / review mode
 - 真实 OpenAI 适配器
 
 这些都可以后续继续往上叠，但当前项目先把最核心的“工具增强推理主循环”钉住。
@@ -129,8 +129,18 @@ pycodex doctor
 - 交互模式下支持 `/exit` 和 `/quit`
 - 交互模式下会显示简洁阶段事件流，例如工具执行状态和模型回看工具结果
 - assistant 文本会按流式 delta 直接打印
-- 交互模式下支持 `/history`、`/title` 和 `/model`
+- 交互模式下支持 `/history`、`/title`、`/model` 和 `/resume`
 - `/model <name>` 会切换当前交互会话后续请求使用的模型；`/model` 会显示当前模型和可选模型
+- `/resume` 不带参数时会按首条用户消息预览列出当前可恢复的 session；`/resume 1`
+  会恢复列表里的第 1 个 session
+- `/resume <数字>` 会从 `CODEX_HOME/sessions` 读取选中的已记录 Codex rollout，
+  并直接替换当前内存里的会话 history
+- 新 session 现在会自动保存到 `CODEX_HOME/sessions/.../rollout-*.jsonl`，
+  使用稳定的 session/thread id，并按 item 级别 append + flush，和 `/resume`
+  读取的 rollout 格式保持一致
+- 如果 workspace 根目录存在非空的 `TURN_HOOK.md`，每个已完成 turn 之后都会把
+  刚结束的 history fork 成一个不落盘的临时 follow-up 会话，并把文件内容作为下一条
+  user 指令提交；适合做 Feishu 通知这类副作用收尾动作
 - 交互模式默认支持 steer：普通输入会走 runtime 的 steer 路径，当前请求会在下一个安全边界尽快停下，后续 steer 文本会按顺序并入下一次模型请求的 `input`；如需明确排队可用 `/queue <message>`，会打印 `[steer] queued: ...`，随后等该 turn 真正开始时再打印 `[steer] inserted: ...`
 - 当前默认注册一组与原版 Codex 一一对应的本地工具子集：`shell`、`shell_command`、`exec_command`、`write_stdin`、`exec`、`wait`、`web_search`、`update_plan`、`request_user_input`、`request_permissions`、`spawn_agent`、`send_input`、`resume_agent`、`wait_agent`、`close_agent`、`apply_patch`、`grep_files`、`read_file`、`list_dir`、`view_image`
 - `--vllm-endpoint http://host:port` 会自动拉起一个本地 `responses_server` compat 层；当 path 为空时会内部补 `/v1`，继续把 `/responses` 请求转到下游 `/v1/chat/completions`。当前对 `model_provider = "vllm"` 已补上 reasoning 兼容：会把 chat chunk 里的 `reasoning` / `reasoning_content` 翻回 Responses `reasoning` item，并把历史里的 `reasoning` item 回放成下游 assistant message 的 `reasoning` 字段；同时会向 vLLM 请求 streaming usage，并在最终 `response.completed.response.usage` 中回传

{python_codex-0.1.2 → python_codex-0.1.4}/docs/ALIGNMENT.md

@@ -549,3 +549,29 @@ Those are the next alignment target after the prompt/context pass.
 - 因此，下一次请求体里的 `input` 现在可以把多个 steer 文本按顺序并到 history 尾部，并且继续沿用同一个 `turn_id`；这一点已经明显比旧版 `cancel + 单条新 turn` 更接近 upstream
 - 通过 `tests/compare_steer_request_bodies.py` 的 fake/proxy capture 对比，当前 steer 首轮/次轮 request body 在忽略 `prompt_cache_key` 后已与本机 installed `codex-cli 0.115.0` 对齐；这里比较的是“默认 steer”路径，因此脚本会先去掉本机用户配置里的顶层 `service_tier`，避免把本地 fast-mode 设置误记成 steer 差异。同一 steer turn 的 follow-up request 仍需继续带 `workspaces`
 - 仍未完全一致的点主要是内部控制流：本地实现仍是在 runtime 层结束一次 `run_turn(...)` 再启动下一次；upstream 则更倾向于在同一个 active turn 里继续 follow-up
+
+## timeout / interrupt 对齐现状
+
+- `pycodex` 现在已经补上最小的 provider 级 stream retry：`ResponsesProviderConfig`
+  支持 `stream_max_retries` / `stream_idle_timeout_ms`，默认值对齐 upstream 的
+  `5` 次重试和 `300_000 ms` SSE idle timeout；代码在 `pycodex/model.py`
+- 当前实现会把 `response.failed`、stream 在 `response.completed` 前断开、以及
+  `requests` 侧的读流异常统一视为 retryable stream error，并在
+  `ResponsesModelClient.complete(...)` 里按 backoff 重试；重试前会向外发
+  `ModelStreamEvent(kind="stream_error")`，CLI 会显示 `[status] Reconnecting...`
+- 这一点已经明显更接近 upstream 在 `run_sampling_request(...)` 里对
+  `CodexErr::Stream(...)` / `CodexErr::Timeout` 的 backoff retry + `StreamError`
+  前端通知语义；对应参考仍在 `core/src/model_provider_info.rs`、
+  `codex-api/src/sse/responses.rs`、`core/src/codex.rs`
+- 还没对齐的点主要有两类：
+  - retry 目前是在 Python `ResponsesModelClient` 内部完成，不像 upstream 那样放在更外层的
+    sampling loop，并复用统一的 `CodexErr::is_retryable()` 分类
+  - 还没有 upstream 的 WebSocket transport / HTTP fallback，因此也没有
+    “超过 WS retry 预算后切到 HTTP” 的那层行为
+- 中断语义也还不一样：upstream 普通“steer/user input”优先走
+  `inject_input(...)` -> `pending_input`，只有显式 interrupt 才会真正取消当前 task；
+  取消时会通过 `CancellationToken` 中止活跃请求/工具，终止 unified-exec 进程，并把
+  `<turn_aborted>` marker 持久化到 history
+- `pycodex` 当前 steer 仍主要靠 `AgentLoop.interrupt_asap` 在 loop 边界抛
+  `TurnInterrupted`；它不会主动打断正在阻塞的模型流读取或正在运行的 tool，也不会写
+  `<turn_aborted>` marker，因此 interrupt 语义仍明显弱于 upstream

{python_codex-0.1.2 → python_codex-0.1.4}/docs/responses_server/README.md

@@ -25,6 +25,7 @@
 - vLLM chat-completions `reasoning` / `reasoning_content` -> Responses `reasoning` item 适配
 - vLLM 历史 `reasoning` item -> assistant message `reasoning` 字段回放
 - vLLM streaming `usage` -> final `response.completed.response.usage`
+- 下游 chat stream 如果半路断开，会转成上游可解析的 `response.failed` 事件，而不是直接截断 HTTP body
 - 普通 function tools
 - custom tools 的 function-wrapper 兼容适配
 - mock `web_search` 接口对齐（返回空结果）

{python_codex-0.1.2 → python_codex-0.1.4}/pycodex/__init__.py

@@ -1,3 +1,7 @@
+from .compat import patch_asyncio
+
+patch_asyncio()
+
 from .agent import AgentLoop
 from .context import ContextConfig, ContextManager
 from .model import (
@@ -60,7 +64,7 @@ from .tools import (
     WriteStdinTool,
 )
 
-def debug(stop: bool = False):
+def debug(stop: 'bool' = False):
 
     import socket
 

{python_codex-0.1.2 → python_codex-0.1.4}/pycodex/agent.py

@@ -1,8 +1,7 @@
-from __future__ import annotations
 
 import asyncio
 import json
-from collections.abc import Callable
+from typing import Callable
 
 from .context import ContextManager
 from .model import ModelClient
@@ -19,10 +18,14 @@ from .protocol import (
 )
 from .tools import ToolContext, ToolRegistry
 from .utils import uuid7_string
+import typing
+
+if typing.TYPE_CHECKING:
+    from .utils.session_persist import SessionRolloutRecorder
 
 
 EventHandler = Callable[[AgentEvent], None]
-NOOP_EVENT_HANDLER: EventHandler = lambda _event: None
+NOOP_EVENT_HANDLER: 'EventHandler' = lambda _event: None
 
 
 class TurnInterrupted(RuntimeError):
@@ -40,51 +43,66 @@ class AgentLoop:
 
     def __init__(
         self,
-        model_client: ModelClient,
-        tool_registry: ToolRegistry,
-        context_manager: ContextManager | None = None,
-        parallel_tool_calls: bool = True,
-        event_handler: EventHandler = NOOP_EVENT_HANDLER,
-        initial_history: tuple[ConversationItem, ...] = (),
-    ) -> None:
+        model_client: 'ModelClient',
+        tool_registry: 'ToolRegistry',
+        context_manager: 'typing.Union[ContextManager, None]' = None,
+        parallel_tool_calls: 'bool' = True,
+        event_handler: 'EventHandler' = NOOP_EVENT_HANDLER,
+        initial_history: 'typing.Tuple[ConversationItem, ...]' = (),
+        rollout_recorder: 'typing.Union[SessionRolloutRecorder, None]' = None,
+    ) -> 'None':
         self._model_client = model_client
         self._tool_registry = tool_registry
         self._context_manager = context_manager or ContextManager()
         self._parallel_tool_calls = parallel_tool_calls
         self._event_handler = event_handler
-        self._history: list[ConversationItem] = list(initial_history)
+        self._history: 'typing.List[ConversationItem]' = list(initial_history)
+        self._rollout_recorder = rollout_recorder
         self.interrupt_asap = False
 
     @property
-    def history(self) -> tuple[ConversationItem, ...]:
+    def history(self) -> 'typing.Tuple[ConversationItem, ...]':
         return tuple(self._history)
 
     def set_event_handler(
-        self, event_handler: EventHandler = NOOP_EVENT_HANDLER
-    ) -> None:
+        self, event_handler: 'EventHandler' = NOOP_EVENT_HANDLER
+    ) -> 'None':
         self._event_handler = event_handler
 
+    def replace_history(
+        self,
+        history: 'typing.Iterable[ConversationItem]',
+    ) -> 'None':
+        self._history = list(history)
+
+    def set_rollout_recorder(
+        self,
+        rollout_recorder: 'typing.Union[SessionRolloutRecorder, None]',
+    ) -> 'None':
+        self._rollout_recorder = rollout_recorder
+
     def _raise_if_interrupt_requested(
         self,
-        turn_id: str,
-        iteration: int,
-        output_text: str | None = None,
-    ) -> None:
+        turn_id: 'str',
+        iteration: 'int',
+        output_text: 'typing.Union[str, None]' = None,
+    ) -> 'None':
         if self.interrupt_asap:
             self.interrupt_asap = False
-            payload: dict[str, object] = {"iteration": iteration}
+            payload: 'typing.Dict[str, object]' = {"iteration": iteration}
             if output_text is not None:
                 payload["output_text"] = output_text
             self._emit("turn_interrupted", turn_id, **payload)
             raise TurnInterrupted("turn interrupted")
 
     async def run_turn(
-        self, texts: list[str], turn_id: str | None = None
-    ) -> TurnResult:
+        self, texts: 'typing.List[str]', turn_id: 'typing.Union[str, None]' = None
+    ) -> 'TurnResult':
         turn_id = turn_id or uuid7_string()
         self.interrupt_asap = False
-        for text in texts:
-            self._history.append(UserMessage(text=text))
+        new_user_messages = [UserMessage(text=text) for text in texts]
+        self._history.extend(new_user_messages)
+        self._persist_history_items(new_user_messages)
 
         self._emit(
             "turn_started",
@@ -93,10 +111,8 @@ class AgentLoop:
             user_texts=list(texts),
         )
 
-        last_assistant_message: str | None = None
-        final_response_items: tuple[
-            AssistantMessage | ToolCall | ReasoningItem, ...
-        ] = ()
+        last_assistant_message: 'typing.Union[str, None]' = None
+        final_response_items: 'typing.Tuple[\n    typing.Union[typing.Union[AssistantMessage, ToolCall], ReasoningItem], ...\n]' = ()
 
         iteration = 0
         try:
@@ -132,13 +148,16 @@ class AgentLoop:
                     item_count=len(response.items),
                 )
 
-                tool_calls: list[ToolCall] = []
+                tool_calls: 'typing.List[ToolCall]' = []
+                persisted_response_items: 'typing.List[ConversationItem]' = []
                 for item in response.items:
                     self._history.append(item)
+                    persisted_response_items.append(item)
                     if isinstance(item, AssistantMessage):
                         last_assistant_message = item.text
                     elif isinstance(item, ToolCall):
                         tool_calls.append(item)
+                self._persist_history_items(persisted_response_items)
 
                 if not tool_calls:
                     self._raise_if_interrupt_requested(
@@ -162,7 +181,10 @@ class AgentLoop:
 
                 tool_results = await self._execute_tool_batch(turn_id, tool_calls)
                 self._history.extend(tool_results)
-                self._history.extend(self._build_follow_up_messages(tool_results))
+                self._persist_history_items(tool_results)
+                follow_up_messages = self._build_follow_up_messages(tool_results)
+                self._history.extend(follow_up_messages)
+                self._persist_history_items(follow_up_messages)
                 self._raise_if_interrupt_requested(
                     turn_id,
                     iteration,
@@ -182,11 +204,11 @@ class AgentLoop:
 
     async def _execute_tool_batch(
         self,
-        turn_id: str,
-        tool_calls: list[ToolCall],
-    ) -> list[ToolResult]:
-        results: list[ToolResult] = []
-        parallel_batch: list[ToolCall] = []
+        turn_id: 'str',
+        tool_calls: 'typing.List[ToolCall]',
+    ) -> 'typing.List[ToolResult]':
+        results: 'typing.List[ToolResult]' = []
+        parallel_batch: 'typing.List[ToolCall]' = []
 
         for call in tool_calls:
             can_run_parallel = (
@@ -224,11 +246,16 @@ class AgentLoop:
 
     async def _run_single_tool(
         self,
-        turn_id: str,
-        call: ToolCall,
-        prior_results: tuple[ToolResult, ...] = (),
-    ) -> ToolResult:
-        self._emit("tool_started", turn_id, tool_name=call.name, call_id=call.call_id)
+        turn_id: 'str',
+        call: 'ToolCall',
+        prior_results: 'typing.Tuple[ToolResult, ...]' = (),
+    ) -> 'ToolResult':
+        payload: 'typing.Dict[str, object]' = {
+            "tool_name": call.name,
+            "call_id": call.call_id,
+            "call": call,
+        }
+        self._emit("tool_started", turn_id, **payload)
         result = await self._tool_registry.execute(
             call,
             ToolContext(
@@ -237,32 +264,43 @@ class AgentLoop:
                 collaboration_mode=self._context_manager.collaboration_mode,
             ),
         )
-        payload: dict[str, object] = {
-            "tool_name": call.name,
-            "call_id": call.call_id,
-            "is_error": result.is_error,
-            "call": call,
-            "result": result,
-        }
+        payload["result"] = result
+        payload["is_error"] = result.is_error
         self._emit("tool_completed", turn_id, **payload)
         return result
 
-    def _emit(self, kind: str, turn_id: str, **payload: object) -> None:
+    def _emit(self, kind: 'str', turn_id: 'str', **payload: 'object') -> 'None':
         self._event_handler(
             AgentEvent(kind=kind, turn_id=turn_id, payload=dict(payload))
         )
 
-    def _handle_model_stream_event(self, turn_id: str, event: ModelStreamEvent) -> None:
+    def _persist_history_items(
+        self,
+        items: 'typing.Iterable[ConversationItem]',
+    ) -> 'None':
+        recorder = self._rollout_recorder
+        if recorder is None:
+            return
+        try:
+            recorder.append_history_items(items)
+        except Exception:  # pragma: no cover - persistence should not break turns
+            return
+
+    def _handle_model_stream_event(self, turn_id: 'str', event: 'ModelStreamEvent') -> 'None':
         if event.kind == "assistant_delta":
             self._emit("assistant_delta", turn_id, **event.payload)
         elif event.kind == "tool_call":
             self._emit("tool_called", turn_id, **event.payload)
+        elif event.kind == "token_count":
+            self._emit("token_count", turn_id, **event.payload)
+        elif event.kind == "stream_error":
+            self._emit("stream_error", turn_id, **event.payload)
 
     def _build_follow_up_messages(
         self,
-        tool_results: list[ToolResult],
-    ) -> list[UserMessage]:
-        follow_ups: list[UserMessage] = []
+        tool_results: 'typing.List[ToolResult]',
+    ) -> 'typing.List[UserMessage]':
+        follow_ups: 'typing.List[UserMessage]' = []
         for result in tool_results:
             statuses = None
             if (