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

{python_codex-0.1.3 → 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.3 → python_codex-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-codex
-Version: 0.1.3
+Version: 0.1.4
 Summary: A minimal Python extraction of Codex's main agent loop
 License-File: LICENSE
 Requires-Python: >=3.6.2
@@ -72,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
@@ -174,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.3 → 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.3 → 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.3 → 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.3 → 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.3 → python_codex-0.1.4}/pycodex/agent.py

@@ -20,6 +20,9 @@ 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
@@ -46,6 +49,7 @@ class AgentLoop:
         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
@@ -53,6 +57,7 @@ class AgentLoop:
         self._parallel_tool_calls = parallel_tool_calls
         self._event_handler = event_handler
         self._history: 'typing.List[ConversationItem]' = list(initial_history)
+        self._rollout_recorder = rollout_recorder
         self.interrupt_asap = False
 
     @property
@@ -64,6 +69,18 @@ class AgentLoop:
     ) -> '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',
@@ -83,8 +100,9 @@ class AgentLoop:
     ) -> '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",
@@ -131,12 +149,15 @@ class AgentLoop:
                 )
 
                 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(
@@ -160,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,
@@ -226,7 +250,12 @@ class AgentLoop:
         call: 'ToolCall',
         prior_results: 'typing.Tuple[ToolResult, ...]' = (),
     ) -> 'ToolResult':
-        self._emit("tool_started", turn_id, tool_name=call.name, call_id=call.call_id)
+        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(
@@ -235,13 +264,8 @@ class AgentLoop:
                 collaboration_mode=self._context_manager.collaboration_mode,
             ),
         )
-        payload: 'typing.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
 
@@ -250,11 +274,27 @@ class AgentLoop:
             AgentEvent(kind=kind, turn_id=turn_id, payload=dict(payload))
         )
 
+    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,

{python_codex-0.1.3 → python_codex-0.1.4}/pycodex/cli.py

@@ -20,7 +20,15 @@ from .portable import bootstrap_called_home, upload_codex_home
 from .protocol import AgentEvent
 from .runtime import AgentRuntime
 from .runtime_services import RuntimeEnvironment, create_runtime_environment
-from .utils import CliSessionView, load_codex_dotenv
+from .utils import CliSessionView, load_codex_dotenv, uuid7_string
+from .utils.compactor import compact_agent_loop
+from .utils.session_persist import (
+    SessionRolloutRecorder,
+    conversation_history_to_turns,
+    list_resumable_sessions,
+    load_resumed_session,
+    resolve_codex_home,
+)
 import typing
 
 EXIT_COMMANDS = {"/exit", "/quit"}
@@ -28,6 +36,8 @@ HISTORY_COMMAND = "/history"
 TITLE_COMMAND = "/title"
 MODEL_COMMAND = "/model"
 QUEUE_COMMAND = "/queue"
+RESUME_COMMAND = "/resume"
+COMPACT_COMMAND = "/compact"
 CliSessionMode = Literal["exec", "tui"]
 LOCAL_RESPONSES_SERVER_API_KEY_ENV = "PYCODEX_LOCAL_RESPONSES_SERVER_KEY"
 CLI_ORIGINATOR = "codex-tui"
@@ -284,6 +294,9 @@ def build_runtime(
         collaboration_mode=collaboration_mode,
         include_collaboration_instructions=use_tui_context,
     )
+    session_id = getattr(client, "_session_id", None) or uuid7_string()
+    if hasattr(client, "_session_id"):
+        client._session_id = session_id
     subagent_context_manager = ContextManager.from_codex_config(
         config_path,
         profile,
@@ -293,6 +306,14 @@ def build_runtime(
     runtime_environment = create_runtime_environment()
     runtime_environment.request_user_input_manager.set_handler(None)
     runtime_environment.request_permissions_manager.set_handler(None)
+    rollout_recorder = SessionRolloutRecorder.create(
+        resolve_codex_home(config_path),
+        session_id,
+        context_manager.cwd,
+        getattr(client, "_originator", CLI_ORIGINATOR),
+        getattr(getattr(client, "_config", None), "provider_name", None),
+        context_manager.resolve_base_instructions(),
+    )
 
     def make_subagent_runtime_builder(base_client):
         def build_subagent_runtime(
@@ -330,7 +351,10 @@ def build_runtime(
     )
     return AgentRuntime(
         AgentLoop(
-            client, get_tools(runtime_environment, exec_mode=True), context_manager
+            client,
+            get_tools(runtime_environment, exec_mode=True),
+            context_manager,
+            rollout_recorder=rollout_recorder,
         ),
         runtime_environment=runtime_environment,
     )
@@ -498,10 +522,14 @@ async def prompt_request_permissions(
 async def run_interactive_session(
     runtime: 'AgentRuntime',
     json_mode: 'bool',
+    config_path: 'typing.Union[str, None]' = None,
 ) -> 'int':
     worker = asyncio.create_task(runtime.run_forever())
+    context_window_tokens = runtime._agent_loop._context_manager.resolve_model_context_window()
     view = CliSessionView()
+    view.set_context_window_tokens(context_window_tokens)
     model_client = runtime._agent_loop._model_client
+    codex_home = resolve_codex_home(config_path)
     runtime.set_event_handler(view.handle_event)
     pending_turn_tasks: 'typing.Set[asyncio.Task[None]]' = set()
     runtime_environment = runtime.runtime_environment
@@ -515,7 +543,7 @@ async def run_interactive_session(
         lambda payload: prompt_request_permissions(view, payload)
     )
     view.write_line("pycodex interactive mode. Type /exit to quit.")
-    view.write_line("Extra commands: /history, /title, /model")
+    view.write_line("Extra commands: /history, /title, /model, /resume, /compact")
     try:
 
         def has_pending_turn_tasks() -> 'bool':
@@ -524,6 +552,39 @@ async def run_interactive_session(
             )
             return bool(pending_turn_tasks)
 
+        async def run_manual_compact() -> 'None':
+            agent_loop = runtime._agent_loop
+            if not agent_loop.history:
+                view.write_line("Nothing to compact.")
+                return
+
+            compact_turn_id = uuid7_string()
+
+            def handle_compact_stream_event(event) -> 'None':
+                if event.kind not in {"token_count", "stream_error"}:
+                    return
+                view.handle_event(
+                    AgentEvent(
+                        kind=event.kind,
+                        turn_id=compact_turn_id,
+                        payload=dict(event.payload),
+                    )
+                )
+
+            view.write_line("Compacting conversation history...")
+            compact_result = await compact_agent_loop(
+                agent_loop,
+                handle_compact_stream_event,
+            )
+            if compact_result is None:
+                view.write_line("Nothing to compact.")
+                return
+            view.load_session_history(
+                getattr(view, "_title", None),
+                conversation_history_to_turns(compact_result.history),
+            )
+            view.write_line(compact_result.display_text())
+
         async def wait_for_turn_result(future) -> 'None':
             try:
                 result = await future
@@ -556,6 +617,50 @@ async def run_interactive_session(
             if prompt_text == TITLE_COMMAND:
                 view.show_title()
                 continue
+            if prompt_text == RESUME_COMMAND:
+                sessions = list_resumable_sessions(codex_home)
+                if not sessions:
+                    view.write_line("No resumable sessions found.")
+                    continue
+                view.write_line("Available sessions:")
+                for index, session in enumerate(sessions, start=1):
+                    view.write_line(f"[{index}] {session['preview']}")
+                continue
+            if prompt_text.startswith(f"{RESUME_COMMAND} "):
+                if has_pending_turn_tasks():
+                    view.write_line(
+                        "Cannot resume while work is running or queued."
+                    )
+                    continue
+                resume_target = prompt_text[len(RESUME_COMMAND) :].strip()
+                try:
+                    resumed = load_resumed_session(codex_home, resume_target)
+                    runtime._agent_loop.replace_history(resumed["history"])
+                    if hasattr(model_client, "_session_id"):
+                        model_client._session_id = str(resumed["session_id"])
+                    runtime._agent_loop.set_rollout_recorder(
+                        SessionRolloutRecorder.resume(resumed["rollout_path"])
+                    )
+                    view.load_session_history(
+                        str(resumed["title"]),
+                        tuple(resumed["turns"]),
+                    )
+                    view.write_line(f"Resumed session: {resumed['title']}")
+                    view.show_history()
+                except Exception as exc:  # pragma: no cover - defensive surface
+                    view.show_error(str(exc))
+                continue
+            if prompt_text == COMPACT_COMMAND:
+                if has_pending_turn_tasks():
+                    view.write_line(
+                        "Cannot compact while work is running or queued."
+                    )
+                    continue
+                try:
+                    await run_manual_compact()
+                except Exception as exc:  # pragma: no cover - defensive surface
+                    view.show_error(str(exc))
+                continue
             if prompt_text.startswith(f"{QUEUE_COMMAND} "):
                 queued_text = prompt_text[len(QUEUE_COMMAND) :].strip()
                 if not queued_text:
@@ -663,6 +768,7 @@ async def run_cli(args: 'argparse.Namespace') -> 'int':
             return await run_interactive_session(
                 runtime,
                 args.json,
+                args.config,
             )
         else:
             prompt_text = resolve_prompt_text(args.prompt)

{python_codex-0.1.3 → python_codex-0.1.4}/pycodex/context.py

@@ -30,6 +30,7 @@ DEFAULT_COLLABORATION_INSTRUCTIONS_PATH = (
 PLAN_COLLABORATION_INSTRUCTIONS_PATH = (
     Path(__file__).resolve().parent / "prompts" / "collaboration_plan.md"
 )
+DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT = 95
 PERMISSIONS_SANDBOX_PROMPTS_PATH = (
     Path(__file__).resolve().parent / "prompts" / "permissions" / "sandbox_mode"
 )
@@ -76,6 +77,7 @@ class ContextConfig:
     codex_home: 'typing.Union[Path, None]' = None
     project_doc_max_bytes: 'typing.Union[int, None]' = None
     model: 'typing.Union[str, None]' = None
+    model_context_window: 'typing.Union[int, None]' = None
     personality: 'typing.Union[str, None]' = None
     approval_policy: 'typing.Union[str, None]' = None
     sandbox_mode: 'typing.Union[str, None]' = None
@@ -117,6 +119,7 @@ class ContextConfig:
             codex_home=codex_home,
             project_doc_max_bytes=_normalize_int(selected.get("project_doc_max_bytes")),
             model=_normalize_text(selected.get("model")),
+            model_context_window=_normalize_int(selected.get("model_context_window")),
             personality=_normalize_text(selected.get("personality")),
             approval_policy=_normalize_text(selected.get("approval_policy")),
             sandbox_mode=_normalize_text(selected.get("sandbox_mode")),
@@ -240,6 +243,26 @@ class ContextManager:
             return resolved
         return self._default_base_instructions
 
+    def resolve_model_context_window(self) -> 'typing.Union[int, None]':
+        model_metadata = None
+        model_slug = self._config.model
+        if model_slug is not None:
+            model_metadata = _load_models_by_slug().get(model_slug)
+
+        context_window = self._config.model_context_window
+        if context_window is None and model_metadata is not None:
+            context_window = _normalize_int(model_metadata.get("context_window"))
+        if context_window is None:
+            return None
+        effective_percent = None
+        if model_metadata is not None:
+            effective_percent = _normalize_int(
+                model_metadata.get("effective_context_window_percent")
+            )
+        if effective_percent is None:
+            effective_percent = DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT
+        return context_window * max(effective_percent, 0) // 100
+
     def _resolve_model_instructions(self) -> 'typing.Union[str, None]':
         model_slug = self._config.model
         if model_slug is None: