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

pycodex/runtime_services.py

@@ -1,25 +1,25 @@
-from __future__ import annotations
 
 import asyncio
 import json
 import random
-from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Awaitable, Callable
 
+from .compat import Literal
 from .protocol import ConversationItem, TurnResult
 from .utils import uuid7_string
+import typing
 
 if TYPE_CHECKING:
     from .runtime import AgentRuntime
 
 PlanStatus = Literal["pending", "in_progress", "completed"]
-PlanListener = Callable[[dict[str, object]], None]
+PlanListener = Callable[[typing.Dict[str, object]], None]
 RuntimeBuilder = Callable[
-    [str | None, str | None, tuple[ConversationItem, ...], str],
+    [typing.Union[str, None], typing.Union[str, None], typing.Tuple[ConversationItem, ...], str],
     "AgentRuntime",
 ]
-AsyncJSONHandler = Callable[[dict[str, object]], Awaitable[dict[str, object] | None]]
+AsyncJSONHandler = Callable[[typing.Dict[str, object]], Awaitable[typing.Union[typing.Dict[str, object], None]]]
 
 DEFAULT_AGENT_NICKNAME_CANDIDATES = (
     "Bacon",
@@ -114,22 +114,22 @@ DEFAULT_AGENT_NICKNAME_CANDIDATES = (
 )
 
 
-@dataclass(frozen=True, slots=True)
+@dataclass(frozen=True, )
 class PlanItem:
-    step: str
-    status: PlanStatus
+    step: 'str'
+    status: 'PlanStatus'
 
 
 class PlanStore:
-    def __init__(self) -> None:
-        self._explanation: str | None = None
-        self._plan: tuple[PlanItem, ...] = ()
-        self._listener: PlanListener = lambda _payload: None
+    def __init__(self) -> 'None':
+        self._explanation: 'typing.Union[str, None]' = None
+        self._plan: 'typing.Tuple[PlanItem, ...]' = ()
+        self._listener: 'PlanListener' = lambda _payload: None
 
-    def set_listener(self, listener: PlanListener | None) -> None:
+    def set_listener(self, listener: 'typing.Union[PlanListener, None]') -> 'None':
         self._listener = listener or (lambda _payload: None)
 
-    def update(self, explanation: str | None, plan: tuple[PlanItem, ...]) -> None:
+    def update(self, explanation: 'typing.Union[str, None]', plan: 'typing.Tuple[PlanItem, ...]') -> 'None':
         in_progress = sum(1 for item in plan if item.status == "in_progress")
         if in_progress > 1:
             raise ValueError("at most one plan step can be in_progress")
@@ -145,7 +145,7 @@ class PlanStore:
             }
         )
 
-    def snapshot(self) -> dict[str, object]:
+    def snapshot(self) -> 'typing.Dict[str, object]':
         return {
             "explanation": self._explanation,
             "plan": [
@@ -156,13 +156,13 @@ class PlanStore:
 
 
 class RequestUserInputManager:
-    def __init__(self) -> None:
-        self._handler: AsyncJSONHandler | None = None
+    def __init__(self) -> 'None':
+        self._handler: 'typing.Union[AsyncJSONHandler, None]' = None
 
-    def set_handler(self, handler: AsyncJSONHandler | None) -> None:
+    def set_handler(self, handler: 'typing.Union[AsyncJSONHandler, None]') -> 'None':
         self._handler = handler
 
-    async def request(self, payload: dict[str, object]) -> dict[str, object] | None:
+    async def request(self, payload: 'typing.Dict[str, object]') -> 'typing.Union[typing.Dict[str, object], None]':
         handler = self._handler
         if handler is None:
             return None
@@ -170,52 +170,52 @@ class RequestUserInputManager:
 
 
 class RequestPermissionsManager:
-    def __init__(self) -> None:
-        self._handler: AsyncJSONHandler | None = None
+    def __init__(self) -> 'None':
+        self._handler: 'typing.Union[AsyncJSONHandler, None]' = None
 
-    def set_handler(self, handler: AsyncJSONHandler | None) -> None:
+    def set_handler(self, handler: 'typing.Union[AsyncJSONHandler, None]') -> 'None':
         self._handler = handler
 
-    async def request(self, payload: dict[str, object]) -> dict[str, object] | None:
+    async def request(self, payload: 'typing.Dict[str, object]') -> 'typing.Union[typing.Dict[str, object], None]':
         handler = self._handler
         if handler is None:
             return None
         return await handler(payload)
 
 
-@dataclass(slots=True)
+@dataclass
 class ManagedAgent:
-    agent_id: str
-    runtime: "AgentRuntime"
-    worker_task: asyncio.Task[None]
-    nickname: str | None = None
-    state: str = "pending_init"
-    completed_message: str | None = None
-    error_message: str | None = None
-    pending_submission_ids: set[str] = field(default_factory=set)
+    agent_id: 'str'
+    runtime: '"AgentRuntime"'
+    worker_task: 'asyncio.Task[None]'
+    nickname: 'typing.Union[str, None]' = None
+    state: 'str' = "pending_init"
+    completed_message: 'typing.Union[str, None]' = None
+    error_message: 'typing.Union[str, None]' = None
+    pending_submission_ids: 'typing.Set[str]' = field(default_factory=set)
 
 
 class SubAgentManager:
-    def __init__(self) -> None:
-        self._runtime_builder: RuntimeBuilder | None = None
-        self._agents: dict[str, ManagedAgent] = {}
+    def __init__(self) -> 'None':
+        self._runtime_builder: 'typing.Union[RuntimeBuilder, None]' = None
+        self._agents: 'typing.Dict[str, ManagedAgent]' = {}
         self._condition = asyncio.Condition()
-        self._available_nicknames: list[str] = []
+        self._available_nicknames: 'typing.List[str]' = []
         self._nickname_random = random.Random()
 
-    def set_runtime_builder(self, builder: RuntimeBuilder | None) -> None:
+    def set_runtime_builder(self, builder: 'typing.Union[RuntimeBuilder, None]') -> 'None':
         self._runtime_builder = builder
 
     async def spawn_agent(
         self,
-        message: str | None,
-        items: list[dict[str, object]] | None,
-        agent_type: str | None,
-        fork_context: bool,
-        model: str | None,
-        reasoning_effort: str | None,
-        history: tuple[ConversationItem, ...],
-    ) -> dict[str, object]:
+        message: 'typing.Union[str, None]',
+        items: 'typing.Union[typing.List[typing.Dict[str, object]], None]',
+        agent_type: 'typing.Union[str, None]',
+        fork_context: 'bool',
+        model: 'typing.Union[str, None]',
+        reasoning_effort: 'typing.Union[str, None]',
+        history: 'typing.Tuple[ConversationItem, ...]',
+    ) -> 'typing.Dict[str, object]':
         builder = self._runtime_builder
         if builder is None:
             raise RuntimeError("spawn_agent is unavailable before runtime initialization")
@@ -246,10 +246,10 @@ class SubAgentManager:
 
     async def send_input(
         self,
-        agent_id: str,
-        prompt_text: str,
-        interrupt: bool,
-    ) -> dict[str, object]:
+        agent_id: 'str',
+        prompt_text: 'str',
+        interrupt: 'bool',
+    ) -> 'typing.Dict[str, object]':
         managed = self._agents.get(agent_id)
         if managed is None:
             raise RuntimeError(f"unknown agent: {agent_id}")
@@ -269,7 +269,7 @@ class SubAgentManager:
             self._condition.notify_all()
         return {"submission_id": submission_id}
 
-    async def resume_agent(self, agent_id: str) -> dict[str, object]:
+    async def resume_agent(self, agent_id: 'str') -> 'typing.Dict[str, object]':
         managed = self._agents.get(agent_id)
         if managed is None:
             return {"status": "not_found"}
@@ -282,7 +282,7 @@ class SubAgentManager:
             self._condition.notify_all()
         return {"status": self._status_payload(managed)}
 
-    async def close_agent(self, agent_id: str) -> dict[str, object]:
+    async def close_agent(self, agent_id: 'str') -> 'typing.Dict[str, object]':
         managed = self._agents.get(agent_id)
         if managed is None:
             return {"status": "not_found"}
@@ -297,7 +297,7 @@ class SubAgentManager:
             self._condition.notify_all()
         return {"status": previous_status}
 
-    def _next_nickname(self) -> str:
+    def _next_nickname(self) -> 'str':
         if not self._available_nicknames:
             self._available_nicknames = list(DEFAULT_AGENT_NICKNAME_CANDIDATES)
             self._nickname_random.shuffle(self._available_nicknames)
