python-codex 0.1.12__tar.gz → 0.1.13__tar.gz

{python_codex-0.1.12 → python_codex-0.1.13}/.gitignore

@@ -5,3 +5,4 @@ __pycache__/
 .tmp/
 .pycodex-storage/
 uv.lock
+.vscode/

{python_codex-0.1.12 → python_codex-0.1.13}/AGENTS.md

@@ -23,7 +23,7 @@
 - 对需要 model-specific prompt 的本地 model slug，直接在 vendored `pycodex/prompts/models.json` 补条目；当前 `step-3.5-flash` / `step-3.5-flash-2603` / `step-3.6` 已按这个方式接入。
 - 交互 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%`。
-- `pyco(<percent>)` 正常只来自模型流里最近一次 `response.completed.response.usage.total_tokens`；如果大 tool output 之后的下一次请求被下游 `context_length_exceeded` 拒绝，rollout 不会单独记录 usage。遇到这类错误时应从错误文案的 `requested ... tokens (... in the messages, ... in the completion)` 提取真实请求 token，作为失败请求的 `token_count` 事件回灌，并立即触发 compact 后重试一次。若 compact 请求本身也超长，先循环删除最旧的 `ToolResult` 及其配对 `ToolCall` 再重试 compact。
+- `pyco(<percent>)` 正常只来自模型流里最近一次 `response.completed.response.usage.total_tokens`；如果大 tool output 之后的下一次请求被下游 `context_length_exceeded` 拒绝，rollout 不会单独记录 usage。遇到这类错误时应从错误文案的 `requested ... tokens (... in the messages, ... in the completion)` 提取真实请求 token，作为失败请求的 `token_count` 事件回灌，并立即触发 compact 后重试一次。若服务端只返回 `Your input exceeds the context window...` 这类无 token 数的 `response.failed`，仍应触发 compact+retry，只是不要伪造 `token_count`。若 compact 请求本身也超长，先循环删除最旧的 `ToolResult` 及其配对 `ToolCall` 再重试 compact。
 - `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 参数。
