python-codex 0.1.12__py3-none-any.whl → 0.1.13__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

@@ -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: