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

pycodex/tools/read_file_tool.py

@@ -9,13 +9,12 @@ Expected behavior:
   mode used to inspect code structure without shelling out to `sed` or `cat`.
 """
 
-from __future__ import annotations
-
 from collections import deque
 from pathlib import Path
 
 from ..protocol import JSONDict, JSONValue
 from .base_tool import BaseTool, ToolContext
+import typing
 
 MAX_LINE_LENGTH = 500
 TAB_WIDTH = 4
@@ -49,7 +48,7 @@ class ReadFileTool(BaseTool):
         "required": ["file_path"],
     }
 
-    async def run(self, context: ToolContext, args: JSONDict) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
         del context
         file_path = Path(str(args.get("file_path", "")))
         offset = int(args.get("offset", 1))
@@ -72,7 +71,7 @@ class ReadFileTool(BaseTool):
             return self._read_indentation(file_path, offset, limit, indentation)
         return self._read_slice(file_path, offset, limit)
 
-    def _read_slice(self, file_path: Path, offset: int, limit: int) -> str:
+    def _read_slice(self, file_path: 'Path', offset: 'int', limit: 'int') -> 'str':
         lines = file_path.read_text(errors="replace").splitlines()
         if offset > len(lines):
             return "Error: `offset` exceeds file length."
@@ -85,11 +84,11 @@ class ReadFileTool(BaseTool):
 
     def _read_indentation(
         self,
-        file_path: Path,
-        offset: int,
-        limit: int,
-        indentation: JSONDict,
-    ) -> str:
+        file_path: 'Path',
+        offset: 'int',
+        limit: 'int',
+        indentation: 'JSONDict',
+    ) -> 'str':
         lines = self._collect_line_records(file_path)
         anchor_line = int(indentation.get("anchor_line", offset))
         max_levels = int(indentation.get("max_levels", 0))
@@ -171,7 +170,7 @@ class ReadFileTool(BaseTool):
             f"L{record['number']}: {record['display']}" for record in selected
         )
 
-    def _collect_line_records(self, file_path: Path) -> list[dict[str, object]]:
+    def _collect_line_records(self, file_path: 'Path') -> 'typing.List[typing.Dict[str, object]]':
         records = []
         for number, raw in enumerate(file_path.read_text(errors="replace").splitlines(), start=1):
             records.append(
@@ -185,7 +184,7 @@ class ReadFileTool(BaseTool):
             )
         return records
 
-    def _compute_effective_indents(self, records: list[dict[str, object]]) -> list[int]:
+    def _compute_effective_indents(self, records: 'typing.List[typing.Dict[str, object]]') -> 'typing.List[int]':
         effective = []
         previous_indent = 0
         for record in records:
@@ -196,7 +195,7 @@ class ReadFileTool(BaseTool):
                 effective.append(previous_indent)
         return effective
 
-    def _measure_indent(self, line: str) -> int:
+    def _measure_indent(self, line: 'str') -> 'int':
         total = 0
         for character in line:
             if character == " ":
@@ -207,10 +206,10 @@ class ReadFileTool(BaseTool):
                 break
         return total
 
-    def _format_line(self, text: str) -> str:
+    def _format_line(self, text: 'str') -> 'str':
         return text[:MAX_LINE_LENGTH]
 
-    def _trim_empty_lines(self, records: deque[dict[str, object]]) -> None:
+    def _trim_empty_lines(self, records: 'deque[typing.Dict[str, object]]') -> 'None':
         while records and not str(records[0]["raw"]).strip():
             records.popleft()
         while records and not str(records[-1]["raw"]).strip():

pycodex/tools/request_permissions_tool.py

@@ -9,8 +9,6 @@ Expected behavior:
 - Return the granted permission profile and scope so later tool calls can use it.
 """
 
-from __future__ import annotations
-
 from ..protocol import JSONDict, JSONValue
 from ..runtime_services import RequestPermissionsManager
 from .base_tool import BaseTool, ToolContext
@@ -73,10 +71,10 @@ class RequestPermissionsTool(BaseTool):
     }
     supports_parallel = False
 
-    def __init__(self, request_manager: RequestPermissionsManager) -> None:
+    def __init__(self, request_manager: 'RequestPermissionsManager') -> 'None':
         self._request_manager = request_manager
 
-    async def run(self, context: ToolContext, args: JSONDict) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
         del context
         permissions = args.get("permissions")
         if not isinstance(permissions, dict):

pycodex/tools/request_user_input_tool.py

@@ -12,14 +12,13 @@ Expected behavior:
   `success=true`.
 """
 
-from __future__ import annotations
-
 import json
 
 from ..collaboration import collaboration_mode_display_name
 from ..protocol import JSONDict, JSONValue
 from ..runtime_services import RequestUserInputManager
 from .base_tool import BaseTool, StructuredToolOutput, ToolContext
+import typing
 
 REQUEST_USER_INPUT_QUESTION_SCHEMA = {
     "type": "object",
@@ -67,9 +66,9 @@ REQUEST_USER_INPUT_QUESTION_SCHEMA = {
 
 
 def request_user_input_is_available(
-    mode: str,
-    default_mode_request_user_input: bool = False,
-) -> bool:
+    mode: 'str',
+    default_mode_request_user_input: 'bool' = False,
+) -> 'bool':
     normalized = mode.strip().lower()
     return normalized == "plan" or (
         default_mode_request_user_input and normalized == "default"
@@ -77,9 +76,9 @@ def request_user_input_is_available(
 
 
 def request_user_input_unavailable_message(
-    mode: str,
-    default_mode_request_user_input: bool = False,
-) -> str | None:
+    mode: 'str',
+    default_mode_request_user_input: 'bool' = False,
+) -> 'typing.Union[str, None]':
     if request_user_input_is_available(mode, default_mode_request_user_input):
         return None
     return (
@@ -89,8 +88,8 @@ def request_user_input_unavailable_message(
 
 
 def request_user_input_tool_description(
-    default_mode_request_user_input: bool = False,
-) -> str:
+    default_mode_request_user_input: 'bool' = False,
+) -> 'str':
     if default_mode_request_user_input:
         allowed_modes = "Default or Plan mode"
     else:
@@ -120,16 +119,16 @@ class RequestUserInputTool(BaseTool):
 
     def __init__(
         self,
-        request_manager: RequestUserInputManager,
-        default_mode_request_user_input: bool = False,
-    ) -> None:
+        request_manager: 'RequestUserInputManager',
+        default_mode_request_user_input: 'bool' = False,
+    ) -> 'None':
         self._request_manager = request_manager
         self._default_mode_request_user_input = default_mode_request_user_input
         self.description = request_user_input_tool_description(
             default_mode_request_user_input
         )
 
-    async def run(self, context: ToolContext, args: JSONDict) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
         unavailable = request_user_input_unavailable_message(
             context.collaboration_mode,
             self._default_mode_request_user_input,

pycodex/tools/resume_agent_tool.py

@@ -8,8 +8,6 @@ Expected behavior:
 - Return the agent's current status payload.
 """
 
-from __future__ import annotations
-
 from ..protocol import JSONDict, JSONValue
 from ..runtime_services import SubAgentManager
 from .agent_tool_schemas import AGENT_STATUS_SCHEMA
@@ -45,10 +43,10 @@ class ResumeAgentTool(BaseTool):
     output_schema = RESUME_AGENT_OUTPUT_SCHEMA
     supports_parallel = False
 
-    def __init__(self, subagent_manager: SubAgentManager) -> None:
+    def __init__(self, subagent_manager: 'SubAgentManager') -> 'None':
         self._subagent_manager = subagent_manager
 
-    async def run(self, context: ToolContext, args: JSONDict) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
         del context
         agent_id = str(args.get("id", "")).strip()
         if not agent_id:

pycodex/tools/send_input_tool.py