@@ -305,9 +305,9 @@ class SubAgentManager:
 
     async def wait_agents(
         self,
-        agent_ids: list[str],
-        timeout_ms: int = 30_000,
-    ) -> dict[str, object]:
+        agent_ids: 'typing.List[str]',
+        timeout_ms: 'int' = 30_000,
+    ) -> 'typing.Dict[str, object]':
         timeout_seconds = max(timeout_ms, 1) / 1000.0
         loop = asyncio.get_running_loop()
         deadline = loop.time() + timeout_seconds
@@ -332,10 +332,10 @@ class SubAgentManager:
 
     async def _track_submission(
         self,
-        managed: ManagedAgent,
-        submission_id: str,
-        future: asyncio.Future[TurnResult | None],
-    ) -> None:
+        managed: 'ManagedAgent',
+        submission_id: 'str',
+        future: 'asyncio.Future[typing.Union[TurnResult, None]]',
+    ) -> 'None':
         try:
             result = await future
         except Exception as exc:  # pragma: no cover - background safety
@@ -354,10 +354,10 @@ class SubAgentManager:
 
     def _compose_prompt(
         self,
-        message: str | None,
-        items: list[dict[str, object]] | None,
-    ) -> str:
-        parts: list[str] = []
+        message: 'typing.Union[str, None]',
+        items: 'typing.Union[typing.List[typing.Dict[str, object]], None]',
+    ) -> 'str':
+        parts: 'typing.List[str]' = []
         if message:
             parts.append(message.strip())
         for item in items or []:
@@ -374,7 +374,7 @@ class SubAgentManager:
                 parts.append(json.dumps(item, ensure_ascii=False))
         return "\n\n".join(part for part in parts if part)
 
-    def _status_payload(self, managed: ManagedAgent | None) -> object:
+    def _status_payload(self, managed: 'typing.Union[ManagedAgent, None]') -> 'object':
         if managed is None:
             return "not_found"
         if managed.error_message is not None:
@@ -385,7 +385,7 @@ class SubAgentManager:
             return managed.state
         return managed.state
 
-    def _is_final_status(self, status: object) -> bool:
+    def _is_final_status(self, status: 'object') -> 'bool':
         if isinstance(status, str):
             return status in {"shutdown", "not_found"}
         if isinstance(status, dict):
@@ -394,19 +394,19 @@ class SubAgentManager:
 
 
 class RuntimeEnvironment:
-    def __init__(self) -> None:
+    def __init__(self) -> 'None':
         self.plan_store = PlanStore()
         self.subagent_manager = SubAgentManager()
         self.request_user_input_manager = RequestUserInputManager()
         self.request_permissions_manager = RequestPermissionsManager()
 
 
-def create_runtime_environment() -> RuntimeEnvironment:
+def create_runtime_environment() -> 'RuntimeEnvironment':
     return RuntimeEnvironment()
 
 
 _RUNTIME_ENV = create_runtime_environment()
 
 
-def get_runtime_environment() -> RuntimeEnvironment:
+def get_runtime_environment() -> 'RuntimeEnvironment':
     return _RUNTIME_ENV

pycodex/tools/agent_tool_schemas.py

@@ -1,7 +1,5 @@
 """Shared schemas for Codex-aligned collaboration tools."""
 
-from __future__ import annotations
-
 COLLAB_INPUT_ITEMS_SCHEMA = {
     "type": "array",
     "description": (

pycodex/tools/apply_patch_tool.py

@@ -11,8 +11,6 @@ Expected behavior:
   same success/error text shape Codex expects.
 """
 
-from __future__ import annotations
-
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -20,6 +18,7 @@ from loguru import logger
 
 from ..protocol import JSONValue
 from .base_tool import BaseTool, ToolContext
+import typing
 
 APPLY_PATCH_LARK_GRAMMAR = """start: begin_patch hunk+ end_patch
 begin_patch: \"*** Begin Patch\" LF
@@ -47,28 +46,28 @@ class ApplyPatchError(RuntimeError):
     pass
 
 
-@dataclass(frozen=True, slots=True)
+@dataclass(frozen=True, )
 class _AddFileOp:
-    path: str
-    content: str
+    path: 'str'
+    content: 'str'
 
 
-@dataclass(frozen=True, slots=True)
+@dataclass(frozen=True, )
 class _DeleteFileOp:
-    path: str
+    path: 'str'
 
 
-@dataclass(frozen=True, slots=True)
+@dataclass(frozen=True, )
 class _UpdateSection:
-    lines: tuple[str, ...]
-    anchor_end_of_file: bool = False
+    lines: 'typing.Tuple[str, ...]'
+    anchor_end_of_file: 'bool' = False
 
 
-@dataclass(frozen=True, slots=True)
+@dataclass(frozen=True, )
 class _UpdateFileOp:
-    path: str
-    move_to: str | None
-    sections: tuple[_UpdateSection, ...]
+    path: 'str'
+    move_to: 'typing.Union[str, None]'
+    sections: 'typing.Tuple[_UpdateSection, ...]'
 
 
 class ApplyPatchTool(BaseTool):
@@ -85,10 +84,10 @@ class ApplyPatchTool(BaseTool):
     }
     supports_parallel = False
 
-    def __init__(self, cwd: str | Path | None = None) -> None:
+    def __init__(self, cwd: 'typing.Union[typing.Union[str, Path], None]' = None) -> 'None':
         self._workspace_root = Path(cwd or Path.cwd()).resolve()
 
-    async def run(self, context: ToolContext, args: JSONValue) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONValue') -> 'JSONValue':
         del context
         patch_text = str(args)
         logger.debug("apply_patch workspace={} bytes={}", self._workspace_root, len(patch_text))
@@ -98,7 +97,7 @@ class ApplyPatchTool(BaseTool):
         except ApplyPatchError as exc:
             return self._format_result(str(exc), exit_code=1)
 
-    def _parse_patch(self, patch_text: str) -> list[_AddFileOp | _DeleteFileOp | _UpdateFileOp]:
+    def _parse_patch(self, patch_text: 'str') -> 'typing.List[typing.Union[typing.Union[_AddFileOp, _DeleteFileOp], _UpdateFileOp]]':
         lines = patch_text.splitlines()
         if not lines:
             raise ApplyPatchError("patch rejected: empty patch")
@@ -107,7 +106,7 @@ class ApplyPatchTool(BaseTool):
                 "apply_patch verification failed: missing '*** Begin Patch' header"
             )
 
-        operations: list[_AddFileOp | _DeleteFileOp | _UpdateFileOp] = []
+        operations: 'typing.List[typing.Union[typing.Union[_AddFileOp, _DeleteFileOp], _UpdateFileOp]]' = []
         index = 1
         while index < len(lines):
             line = lines[index]
@@ -122,9 +121,9 @@ class ApplyPatchTool(BaseTool):
                 return operations
 
             if line.startswith("*** Add File: "):
-                path = line.removeprefix("*** Add File: ")
+                path = line[len("*** Add File: ") :]
                 index += 1
-                content_lines: list[str] = []
+                content_lines: 'typing.List[str]' = []
                 while index < len(lines) and not lines[index].startswith("*** "):
                     entry = lines[index]
                     if not entry.startswith("+"):
@@ -141,21 +140,21 @@ class ApplyPatchTool(BaseTool):
                 continue
 
             if line.startswith("*** Delete File: "):
-                path = line.removeprefix("*** Delete File: ")
+                path = line[len("*** Delete File: ") :]
                 operations.append(_DeleteFileOp(path=path))
                 index += 1
                 continue
 
             if line.startswith("*** Update File: "):
-                path = line.removeprefix("*** Update File: ")
+                path = line[len("*** Update File: ") :]
                 index += 1
                 move_to = None
                 if index < len(lines) and lines[index].startswith("*** Move to: "):
-                    move_to = lines[index].removeprefix("*** Move to: ")
+                    move_to = lines[index][len("*** Move to: ") :]
                     index += 1
 
-                sections: list[_UpdateSection] = []
-                current_lines: list[str] = []
+                sections: 'typing.List[_UpdateSection]' = []
+                current_lines: 'typing.List[str]' = []
                 saw_hunk_header = False
                 anchor_end_of_file = False
                 while index < len(lines):