@@ -57,3 +57,5 @@
 - 对接真实 `~/.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 污染恢复列表。
 - auto-compact 对齐上游配置名 `model_auto_compact_token_limit`；为空时关闭，触发依据是最近一次模型上报的 `usage.total_tokens`，pre-turn 压缩上一轮历史，mid-turn 压缩工具 follow-up 前的当前历史，并继续复用现有 compacted rollout 记录。
+- Responses streaming 里的 `response.incomplete` 不是连接断开：不要让 `ResponsesModelClient` 把它当 retryable incomplete stream 反复重连。普通 turn 应明确报 `response.incomplete`；compact 请求如果已经收到 assistant partial summary，可以用这个 partial summary 完成 replacement history，避免 midturn auto-compact 卡在 5 次 retry。
+- Feishu card tests read `~/.codex/.feishu_refresh_token` through production code; when running `tests/test_feishu_card.py` locally, isolate HOME (for example `HOME=/tmp/pycodex-empty-home env -u VIRTUAL_ENV uv run pytest tests/test_feishu_card.py tests/test_feishu_link.py`) unless the test itself controls `HOME`.

{python_codex-0.1.12 → python_codex-0.1.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-codex
-Version: 0.1.12
+Version: 0.1.13
 Summary: A minimal Python extraction of Codex's main agent loop
 License-File: LICENSE
 Requires-Python: >=3.6.2

{python_codex-0.1.12 → python_codex-0.1.13}/docs/ALIGNMENT.md

@@ -554,7 +554,7 @@ Those are the next alignment target after the prompt/context pass.
 
 - `pycodex` 现在已经补上最小的 provider 级 stream retry：`ResponsesProviderConfig`
   支持 `stream_max_retries` / `stream_idle_timeout_ms`，默认值对齐 upstream 的
-  `5` 次重试和 `300_000 ms` SSE idle timeout；代码在 `pycodex/model.py`
+  `300_000 ms` SSE idle timeout；代码在 `pycodex/model.py`
 - 当前实现会把 `response.failed`、stream 在 `response.completed` 前断开、以及
   `requests` 侧的读流异常统一视为 retryable stream error，并在
   `ResponsesModelClient.complete(...)` 里按 backoff 重试；重试前会向外发

{python_codex-0.1.12 → python_codex-0.1.13}/pycodex/__init__.py

@@ -2,12 +2,13 @@ from .compat import patch_asyncio
 
 patch_asyncio()
 
-from .agent import AgentLoop
+from .agent import Agent
 from .context import ContextConfig, ContextManager
 from .model import (
     ModelClient,
     NOOP_MODEL_STREAM_EVENT_HANDLER,
     ResponsesApiError,
+    ResponsesIncompleteError,
     ResponsesModelClient,
     ResponsesProviderConfig,
 )
@@ -26,14 +27,14 @@ from .protocol import (
     TurnResult,
     UserMessage,
 )
-from .runtime import AgentRuntime
+from .runtime import CliSubmissionQueue
 from .runtime_services import (
     PlanStore,
     RequestPermissionsManager,
     RequestUserInputManager,
     SubAgentManager,
-    create_runtime_environment,
-    get_runtime_environment,
+    create_agent_runtime_environment,
+    get_agent_runtime_environment,
 )
 from .tools import (
     ApplyPatchTool,
@@ -90,13 +91,13 @@ def debug(stop: 'bool' = False):
 
 __all__ = [
     "AgentEvent",
-    "AgentLoop",
-    "AgentRuntime",
+    "Agent",
+    "CliSubmissionQueue",
     "ApplyPatchTool",
     "AssistantMessage",
     "BaseTool",
     "CloseAgentTool",
-    "create_runtime_environment",
+    "create_agent_runtime_environment",
     "CodeModeManager",
     "ContextConfig",
     "ContextManager",
@@ -120,6 +121,7 @@ __all__ = [
     "RequestUserInputManager",
     "ResumeAgentTool",
     "ResponsesApiError",
+    "ResponsesIncompleteError",
     "ResponsesModelClient",
     "ResponsesProviderConfig",
     "SendInputTool",
@@ -142,5 +144,5 @@ __all__ = [
     "WaitTool",
     "WebSearchTool",
     "WriteStdinTool",
-    "get_runtime_environment",
+    "get_agent_runtime_environment",
 ]

{python_codex-0.1.12 → python_codex-0.1.13}/pycodex/agent.py

@@ -23,10 +23,11 @@ import typing
 
 if typing.TYPE_CHECKING:
     from .utils.session_persist import SessionRolloutRecorder
+    from .runtime_services import AgentRuntimeEnvironment
 
 
 EventHandler = Callable[[AgentEvent], None]
-NOOP_EVENT_HANDLER: 'EventHandler' = lambda _event: None
+BASE_EVENT_HANDLER: 'EventHandler' = lambda _event: None
 _REQUESTED_TOKENS_RE = re.compile(
     r"requested\s+([0-9,]+)\s+tokens",
     re.IGNORECASE,
@@ -39,13 +40,19 @@ _MAX_CONTEXT_TOKENS_RE = re.compile(
     r"maximum\s+context\s+length\s+is\s+([0-9,]+)\s+tokens",
     re.IGNORECASE,
 )
+_CONTEXT_LENGTH_ERROR_MARKERS = (
+    "context_length_exceeded",
+    "maximum context length",
+    "exceeds the context window",
+    "exceeded the context window",
+)
 
 
 class TurnInterrupted(RuntimeError):
     pass
 
 
-class AgentLoop:
+class Agent:
     """Minimal Python port of Codex's turn loop.
 
     The core idea mirrors the Rust implementation:
@@ -60,9 +67,10 @@ class AgentLoop:
         tool_registry: 'ToolRegistry',
         context_manager: 'typing.Union[ContextManager, None]' = None,
         parallel_tool_calls: 'bool' = True,
-        event_handler: 'EventHandler' = NOOP_EVENT_HANDLER,
+        event_handler: 'EventHandler' = BASE_EVENT_HANDLER,
         initial_history: 'typing.Tuple[ConversationItem, ...]' = (),
         rollout_recorder: 'typing.Union[SessionRolloutRecorder, None]' = None,
+        runtime_environment: 'AgentRuntimeEnvironment' = None,
     ) -> 'None':
         self._model_client = model_client
         self._tool_registry = tool_registry
@@ -75,6 +83,7 @@ class AgentLoop:
             self._context_manager.resolve_auto_compact_token_limit()
         )
         self._last_total_usage_tokens: 'typing.Union[int, None]' = None
+        self.runtime_environment = runtime_environment
         self.interrupt_asap = False
 
     @property
@@ -82,7 +91,7 @@ class AgentLoop:
         return tuple(self._history)
 
     def set_event_handler(
-        self, event_handler: 'EventHandler' = NOOP_EVENT_HANDLER
+        self, event_handler: 'EventHandler' = BASE_EVENT_HANDLER
     ) -> 'None':
         self._event_handler = event_handler
 
@@ -98,6 +107,11 @@ class AgentLoop:
     ) -> 'None':
         self._rollout_recorder = rollout_recorder
 
+    def ask(self, text: 'str') -> 'TurnResult':
+        from .utils.async_bridge import run_async
+
+        return run_async(self.run_turn([text]))
+
     def _raise_if_interrupt_requested(
         self,
         turn_id: 'str',
@@ -342,17 +356,26 @@ class AgentLoop:
                     lambda event: self._handle_model_stream_event(turn_id, event),
                 )
             except Exception as exc:
-                context_usage = _usage_from_context_length_error(str(exc))
-                if context_usage is None or attempted_context_compact:
+                error_message = str(exc)
+                if (
+                    not _is_context_length_error_message(error_message)
+                    or attempted_context_compact
+                ):
                     raise
                 attempted_context_compact = True
-                self._remember_token_usage(context_usage)
-                self._emit("token_count", turn_id, usage=context_usage)
+                context_usage = _usage_from_context_length_error(error_message)
+                if context_usage is not None:
+                    self._remember_token_usage(context_usage)
+                    self._emit("token_count", turn_id, usage=context_usage)
                 await self._run_auto_compact(
                     turn_id,
                     phase="context_length_exceeded",
-                    total_tokens=context_usage.get("total_tokens"),
-                    token_limit=_context_length_error_token_limit(str(exc)),
+                    total_tokens=(
+                        context_usage.get("total_tokens")
+                        if context_usage is not None
+                        else None
+                    ),
+                    token_limit=_context_length_error_token_limit(error_message),
                     prune_tool_results_on_context_error=True,
                 )
                 self._raise_if_interrupt_requested(turn_id, iteration)
@@ -385,7 +408,7 @@ class AgentLoop:
         token_limit: 'typing.Union[int, None]' = None,
         prune_tool_results_on_context_error: 'bool' = False,
     ) -> 'None':
-        from .utils.compactor import compact_agent_loop
+        from .utils.compactor import compact_agent
 
         payload: 'typing.Dict[str, object]' = {"phase": phase}
         if total_tokens is not None:
@@ -403,7 +426,7 @@ class AgentLoop:
                 self._emit("stream_error", turn_id, **event.payload)
 
         try:
-            compact_result = await compact_agent_loop(
+            compact_result = await compact_agent(
                 self,
                 handle_compact_stream_event,
                 prune_tool_results_on_context_error,
@@ -477,11 +500,7 @@ class AgentLoop:
 def _usage_from_context_length_error(
     message: 'str',
 ) -> 'typing.Union[typing.Dict[str, int], None]':
-    lower = message.lower()
-    if (
-        "context_length_exceeded" not in lower
-        and "maximum context length" not in lower
-    ):
+    if not _is_context_length_error_message(message):
         return None
 
     requested_match = _REQUESTED_TOKENS_RE.search(message)
@@ -498,6 +517,11 @@ def _usage_from_context_length_error(
     return usage
 
 
+def _is_context_length_error_message(message: 'str') -> 'bool':
+    lower = message.lower()
+    return any(marker in lower for marker in _CONTEXT_LENGTH_ERROR_MARKERS)
+
+
 def _context_length_error_token_limit(message: 'str') -> 'typing.Union[int, None]':
     limit_match = _MAX_CONTEXT_TOKENS_RE.search(message)
     if limit_match is None: