python-codex 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

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
 

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,11 @@ from .protocol import (
 )
 from .tools import ToolContext, ToolRegistry
 from .utils import uuid7_string
+import typing
 
 
 EventHandler = Callable[[AgentEvent], None]
-NOOP_EVENT_HANDLER: EventHandler = lambda _event: None
+NOOP_EVENT_HANDLER: 'EventHandler' = lambda _event: None
 
 
 class TurnInterrupted(RuntimeError):
@@ -40,47 +40,47 @@ 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, ...]' = (),
+    ) -> '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.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 _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:
@@ -93,10 +93,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,7 +130,7 @@ class AgentLoop:
                     item_count=len(response.items),
                 )
 
-                tool_calls: list[ToolCall] = []
+                tool_calls: 'typing.List[ToolCall]' = []
                 for item in response.items:
                     self._history.append(item)
                     if isinstance(item, AssistantMessage):
@@ -182,11 +180,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,10 +222,10 @@ class AgentLoop:
 
     async def _run_single_tool(
         self,
-        turn_id: str,
-        call: ToolCall,
-        prior_results: tuple[ToolResult, ...] = (),
-    ) -> ToolResult:
+        turn_id: 'str',
+        call: 'ToolCall',
+        prior_results: 'typing.Tuple[ToolResult, ...]' = (),
+    ) -> 'ToolResult':
         self._emit("tool_started", turn_id, tool_name=call.name, call_id=call.call_id)
         result = await self._tool_registry.execute(
             call,
@@ -237,7 +235,7 @@ class AgentLoop:
                 collaboration_mode=self._context_manager.collaboration_mode,
             ),
         )
-        payload: dict[str, object] = {
+        payload: 'typing.Dict[str, object]' = {
             "tool_name": call.name,
             "call_id": call.call_id,
             "is_error": result.is_error,
@@ -247,12 +245,12 @@ class AgentLoop:
         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 _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":
@@ -260,9 +258,9 @@ class AgentLoop:
 
     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 (

pycodex/cli.py

@@ -1,4 +1,3 @@
-from __future__ import annotations
 
 import atexit
 import argparse
@@ -10,10 +9,11 @@ import sys
 import tempfile
 from dataclasses import asdict, replace
 from pathlib import Path
-from typing import Literal, Sequence
+from typing import Sequence
 
 from .agent import AgentLoop
 from .collaboration import DEFAULT_COLLABORATION_MODE, CollaborationMode
+from .compat import Literal
 from .context import ContextManager
 from .model import ResponsesModelClient, ResponsesProviderConfig
 from .portable import bootstrap_called_home, upload_codex_home
@@ -21,6 +21,7 @@ from .protocol import AgentEvent
 from .runtime import AgentRuntime
 from .runtime_services import RuntimeEnvironment, create_runtime_environment
 from .utils import CliSessionView, load_codex_dotenv
+import typing
 
 EXIT_COMMANDS = {"/exit", "/quit"}
 HISTORY_COMMAND = "/history"
@@ -40,7 +41,7 @@ def launch_chat_completion_compat_server(*args, **kwargs):
     return launch_compat_server(*args, **kwargs)
 
 
-def configure_loguru() -> None:
+def configure_loguru() -> 'None':
     try:
         from loguru import logger
     except ImportError:  # pragma: no cover - dependency may be absent in minimal envs
@@ -61,7 +62,7 @@ def configure_loguru() -> None:
         logger.add(sys.stderr, level="DEBUG")
 
 
-def build_parser() -> argparse.ArgumentParser:
+def build_parser() -> 'argparse.ArgumentParser':
     parser = argparse.ArgumentParser(
         prog="pycodex",
         description="Minimal Codex-style local CLI backed by ~/.codex/config.toml.",
@@ -131,11 +132,11 @@ def build_parser() -> argparse.ArgumentParser:
     return parser
 
 
-def should_run_interactive(prompt_parts: Sequence[str], stdin_is_tty: bool) -> bool:
+def should_run_interactive(prompt_parts: 'Sequence[str]', stdin_is_tty: 'bool') -> 'bool':
     return not prompt_parts and stdin_is_tty
 
 
-def resolve_prompt_text(prompt_parts: Sequence[str]) -> str:
+def resolve_prompt_text(prompt_parts: 'Sequence[str]') -> 'str':
     if prompt_parts:
         return " ".join(prompt_parts).strip()
 
@@ -148,8 +149,8 @@ def resolve_prompt_text(prompt_parts: Sequence[str]) -> str:
 
 
 def get_tools(
-    runtime_environment: RuntimeEnvironment | None = None,
-    exec_mode: bool = False,
+    runtime_environment: 'typing.Union[RuntimeEnvironment, None]' = None,
+    exec_mode: 'bool' = False,
 ):
     from .tools import (
         ApplyPatchTool,
@@ -243,7 +244,7 @@ def get_tools(
     return registry
 
 
-def get_subagent_tools(runtime_environment: RuntimeEnvironment | None = None):
+def get_subagent_tools(runtime_environment: 'typing.Union[RuntimeEnvironment, None]' = None):
     from .tools import (
         ApplyPatchTool,
         ExecCommandTool,
@@ -268,13 +269,13 @@ def get_subagent_tools(runtime_environment: RuntimeEnvironment | None = None):
 
 
 def build_runtime(
-    config_path: str,
-    profile: str | None,
-    system_prompt: str | None,
+    config_path: 'str',
+    profile: 'typing.Union[str, None]',
+    system_prompt: 'typing.Union[str, None]',
     client,
-    session_mode: CliSessionMode = "exec",
-    collaboration_mode: CollaborationMode = DEFAULT_COLLABORATION_MODE,
-) -> AgentRuntime:
+    session_mode: 'CliSessionMode' = "exec",
+    collaboration_mode: 'CollaborationMode' = DEFAULT_COLLABORATION_MODE,
+) -> 'AgentRuntime':
     use_tui_context = session_mode == "tui"
     context_manager = ContextManager.from_codex_config(
         config_path,
@@ -295,11 +296,11 @@ def build_runtime(
 
     def make_subagent_runtime_builder(base_client):
         def build_subagent_runtime(
-            model_override: str | None,
-            reasoning_effort_override: str | None,
+            model_override: 'typing.Union[str, None]',
+            reasoning_effort_override: 'typing.Union[str, None]',
             initial_history=(),
-            session_id: str | None = None,
-        ) -> AgentRuntime:
+            session_id: 'typing.Union[str, None]' = None,
+        ) -> 'AgentRuntime':
             nested_client = base_client.with_overrides(
                 model_override,
                 reasoning_effort_override,
@@ -335,19 +336,19 @@ def build_runtime(
     )
 
 
-def format_turn_output(result, json_mode: bool) -> str:
+def format_turn_output(result, json_mode: 'bool') -> 'str':
     if json_mode:
         return json.dumps(asdict(result), ensure_ascii=False, indent=2)
     return result.output_text or ""
 
 
 def _build_model_client(
-    config_path: str,
-    profile: str | None,
-    timeout_seconds: float,
-    managed_responses_base_url: str | None = None,
-    vllm_endpoint: str | None = None,
-    use_chat_completion: bool = False,
+    config_path: 'str',
+    profile: 'typing.Union[str, None]',
+    timeout_seconds: 'float',
+    managed_responses_base_url: 'typing.Union[str, None]' = None,
+    vllm_endpoint: 'typing.Union[str, None]' = None,
+    use_chat_completion: 'bool' = False,
 ):
     load_codex_dotenv(config_path)
     provider_config = ResponsesProviderConfig.from_codex_config(
@@ -393,13 +394,13 @@ def _build_model_client(
 
 
 async def prompt_request_user_input(
-    view: CliSessionView,
-    payload: dict[str, object],
-) -> dict[str, object] | None:
+    view: 'CliSessionView',
+    payload: 'typing.Dict[str, object]',
+) -> 'typing.Union[typing.Dict[str, object], None]':
     view.finish_stream()
     view.pause_spinner()
     view.write_line("[request_user_input] waiting for user response")
-    answers: dict[str, dict[str, list[str]]] = {}
+    answers: 'typing.Dict[str, typing.Dict[str, typing.List[str]]]' = {}
     try:
         for question in payload.get("questions", []):
             if not isinstance(question, dict):
@@ -456,9 +457,9 @@ async def prompt_request_user_input(
 
 
 async def prompt_request_permissions(
-    view: CliSessionView,
-    payload: dict[str, object],
-) -> dict[str, object] | None:
+    view: 'CliSessionView',
+    payload: 'typing.Dict[str, object]',
+) -> 'typing.Union[typing.Dict[str, object], None]':
     view.finish_stream()
     view.pause_spinner()
     view.write_line("[request_permissions] user approval required")
@@ -495,14 +496,14 @@ async def prompt_request_permissions(
 
 
 async def run_interactive_session(
-    runtime: AgentRuntime,
-    json_mode: bool,
-) -> int:
+    runtime: 'AgentRuntime',
+    json_mode: 'bool',
+) -> 'int':
     worker = asyncio.create_task(runtime.run_forever())
     view = CliSessionView()
     model_client = runtime._agent_loop._model_client
     runtime.set_event_handler(view.handle_event)
-    pending_turn_tasks: set[asyncio.Task[None]] = set()
+    pending_turn_tasks: 'typing.Set[asyncio.Task[None]]' = set()
     runtime_environment = runtime.runtime_environment
     if runtime_environment is None:
         runtime_environment = create_runtime_environment()
@@ -517,13 +518,13 @@ async def run_interactive_session(
     view.write_line("Extra commands: /history, /title, /model")
     try:
 
-        def has_pending_turn_tasks() -> bool:
+        def has_pending_turn_tasks() -> 'bool':
             pending_turn_tasks.difference_update(
                 task for task in tuple(pending_turn_tasks) if task.done()
             )
             return bool(pending_turn_tasks)
 
-        async def wait_for_turn_result(future) -> None:
+        async def wait_for_turn_result(future) -> 'None':
             try:
                 result = await future
             except Exception as exc:  # pragma: no cover - defensive surface
@@ -618,7 +619,7 @@ async def run_interactive_session(
     return 0
 
 
-async def run_cli(args: argparse.Namespace) -> int:
+async def run_cli(args: 'argparse.Namespace') -> 'int':
     runtime = None
     worker = None
     try:
@@ -628,7 +629,7 @@ async def run_cli(args: argparse.Namespace) -> int:
             raise ValueError("--put does not accept prompt text")
         configure_loguru()
         if args.put is not None:
-            def emit_put_log(message: str) -> None:
+            def emit_put_log(message: 'str') -> 'None':
                 print(message, flush=True)
 
             call_spec = upload_codex_home(args.put, event_handler=emit_put_log)
@@ -678,7 +679,7 @@ async def run_cli(args: argparse.Namespace) -> int:
             await worker
 
 
-def main(argv: Sequence[str] | None = None) -> int:
+def main(argv: 'typing.Union[Sequence[str], None]' = None) -> 'int':
     raw_args = list(argv) if argv is not None else None
     if raw_args is None:
         raw_args = sys.argv[1:]

pycodex/collaboration.py

@@ -1,13 +1,13 @@
-from __future__ import annotations
 
-from typing import Literal
+from .compat import Literal
+import typing
 
 CollaborationMode = Literal["default", "plan", "execute", "pair_programming"]
 
-DEFAULT_COLLABORATION_MODE: CollaborationMode = "default"
-PLAN_COLLABORATION_MODE: CollaborationMode = "plan"
+DEFAULT_COLLABORATION_MODE: 'CollaborationMode' = "default"
+PLAN_COLLABORATION_MODE: 'CollaborationMode' = "plan"
 
-_MODE_DISPLAY_NAMES: dict[str, str] = {
+_MODE_DISPLAY_NAMES: 'typing.Dict[str, str]' = {
     "default": "Default",
     "plan": "Plan",
     "execute": "Execute",
@@ -15,7 +15,6 @@ _MODE_DISPLAY_NAMES: dict[str, str] = {
 }
 
 
-def collaboration_mode_display_name(mode: str | None) -> str:
+def collaboration_mode_display_name(mode: 'typing.Union[str, None]') -> 'str':
     normalized = (mode or DEFAULT_COLLABORATION_MODE).strip().lower()
     return _MODE_DISPLAY_NAMES.get(normalized, normalized.replace("_", " ").title())
-

pycodex/compat.py

@@ -0,0 +1,99 @@
+import asyncio
+import functools
+import shlex
+
+try:
+    from http.server import ThreadingHTTPServer
+except ImportError:  # pragma: no cover - Python 3.6 path
+    from http.server import HTTPServer
+    from socketserver import ThreadingMixIn
+
+    class ThreadingHTTPServer(ThreadingMixIn, HTTPServer):
+        daemon_threads = True
+
+try:
+    from importlib import metadata as importlib_metadata
+except ImportError:  # pragma: no cover - Python 3.6 path
+    import importlib_metadata  # type: ignore
+
+try:
+    from typing import Literal, Protocol, TypeAlias
+except ImportError:  # pragma: no cover - Python 3.6 path
+    from typing_extensions import Literal, Protocol  # type: ignore
+    try:
+        from typing_extensions import TypeAlias  # type: ignore
+    except ImportError:  # pragma: no cover - old typing_extensions
+        TypeAlias = object
+
+
+def patch_asyncio():
+    if not hasattr(asyncio, "create_task"):
+        asyncio.create_task = asyncio.ensure_future
+
+    if not hasattr(asyncio, "get_running_loop"):
+        def get_running_loop():
+            return asyncio.get_event_loop()
+
+        asyncio.get_running_loop = get_running_loop
+
+    if not hasattr(asyncio, "to_thread"):
+        async def to_thread(func, *args, **kwargs):
+            loop = asyncio.get_event_loop()
+            call = functools.partial(func, *args, **kwargs)
+            return await loop.run_in_executor(None, call)
+
+        asyncio.to_thread = to_thread
+
+    if not hasattr(asyncio, "run"):
+        def run(main):
+            loop = asyncio.new_event_loop()
+            try:
+                asyncio.set_event_loop(loop)
+                return loop.run_until_complete(main)
+            finally:
+                all_tasks = getattr(asyncio.Task, "all_tasks", None)
+                if all_tasks is not None:
+                    pending = all_tasks(loop=loop)
+                else:
+                    pending = asyncio.all_tasks(loop)
+                for task in pending:
+                    task.cancel()
+                if pending:
+                    loop.run_until_complete(
+                        asyncio.gather(*pending, return_exceptions=True)
+                    )
+                shutdown_asyncgens = getattr(loop, "shutdown_asyncgens", None)
+                if shutdown_asyncgens is not None:
+                    loop.run_until_complete(shutdown_asyncgens())
+                asyncio.set_event_loop(None)
+                loop.close()
+
+        asyncio.run = run
+
+
+def shlex_join(parts):
+    join = getattr(shlex, "join", None)
+    if join is not None:
+        return join(parts)
+    return " ".join(shlex.quote(part) for part in parts)
+
+
+def stream_writer_is_closing(writer):
+    method = getattr(writer, "is_closing", None)
+    if callable(method):
+        return method()
+    transport = getattr(writer, "transport", None)
+    if transport is None:
+        return False
+    transport_is_closing = getattr(transport, "is_closing", None)
+    if callable(transport_is_closing):
+        return transport_is_closing()
+    return False
+
+
+def is_ascii(text):
+    try:
+        text.encode("ascii")
+    except UnicodeEncodeError:
+        return False
+    return True