@@ -9,12 +9,11 @@ Expected behavior:
 - Return the submission id for the queued input.
 """
 
-from __future__ import annotations
-
 from ..protocol import JSONDict, JSONValue
 from ..runtime_services import SubAgentManager
 from .agent_tool_schemas import COLLAB_INPUT_ITEMS_SCHEMA
 from .base_tool import BaseTool, ToolContext
+import typing
 
 SEND_INPUT_OUTPUT_SCHEMA = {
     "type": "object",
@@ -58,10 +57,10 @@ class SendInputTool(BaseTool):
     output_schema = SEND_INPUT_OUTPUT_SCHEMA
     supports_parallel = False
 
-    def __init__(self, subagent_manager: SubAgentManager) -> None:
+    def __init__(self, subagent_manager: 'SubAgentManager') -> 'None':
         self._subagent_manager = subagent_manager
 
-    async def run(self, context: ToolContext, args: JSONDict) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
         del context
         agent_id = str(args.get("id", "")).strip()
         if not agent_id:
@@ -83,10 +82,10 @@ class SendInputTool(BaseTool):
 
     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 []:
@@ -99,7 +98,7 @@ class SendInputTool(BaseTool):
                 parts.append(str(item))
         return "\n\n".join(part for part in parts if part)
 
-    def _optional_string(self, args: JSONDict, key: str) -> str | None:
+    def _optional_string(self, args: 'JSONDict', key: 'str') -> 'typing.Union[str, None]':
         value = args.get(key)
         if value in (None, ""):
             return None

pycodex/tools/shell_command_tool.py

@@ -11,13 +11,12 @@ Expected behavior:
   stdout, and stderr.
 """
 
-from __future__ import annotations
-
 import asyncio
 from pathlib import Path
 
 from ..protocol import JSONDict, JSONValue
 from .base_tool import BaseTool, ToolContext
+import typing
 
 DEFAULT_SHELL_TIMEOUT_MS = 30_000
 MAX_OUTPUT_CHARS = 12_000
@@ -38,10 +37,10 @@ class ShellCommandTool(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._working_directory = Path(cwd or Path.cwd()).resolve()
 
-    async def run(self, context: ToolContext, args: JSONDict) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
         del context
         command = str(args.get("command", "")).strip()
         timeout_ms = int(args.get("timeout_ms", DEFAULT_SHELL_TIMEOUT_MS))
@@ -93,7 +92,7 @@ class ShellCommandTool(BaseTool):
 
         return "\n".join(pieces)
 
-    def _resolve_workdir(self, workdir_arg) -> Path:
+    def _resolve_workdir(self, workdir_arg) -> 'Path':
         if workdir_arg in (None, ""):
             return self._working_directory
         workdir = Path(str(workdir_arg))
@@ -101,7 +100,7 @@ class ShellCommandTool(BaseTool):
             workdir = self._working_directory / workdir
         return workdir.resolve()
 
-    def _clip_output(self, text: str) -> str:
+    def _clip_output(self, text: 'str') -> 'str':
         if len(text) <= MAX_OUTPUT_CHARS:
             return text
         return text[:MAX_OUTPUT_CHARS] + "\n...[truncated]..."

pycodex/tools/shell_tool.py

@@ -11,13 +11,12 @@ Expected behavior:
   stdout, and stderr.
 """
 
-from __future__ import annotations
-
 import asyncio
 from pathlib import Path
 
 from ..protocol import JSONDict, JSONValue
 from .base_tool import BaseTool, ToolContext
+import typing
 
 DEFAULT_SHELL_TIMEOUT_MS = 30_000
 MAX_OUTPUT_CHARS = 12_000
@@ -43,10 +42,10 @@ class ShellTool(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._working_directory = Path(cwd or Path.cwd()).resolve()
 
-    async def run(self, context: ToolContext, args: JSONDict) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
         del context
         command = args.get("command")
         timeout_ms = int(args.get("timeout_ms", DEFAULT_SHELL_TIMEOUT_MS))
@@ -98,7 +97,7 @@ class ShellTool(BaseTool):
 
         return "\n".join(pieces)
 
-    def _resolve_workdir(self, workdir_arg) -> Path:
+    def _resolve_workdir(self, workdir_arg) -> 'Path':
         if workdir_arg in (None, ""):
             return self._working_directory
         workdir = Path(str(workdir_arg))
@@ -106,7 +105,7 @@ class ShellTool(BaseTool):
             workdir = self._working_directory / workdir
         return workdir.resolve()
 
-    def _clip_output(self, text: str) -> str:
+    def _clip_output(self, text: 'str') -> 'str':
         if len(text) <= MAX_OUTPUT_CHARS:
             return text
         return text[:MAX_OUTPUT_CHARS] + "\n...[truncated]..."

pycodex/tools/spawn_agent_tool.py

@@ -9,12 +9,11 @@ Expected behavior:
 - Return the new agent identifier plus any user-facing nickname.
 """
 
-from __future__ import annotations
-
 from ..protocol import JSONDict, JSONValue
 from ..runtime_services import SubAgentManager
 from .agent_tool_schemas import COLLAB_INPUT_ITEMS_SCHEMA
 from .base_tool import BaseTool, ToolContext
+import typing
 
 SPAWN_AGENT_OUTPUT_SCHEMA = {
     "type": "object",
@@ -70,10 +69,10 @@ class SpawnAgentTool(BaseTool):
     output_schema = SPAWN_AGENT_OUTPUT_SCHEMA
     supports_parallel = False
 
-    def __init__(self, subagent_manager: SubAgentManager) -> None:
+    def __init__(self, subagent_manager: 'SubAgentManager') -> 'None':
         self._subagent_manager = subagent_manager
 
-    async def run(self, context: ToolContext, args: JSONDict) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
         message = self._optional_string(args, "message")
         items = args.get("items")
         if items is not None and not isinstance(items, list):
@@ -90,7 +89,7 @@ class SpawnAgentTool(BaseTool):
             history=context.history,
         )
 
-    def _optional_string(self, args: JSONDict, key: str) -> str | None:
+    def _optional_string(self, args: 'JSONDict', key: 'str') -> 'typing.Union[str, None]':
         value = args.get(key)
         if value in (None, ""):
             return None

pycodex/tools/unified_exec_manager.py

@@ -11,8 +11,6 @@ Expected behavior:
 - Return summaries in the same textual shape Codex tools expect.
 """
 
-from __future__ import annotations
-
 import asyncio
 import os
 import shlex
@@ -22,6 +20,9 @@ from pathlib import Path
 
 from loguru import logger
 
+from ..compat import shlex_join, stream_writer_is_closing
+import typing
+
 DEFAULT_EXEC_YIELD_TIME_MS = 10_000
 DEFAULT_WRITE_STDIN_YIELD_TIME_MS = 250
 DEFAULT_MAX_OUTPUT_TOKENS = 10_000
@@ -63,33 +64,33 @@ UNIFIED_EXEC_OUTPUT_SCHEMA = {
 }
 
 
-def _approx_token_count(text: str) -> int:
+def _approx_token_count(text: 'str') -> 'int':
     if not text:
         return 0
     byte_length = len(text.encode("utf-8"))
     return max(1, (byte_length + APPROX_BYTES_PER_TOKEN - 1) // APPROX_BYTES_PER_TOKEN)
 
 
-def _approx_bytes_for_tokens(token_count: int) -> int:
+def _approx_bytes_for_tokens(token_count: 'int') -> 'int':
     return max(token_count, 0) * APPROX_BYTES_PER_TOKEN
 
 
-def _approx_tokens_from_byte_count(byte_count: int) -> int:
+def _approx_tokens_from_byte_count(byte_count: 'int') -> 'int':
     if byte_count <= 0:
         return 0
     return (byte_count + APPROX_BYTES_PER_TOKEN - 1) // APPROX_BYTES_PER_TOKEN
 
 
-def _split_budget(byte_budget: int) -> tuple[int, int]:
+def _split_budget(byte_budget: 'int') -> 'typing.Tuple[int, int]':
     left_budget = byte_budget // 2
     return left_budget, byte_budget - left_budget
 
 
 def _split_string(
-    text: str,
-    beginning_bytes: int,
-    end_bytes: int,
-) -> tuple[str, str]:
+    text: 'str',
+    beginning_bytes: 'int',
+    end_bytes: 'int',
+) -> 'typing.Tuple[str, str]':
     if not text:
         return "", ""
 
@@ -122,7 +123,7 @@ def _split_string(
     return text[:prefix_end], text[suffix_start:]
 
 
-def _truncate_text(text: str, max_tokens: int) -> str:
+def _truncate_text(text: 'str', max_tokens: 'int') -> 'str':
     if not text:
         return ""
 
@@ -141,7 +142,7 @@ def _truncate_text(text: str, max_tokens: int) -> str:
     return f"{prefix}{marker}{suffix}"
 
 
-def _formatted_truncate_text(text: str, max_tokens: int) -> str:
+def _formatted_truncate_text(text: 'str', max_tokens: 'int') -> 'str':
     byte_budget = _approx_bytes_for_tokens(max_tokens)
     if len(text.encode("utf-8")) <= byte_budget:
         return text
@@ -150,13 +151,13 @@ def _formatted_truncate_text(text: str, max_tokens: int) -> str:
     return f"Total output lines: {total_lines}\n\n{_truncate_text(text, max_tokens)}"
 
 
-@dataclass(slots=True)
+@dataclass
 class _HeadTailBuffer:
-    max_bytes: int = UNIFIED_EXEC_OUTPUT_MAX_BYTES
-    head: bytearray = field(default_factory=bytearray)
-    tail: bytearray = field(default_factory=bytearray)
+    max_bytes: 'int' = UNIFIED_EXEC_OUTPUT_MAX_BYTES
+    head: 'bytearray' = field(default_factory=bytearray)
+    tail: 'bytearray' = field(default_factory=bytearray)
 
-    def push_chunk(self, chunk: bytes) -> None:
+    def push_chunk(self, chunk: 'bytes') -> 'None':
         if not chunk or self.max_bytes <= 0:
             return
 
@@ -178,45 +179,45 @@ class _HeadTailBuffer:
             excess = len(self.tail) - tail_budget
             del self.tail[:excess]
 
-    def drain_bytes(self) -> bytes:
+    def drain_bytes(self) -> 'bytes':
         combined = bytes(self.head) + bytes(self.tail)
         self.head.clear()
         self.tail.clear()
         return combined
 
-    def has_data(self) -> bool:
+    def has_data(self) -> 'bool':
         return bool(self.head or self.tail)
 
 
-@dataclass(slots=True)
+@dataclass
 class UnifiedExecSession:
-    session_id: int
-    process: asyncio.subprocess.Process
-    start_time: float
-    command_display: str
-    tty: bool
-    unread_output: _HeadTailBuffer = field(default_factory=_HeadTailBuffer)
-    reader_task: asyncio.Task | None = None
-    output_event: asyncio.Event = field(default_factory=asyncio.Event)
+    session_id: 'int'
+    process: 'asyncio.subprocess.Process'
+    start_time: 'float'
+    command_display: 'str'
+    tty: 'bool'
+    unread_output: '_HeadTailBuffer' = field(default_factory=_HeadTailBuffer)
+    reader_task: 'typing.Union[asyncio.Task, None]' = None
+    output_event: 'asyncio.Event' = field(default_factory=asyncio.Event)
 
 
 class UnifiedExecManager:
-    def __init__(self, cwd: str | Path | None = None) -> None:
+    def __init__(self, cwd: 'typing.Union[typing.Union[str, Path], None]' = None) -> 'None':
         self._default_cwd = Path(cwd or Path.cwd()).resolve()
         self._next_session_id = DEFAULT_SESSION_ID_START
-        self._sessions: dict[int, UnifiedExecSession] = {}
+        self._sessions: 'typing.Dict[int, UnifiedExecSession]' = {}
         self._lock = asyncio.Lock()
 
     async def exec_command(
         self,
-        cmd: str,
-        workdir: str | None = None,
-        shell: str | None = None,
-        login: bool = DEFAULT_LOGIN,
-        tty: bool = DEFAULT_TTY,
-        yield_time_ms: int = DEFAULT_EXEC_YIELD_TIME_MS,
-        max_output_tokens: int | None = None,
-    ) -> str:
+        cmd: 'str',
+        workdir: 'typing.Union[str, None]' = None,
+        shell: 'typing.Union[str, None]' = None,
+        login: 'bool' = DEFAULT_LOGIN,
+        tty: 'bool' = DEFAULT_TTY,
+        yield_time_ms: 'int' = DEFAULT_EXEC_YIELD_TIME_MS,
+        max_output_tokens: 'typing.Union[int, None]' = None,
+    ) -> 'str':
         session_id = await self._allocate_session_id()
         command = self._build_shell_command(cmd, shell, login)
         cwd = self._resolve_workdir(workdir)
@@ -238,7 +239,7 @@ class UnifiedExecManager:
             session_id=session_id,
             process=process,
             start_time=asyncio.get_running_loop().time(),
-            command_display=shlex.join(command),
+            command_display=shlex_join(command),
             tty=tty,
         )
         session.reader_task = asyncio.create_task(self._pump_output(session))
@@ -254,11 +255,11 @@ class UnifiedExecManager:
 
     async def write_stdin(
         self,
-        session_id: int,
-        chars: str = "",
-        yield_time_ms: int = DEFAULT_WRITE_STDIN_YIELD_TIME_MS,
-        max_output_tokens: int | None = None,
-    ) -> str:
+        session_id: 'int',
+        chars: 'str' = "",
+        yield_time_ms: 'int' = DEFAULT_WRITE_STDIN_YIELD_TIME_MS,
+        max_output_tokens: 'typing.Union[int, None]' = None,
+    ) -> 'str':
         session = await self._get_session(session_id)
         if session is None:
             return f"Error: session_id {session_id} is not running."
@@ -278,22 +279,22 @@ class UnifiedExecManager:
             max_output_tokens,
         )
 
-    async def _allocate_session_id(self) -> int:
+    async def _allocate_session_id(self) -> 'int':
         async with self._lock:
             session_id = self._next_session_id
             self._next_session_id += 1
             return session_id
 
-    async def _get_session(self, session_id: int) -> UnifiedExecSession | None:
+    async def _get_session(self, session_id: 'int') -> 'typing.Union[UnifiedExecSession, None]':
         async with self._lock:
             return self._sessions.get(session_id)
 
     async def _wait_and_snapshot(
         self,
-        session_id: int,
-        yield_time_ms: int,
-        max_output_tokens: int | None,
-    ) -> str:
+        session_id: 'int',
+        yield_time_ms: 'int',
+        max_output_tokens: 'typing.Union[int, None]',
+    ) -> 'str':
         session = await self._get_session(session_id)
         if session is None:
             return f"Error: session_id {session_id} is not running."
@@ -343,15 +344,15 @@ class UnifiedExecManager:
 
         return "\n".join(lines)
 
-    async def _close_session(self, session_id: int) -> None:
+    async def _close_session(self, session_id: 'int') -> 'None':
         async with self._lock:
             session = self._sessions.pop(session_id, None)
         if session is None:
             return
-        if session.process.stdin is not None and not session.process.stdin.is_closing():
+        if session.process.stdin is not None and not stream_writer_is_closing(session.process.stdin):
             session.process.stdin.close()
 
-    async def _pump_output(self, session: UnifiedExecSession) -> None:
+    async def _pump_output(self, session: 'UnifiedExecSession') -> 'None':
         stream = session.process.stdout
         if stream is None:
             return
@@ -363,7 +364,7 @@ class UnifiedExecManager:
             session.output_event.set()
         session.output_event.set()
 
-    def _resolve_workdir(self, workdir: str | None) -> Path:
+    def _resolve_workdir(self, workdir: 'typing.Union[str, None]') -> 'Path':
         if not workdir:
             return self._default_cwd
         path = Path(workdir)
@@ -373,10 +374,10 @@ class UnifiedExecManager:
 
     def _build_shell_command(
         self,
-        cmd: str,
-        shell: str | None,
-        login: bool,
-    ) -> list[str]:
+        cmd: 'str',
+        shell: 'typing.Union[str, None]',
+        login: 'bool',
+    ) -> 'typing.List[str]':
         shell_path = shell or os.environ.get("SHELL") or "/bin/bash"
         shell_name = Path(shell_path).name.lower()
         if shell_name in {"cmd", "cmd.exe"}:
@@ -385,13 +386,13 @@ class UnifiedExecManager:
             return [shell_path, "-NoProfile", "-Command", cmd]
         return [shell_path, "-lc" if login else "-c", cmd]
 
-    def _estimate_token_count(self, output: str) -> int | None:
+    def _estimate_token_count(self, output: 'str') -> 'typing.Union[int, None]':
         return _approx_token_count(output)
 
-    def _truncate_output(self, output: str, max_output_tokens: int | None) -> str:
+    def _truncate_output(self, output: 'str', max_output_tokens: 'typing.Union[int, None]') -> 'str':
         token_budget = DEFAULT_MAX_OUTPUT_TOKENS if max_output_tokens is None else max_output_tokens
         return _formatted_truncate_text(output, max(token_budget, 0))
 
-    def _tty_echo(self, chars: str) -> bytes:
+    def _tty_echo(self, chars: 'str') -> 'bytes':
         normalized = chars.replace("\n", "\r\n")
         return normalized.encode("utf-8")