@@ -221,10 +220,10 @@ class ApplyPatchTool(BaseTool):
 
     def _apply_operations(
         self,
-        operations: list[_AddFileOp | _DeleteFileOp | _UpdateFileOp],
-    ) -> str:
-        preview: dict[Path, str | None] = {}
-        summaries: dict[Path, str] = {}
+        operations: 'typing.List[typing.Union[typing.Union[_AddFileOp, _DeleteFileOp], _UpdateFileOp]]',
+    ) -> 'str':
+        preview: 'typing.Dict[Path, typing.Union[str, None]]' = {}
+        summaries: 'typing.Dict[Path, str]' = {}
 
         for operation in operations:
             if isinstance(operation, _AddFileOp):
@@ -254,7 +253,7 @@ class ApplyPatchTool(BaseTool):
         self._write_preview(preview)
         return self._format_success(summaries)
 
-    def _read_preview_file(self, path: Path, preview: dict[Path, str | None]) -> str:
+    def _read_preview_file(self, path: 'Path', preview: 'typing.Dict[Path, typing.Union[str, None]]') -> 'str':
         if path in preview:
             content = preview[path]
             if content is None:
@@ -271,10 +270,10 @@ class ApplyPatchTool(BaseTool):
 
     def _apply_update(
         self,
-        path: Path,
-        original_text: str,
-        sections: tuple[_UpdateSection, ...],
-    ) -> str:
+        path: 'Path',
+        original_text: 'str',
+        sections: 'typing.Tuple[_UpdateSection, ...]',
+    ) -> 'str':
         lines = original_text.splitlines()
         cursor = 0
         for section in sections:
@@ -295,11 +294,11 @@ class ApplyPatchTool(BaseTool):
 
     def _find_match(
         self,
-        lines: list[str],
-        old_block: list[str],
-        cursor: int,
-        anchor_end_of_file: bool,
-    ) -> int | None:
+        lines: 'typing.List[str]',
+        old_block: 'typing.List[str]',
+        cursor: 'int',
+        anchor_end_of_file: 'bool',
+    ) -> 'typing.Union[int, None]':
         if anchor_end_of_file:
             start = len(lines) - len(old_block)
             if start >= 0 and lines[start : start + len(old_block)] == old_block:
@@ -318,7 +317,7 @@ class ApplyPatchTool(BaseTool):
                 return start
         return None
 
-    def _write_preview(self, preview: dict[Path, str | None]) -> None:
+    def _write_preview(self, preview: 'typing.Dict[Path, typing.Union[str, None]]') -> 'None':
         for path, content in preview.items():
             if content is None:
                 if path.exists():
@@ -327,17 +326,17 @@ class ApplyPatchTool(BaseTool):
             path.parent.mkdir(parents=True, exist_ok=True)
             path.write_text(content, encoding="utf-8")
 
-    def _format_success(self, summaries: dict[Path, str]) -> str:
+    def _format_success(self, summaries: 'typing.Dict[Path, str]') -> 'str':
         buckets = {"A": [], "M": [], "D": []}
         for path, status in summaries.items():
             buckets[status].append(path.relative_to(self._workspace_root).as_posix())
-        lines = ["Success. Updated the following files:"]
+        lines = ["Success:"]
         for status in ("A", "M", "D"):
             for rel_path in sorted(buckets[status]):
                 lines.append(f"{status} {rel_path}")
-        return "\n".join(lines) + "\n"
+        return " ".join(lines) + "\n"
 
-    def _format_result(self, output: str, exit_code: int) -> str:
+    def _format_result(self, output: 'str', exit_code: 'int') -> 'str':
         return (
             f"Exit code: {exit_code}\n"
             "Wall time: 0 seconds\n"
@@ -345,7 +344,7 @@ class ApplyPatchTool(BaseTool):
             f"{output}"
         )
 
-    def _resolve_workspace_path(self, path_text: str) -> Path:
+    def _resolve_workspace_path(self, path_text: 'str') -> 'Path':
         path = Path(path_text)
         resolved = path if path.is_absolute() else self._workspace_root / path
         resolved = resolved.resolve()
@@ -357,7 +356,7 @@ class ApplyPatchTool(BaseTool):
             ) from exc
         return resolved
 
-    def _join_lines(self, lines: list[str]) -> str:
+    def _join_lines(self, lines: 'typing.List[str]') -> 'str':
         if not lines:
             return ""
         return "\n".join(lines) + "\n"