python-codex 0.1.12__py3-none-any.whl → 0.1.14__py3-none-any.whl

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",
 ]

pycodex/agent.py

@@ -5,7 +5,7 @@ import re
 from typing import Callable
 
 from .context import ContextManager
-from .model import ModelClient
+from .model import ModelClient, ResponsesIncompleteError
 from .protocol import (
     AgentEvent,
     AssistantMessage,
@@ -17,16 +17,17 @@ from .protocol import (
     TurnResult,
     UserMessage,
 )
-from .tools import ToolContext, ToolRegistry
+from .tools import ExecCommandTool, ToolContext, ToolRegistry, UnifiedExecManager
 from .utils import uuid7_string
 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,20 @@ _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",
+)
+TERMINAL_TURN_EVENTS = {"turn_completed", "turn_failed", "turn_interrupted"}
 
 
 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 +68,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,14 +84,24 @@ 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
+        self._turn_running = False
+        exec_command_tool = self._tool_registry.get_tool("exec_command")
+        self._exec_manager = (
+            exec_command_tool._manager
+            if isinstance(exec_command_tool, ExecCommandTool)
+            else None
+        )
+        if self._exec_manager is not None:
+            self._exec_manager.set_notify_hook(self.maybe_invoke)
 
     @property
     def history(self) -> 'typing.Tuple[ConversationItem, ...]':
         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 +117,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',
@@ -115,6 +139,7 @@ class AgentLoop:
     async def run_turn(
         self, texts: 'typing.List[str]', turn_id: 'typing.Union[str, None]' = None
     ) -> 'TurnResult':
+        self._turn_running = True
         turn_id = turn_id or uuid7_string()
         self.interrupt_asap = False
         new_user_messages = [UserMessage(text=text) for text in texts]
@@ -154,16 +179,10 @@ class AgentLoop:
                     item_count=len(response.items),
                 )
 
-                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)
+                recorded_items = self._record_model_response_items(response.items)
+                tool_calls = recorded_items[1]
+                if recorded_items[2] is not None:
+                    last_assistant_message = recorded_items[2]
 
                 if not tool_calls:
                     self._raise_if_interrupt_requested(
@@ -177,6 +196,7 @@ class AgentLoop:
                         iteration=iteration,
                         output_text=last_assistant_message,
                     )
+                    self._turn_running = False
                     return TurnResult(
                         turn_id=turn_id,
                         output_text=last_assistant_message,
@@ -197,6 +217,7 @@ class AgentLoop:
                     output_text=last_assistant_message,
                 )
         except TurnInterrupted:
+            self._turn_running = False
             raise
         except Exception as exc:
             context_usage = _usage_from_context_length_error(str(exc))
@@ -210,8 +231,29 @@ class AgentLoop:
                 error=str(exc),
                 error_type=type(exc).__name__,
             )
+            self._turn_running = False
             raise
 
+    async def maybe_invoke(self, event: 'typing.Dict[str, object]') -> 'bool':
+        if self._turn_running or event.get("type") != "exec_command_completed":
+            return False
+        payload = {
+            "session_id": event.get("session_id"),
+            "exit_code": event.get("exit_code"),
+            "command": event.get("command"),
+        }
+        text = (
+            "<exec_command_completed>\n"
+            f"{json.dumps(payload, ensure_ascii=False, separators=(',', ':'))}\n"
+            "</exec_command_completed>"
+        )
+        self._turn_running = True
+        task = asyncio.create_task(self.run_turn([text]))
+        task.add_done_callback(
+            lambda task: None if task.cancelled() else task.exception()
+        )
+        return True
+
     async def _execute_tool_batch(
         self,
         turn_id: 'str',
@@ -280,10 +322,18 @@ class AgentLoop:
         return result
 
     def _emit(self, kind: 'str', turn_id: 'str', **payload: 'object') -> 'None':
+        if kind in TERMINAL_TURN_EVENTS:
+            payload["background_exec_count"] = self._background_exec_count()
         self._event_handler(
             AgentEvent(kind=kind, turn_id=turn_id, payload=dict(payload))
         )
 
+    def _background_exec_count(self) -> 'int':
+        manager: 'typing.Union[UnifiedExecManager, None]' = self._exec_manager
+        if manager is None:
+            return 0
+        return manager.running_session_count()
+
     def _persist_history_items(
         self,
         items: 'typing.Iterable[ConversationItem]',
@@ -296,6 +346,28 @@ class AgentLoop:
         except Exception:  # pragma: no cover - persistence should not break turns
             return
 
+    def _record_model_response_items(
+        self,
+        items: 'typing.Iterable[object]',
+        include_tool_calls: 'bool' = True,
+    ) -> 'typing.Tuple[typing.Tuple[ConversationItem, ...], typing.List[ToolCall], typing.Union[str, None]]':
+        persisted_response_items: 'typing.List[ConversationItem]' = []
+        tool_calls: 'typing.List[ToolCall]' = []
+        last_assistant_message = None
+        for item in items:
+            if isinstance(item, ToolCall) and not include_tool_calls:
+                continue
+            if not isinstance(item, (AssistantMessage, ToolCall, ReasoningItem)):
+                continue
+            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)
+        return tuple(persisted_response_items), tool_calls, last_assistant_message
+
     def _handle_model_stream_event(self, turn_id: 'str', event: 'ModelStreamEvent') -> 'None':
         if event.kind == "token_count":
             self._remember_token_usage(event.payload.get("usage"))
@@ -341,18 +413,34 @@ class AgentLoop:
                     prompt,
                     lambda event: self._handle_model_stream_event(turn_id, event),
                 )
+            except ResponsesIncompleteError as exc:
+                if exc.reason == "max_output_tokens":
+                    self._record_model_response_items(
+                        exc.partial_items,
+                        include_tool_calls=False,
+                    )
+                raise
             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 +473,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 +491,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 +565,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 +582,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: