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

pycodex/tools/base_tool.py

@@ -10,8 +10,6 @@ Expected behavior:
   model, and dispatches `ToolCall` executions back into `ToolResult`s.
 """
 
-from __future__ import annotations
-
 import inspect
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
@@ -20,6 +18,7 @@ import json
 from pathlib import Path
 
 from ..protocol import ConversationItem, JSONDict, JSONValue, ToolCall, ToolResult, ToolSpec
+import typing
 
 EXEC_TOOLS_SNAPSHOT_PATH = (
     Path(__file__).resolve().parent.parent / "prompts" / "exec_tools.json"
@@ -27,8 +26,8 @@ EXEC_TOOLS_SNAPSHOT_PATH = (
 
 
 @lru_cache(maxsize=1)
-def _load_exec_tool_payloads() -> dict[str, JSONDict]:
-    payloads: dict[str, JSONDict] = {}
+def _load_exec_tool_payloads() -> 'typing.Dict[str, JSONDict]':
+    payloads: 'typing.Dict[str, JSONDict]' = {}
     for payload in json.loads(EXEC_TOOLS_SNAPSHOT_PATH.read_text()):
         if not isinstance(payload, dict):
             continue
@@ -41,36 +40,36 @@ def _load_exec_tool_payloads() -> dict[str, JSONDict]:
     return payloads
 
 
-@dataclass(frozen=True, slots=True)
+@dataclass(frozen=True, )
 class ToolContext:
-    turn_id: str
-    history: tuple[ConversationItem, ...]
-    collaboration_mode: str = "default"
+    turn_id: 'str'
+    history: 'typing.Tuple[ConversationItem, ...]'
+    collaboration_mode: 'str' = "default"
 
 
 class StructuredToolOutput:
     def __init__(
         self,
-        output: JSONValue,
-        content_items: tuple[JSONDict, ...] | list[JSONDict] | None = None,
-        success: bool | None = None,
-    ) -> None:
+        output: 'JSONValue',
+        content_items: 'typing.Union[typing.Union[typing.Tuple[JSONDict, ...], typing.List[JSONDict]], None]' = None,
+        success: 'typing.Union[bool, None]' = None,
+    ) -> 'None':
         self.output = output
         self.content_items = None if content_items is None else tuple(content_items)
         self.success = success
 
 
 class BaseTool(ABC):
-    name: str
-    description: str
-    input_schema: JSONDict | None = None
-    tool_type: str = "function"
-    format: JSONDict | None = None
-    options: JSONDict | None = None
-    output_schema: JSONDict | None = None
-    supports_parallel: bool = True
-
-    def spec(self) -> ToolSpec:
+    name: 'str'
+    description: 'str'
+    input_schema: 'typing.Union[JSONDict, None]' = None
+    tool_type: 'str' = "function"
+    format: 'typing.Union[JSONDict, None]' = None
+    options: 'typing.Union[JSONDict, None]' = None
+    output_schema: 'typing.Union[JSONDict, None]' = None
+    supports_parallel: 'bool' = True
+
+    def spec(self) -> 'ToolSpec':
         return ToolSpec(
             name=self.name,
             description=self.description,
@@ -83,32 +82,32 @@ class BaseTool(ABC):
             raw_payload=self.raw_payload(),
         )
 
-    def serialize(self) -> JSONDict:
+    def serialize(self) -> 'JSONDict':
         return self.spec().serialize()
 
-    def raw_payload(self) -> JSONDict | None:
+    def raw_payload(self) -> 'typing.Union[JSONDict, None]':
         return _load_exec_tool_payloads().get(self.name)
 
     @abstractmethod
-    async def run(self, context: ToolContext, args: JSONValue) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONValue') -> 'JSONValue':
         raise NotImplementedError
 
 
 class ToolRegistry:
-    def __init__(self) -> None:
-        self._tools: dict[str, BaseTool] = {}
+    def __init__(self) -> 'None':
+        self._tools: 'typing.Dict[str, BaseTool]' = {}
 
-    def register(self, tool: BaseTool) -> None:
+    def register(self, tool: 'BaseTool') -> 'None':
         self._tools[tool.name] = tool
 
-    def model_visible_specs(self) -> list[ToolSpec]:
+    def model_visible_specs(self) -> 'typing.List[ToolSpec]':
         return [tool.spec() for tool in self._tools.values()]
 
-    def supports_parallel(self, tool_name: str) -> bool:
+    def supports_parallel(self, tool_name: 'str') -> 'bool':
         tool = self._tools.get(tool_name)
         return False if tool is None else tool.supports_parallel
 
-    async def execute(self, call: ToolCall, context: ToolContext) -> ToolResult:
+    async def execute(self, call: 'ToolCall', context: 'ToolContext') -> 'ToolResult':
         tool = self._tools.get(call.name)
         if tool is None:
             return ToolResult(
@@ -149,19 +148,19 @@ class ToolRegistry:
                 tool_type=call.tool_type,
             )
 
-    def __contains__(self, tool_name: str) -> bool:
+    def __contains__(self, tool_name: 'str') -> 'bool':
         return tool_name in self._tools
 
-    def __len__(self) -> int:
+    def __len__(self) -> 'int':
         return len(self._tools)
 
-    def names(self) -> tuple[str, ...]:
+    def names(self) -> 'typing.Tuple[str, ...]':
         return tuple(self._tools)
 
-    def get_tool(self, tool_name: str) -> BaseTool | None:
+    def get_tool(self, tool_name: 'str') -> 'typing.Union[BaseTool, None]':
         return self._tools.get(tool_name)
 
-    def tools(self) -> tuple[BaseTool, ...]:
+    def tools(self) -> 'typing.Tuple[BaseTool, ...]':
         return tuple(self._tools.values())
 
 

pycodex/tools/close_agent_tool.py

@@ -8,8 +8,6 @@ Expected behavior:
 - Return the agent status observed at close time.
 """
 
-from __future__ import annotations
-
 from ..protocol import JSONDict, JSONValue
 from ..runtime_services import SubAgentManager
 from .agent_tool_schemas import AGENT_STATUS_SCHEMA
@@ -44,10 +42,10 @@ class CloseAgentTool(BaseTool):
     output_schema = CLOSE_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/code_mode_manager.py

@@ -10,8 +10,6 @@ Expected behavior:
   `wait`.
 """
 
-from __future__ import annotations
-
 import asyncio
 import json
 import math
@@ -21,8 +19,10 @@ from pathlib import Path
 
 from loguru import logger
 
+from ..compat import is_ascii, stream_writer_is_closing
 from ..protocol import JSONDict, JSONValue, ToolCall
 from .base_tool import StructuredToolOutput, ToolContext, ToolRegistry
+import typing
 
 DEFAULT_WAIT_YIELD_TIME_MS = 10_000
 DEFAULT_MAX_OUTPUT_TOKENS = 10_000
@@ -31,41 +31,41 @@ EXEC_PRAGMA_PREFIX = "// @exec:"
 WAIT_COMPLETION_GRACE_SECONDS = 0.02
 
 
-@dataclass(slots=True)
+@dataclass
 class ExecCell:
-    cell_id: str
-    process: asyncio.subprocess.Process
-    started_at: float
-    output_items: list[JSONDict] = field(default_factory=list)
-    delivered_count: int = 0
-    reader_task: asyncio.Task | None = None
-    stderr_task: asyncio.Task | None = None
-    yield_event: asyncio.Event = field(default_factory=asyncio.Event)
-    output_event: asyncio.Event = field(default_factory=asyncio.Event)
-    done_event: asyncio.Event = field(default_factory=asyncio.Event)
-    completed: bool = False
-    terminated: bool = False
-    error_text: str | None = None
-    stderr_chunks: list[str] = field(default_factory=list)
-
-
-@dataclass(frozen=True, slots=True)
+    cell_id: 'str'
+    process: 'asyncio.subprocess.Process'
+    started_at: 'float'
+    output_items: 'typing.List[JSONDict]' = field(default_factory=list)
+    delivered_count: 'int' = 0
+    reader_task: 'typing.Union[asyncio.Task, None]' = None
+    stderr_task: 'typing.Union[asyncio.Task, None]' = None
+    yield_event: 'asyncio.Event' = field(default_factory=asyncio.Event)
+    output_event: 'asyncio.Event' = field(default_factory=asyncio.Event)
+    done_event: 'asyncio.Event' = field(default_factory=asyncio.Event)
+    completed: 'bool' = False
+    terminated: 'bool' = False
+    error_text: 'typing.Union[str, None]' = None
+    stderr_chunks: 'typing.List[str]' = field(default_factory=list)
+
+
+@dataclass(frozen=True, )
 class ParsedExecSource:
-    code: str
-    yield_time_ms: int | None
-    max_output_tokens: int | None
+    code: 'str'
+    yield_time_ms: 'typing.Union[int, None]'
+    max_output_tokens: 'typing.Union[int, None]'
 
 
 class CodeModeManager:
-    def __init__(self, registry: ToolRegistry, cwd: str | Path | None = None) -> None:
+    def __init__(self, registry: 'ToolRegistry', cwd: 'typing.Union[typing.Union[str, Path], None]' = None) -> 'None':
         self._registry = registry
         self._default_cwd = Path(cwd or Path.cwd()).resolve()
         self._runtime_script = Path(__file__).with_name("exec_runtime.js")
-        self._stored_values: dict[str, JSONValue] = {}
-        self._cells: dict[str, ExecCell] = {}
+        self._stored_values: 'typing.Dict[str, JSONValue]' = {}
+        self._cells: 'typing.Dict[str, ExecCell]' = {}
         self._lock = asyncio.Lock()
 
-    async def exec(self, source: str, context: ToolContext) -> StructuredToolOutput | str:
+    async def exec(self, source: 'str', context: 'ToolContext') -> 'typing.Union[StructuredToolOutput, str]':
         try:
             parsed = self._parse_exec_source(source)
         except ValueError as exc:
@@ -77,11 +77,11 @@ class CodeModeManager:
 
     async def wait(
         self,
-        cell_id: str,
-        yield_time_ms: int,
-        max_tokens: int | None,
-        terminate: bool,
-    ) -> StructuredToolOutput | str:
+        cell_id: 'str',
+        yield_time_ms: 'int',
+        max_tokens: 'typing.Union[int, None]',
+        terminate: 'bool',
+    ) -> 'typing.Union[StructuredToolOutput, str]':
         cell = self._cells.get(cell_id)
         if cell is None:
             return f"Error: unknown exec cell `{cell_id}`."
@@ -98,8 +98,8 @@ class CodeModeManager:
         await self._wait_for_wait(cell, yield_time_ms)
         return await self._snapshot_cell(cell, max_tokens)
 
-    def enabled_tools(self) -> list[dict[str, str]]:
-        enabled: list[dict[str, str]] = []
+    def enabled_tools(self) -> 'typing.List[typing.Dict[str, str]]':
+        enabled: 'typing.List[typing.Dict[str, str]]' = []
         for tool in self._registry.tools():
             if tool.name in {"exec", "wait"}:
                 continue
@@ -116,7 +116,7 @@ class CodeModeManager:
         enabled.sort(key=lambda item: item["tool_name"])
         return enabled
 
-    async def _start_cell(self, code: str, context: ToolContext) -> ExecCell:
+    async def _start_cell(self, code: 'str', context: 'ToolContext') -> 'ExecCell':
         cell_id = uuid.uuid4().hex[:10]
         process = await asyncio.create_subprocess_exec(
             "node",
@@ -147,7 +147,7 @@ class CodeModeManager:
         logger.debug("exec start cell_id={} cwd={}", cell_id, self._default_cwd)
         return cell
 
-    async def _read_stdout(self, cell: ExecCell, context: ToolContext) -> None:
+    async def _read_stdout(self, cell: 'ExecCell', context: 'ToolContext') -> 'None':
         stream = cell.process.stdout
         if stream is None:
             cell.error_text = "missing stdout pipe"
@@ -181,7 +181,7 @@ class CodeModeManager:
                 cell.output_event.set()
                 continue
             if msg_type == "output_image":
-                image_item: JSONDict = {
+                image_item: 'JSONDict' = {
                     "type": "input_image",
                     "image_url": str(message.get("image_url", "")),
                 }
@@ -220,7 +220,7 @@ class CodeModeManager:
             cell.done_event.set()
             cell.output_event.set()
 
-    async def _read_stderr(self, cell: ExecCell) -> None:
+    async def _read_stderr(self, cell: 'ExecCell') -> 'None':
         stream = cell.process.stderr
         if stream is None:
             return
@@ -232,10 +232,10 @@ class CodeModeManager:
 
     async def _handle_nested_tool_call(
         self,
-        cell: ExecCell,
-        context: ToolContext,
-        message: JSONDict,
-    ) -> None:
+        cell: 'ExecCell',
+        context: 'ToolContext',
+        message: 'JSONDict',
+    ) -> 'None':
         tool_name = str(message.get("tool_name", ""))
         request_id = str(message.get("id", ""))
         tool = self._registry.get_tool(tool_name)
@@ -287,14 +287,14 @@ class CodeModeManager:
             }
         await self._send_message(cell, payload)
 
-    async def _send_message(self, cell: ExecCell, payload: JSONDict) -> None:
+    async def _send_message(self, cell: 'ExecCell', payload: 'JSONDict') -> 'None':
         stdin = cell.process.stdin
-        if stdin is None or stdin.is_closing():
+        if stdin is None or stream_writer_is_closing(stdin):
             return
         stdin.write((json.dumps(payload, ensure_ascii=False) + "\n").encode("utf-8"))
         await stdin.drain()
 
-    async def _wait_for_exec(self, cell: ExecCell, yield_time_ms: int | None) -> None:
+    async def _wait_for_exec(self, cell: 'ExecCell', yield_time_ms: 'typing.Union[int, None]') -> 'None':
         done_task = asyncio.create_task(cell.done_event.wait())
         yield_task = asyncio.create_task(cell.yield_event.wait())
         tasks = {done_task, yield_task}
@@ -314,7 +314,7 @@ class CodeModeManager:
                     task.cancel()
         cell.yield_event.clear()
 
-    async def _wait_for_wait(self, cell: ExecCell, yield_time_ms: int) -> None:
+    async def _wait_for_wait(self, cell: 'ExecCell', yield_time_ms: 'int') -> 'None':
         loop = asyncio.get_running_loop()
         deadline = loop.time() + max(yield_time_ms, 1) / 1000.0
         initial_count = cell.delivered_count
@@ -357,9 +357,9 @@ class CodeModeManager:
 
     async def _wait_for_completion_grace(
         self,
-        cell: ExecCell,
-        timeout_seconds: float,
-    ) -> None:
+        cell: 'ExecCell',
+        timeout_seconds: 'float',
+    ) -> 'None':
         if timeout_seconds <= 0:
             return
         done_task = asyncio.create_task(cell.done_event.wait())
@@ -378,9 +378,9 @@ class CodeModeManager:
 
     async def _snapshot_cell(
         self,
-        cell: ExecCell,
-        max_tokens: int | None,
-    ) -> StructuredToolOutput:
+        cell: 'ExecCell',
+        max_tokens: 'typing.Union[int, None]',
+    ) -> 'StructuredToolOutput':
         if cell.process.returncode is not None and cell.reader_task is not None:
             await cell.reader_task
 
@@ -421,13 +421,13 @@ class CodeModeManager:
 
     def _truncate_content_items(
         self,
-        items: list[JSONDict],
-        max_tokens: int | None,
-    ) -> list[JSONDict]:
+        items: 'typing.List[JSONDict]',
+        max_tokens: 'typing.Union[int, None]',
+    ) -> 'typing.List[JSONDict]':
         token_budget = DEFAULT_MAX_OUTPUT_TOKENS if max_tokens is None else max_tokens
         max_chars = max(1, token_budget) * CHARS_PER_TOKEN
         total_chars = 0
-        truncated: list[JSONDict] = []
+        truncated: 'typing.List[JSONDict]' = []
         for item in items:
             if item.get("type") != "input_text":
                 truncated.append(item)
@@ -449,7 +449,7 @@ class CodeModeManager:
             total_chars += len(text)
         return truncated
 
-    def _status_text(self, cell: ExecCell) -> str:
+    def _status_text(self, cell: 'ExecCell') -> 'str':
         if cell.terminated:
             return "Script terminated"
         if not cell.done_event.is_set():
@@ -458,7 +458,7 @@ class CodeModeManager:
             return "Script failed"
         return "Script completed"
 
-    def _parse_exec_source(self, input_text: str) -> ParsedExecSource:
+    def _parse_exec_source(self, input_text: 'str') -> 'ParsedExecSource':
         if not input_text.strip():
             raise ValueError(
                 "exec expects raw JavaScript source text (non-empty)."
@@ -499,13 +499,13 @@ class CodeModeManager:
             max_output_tokens=max_output_tokens,
         )
 
-    def _normalize_identifier(self, tool_name: str) -> str:
+    def _normalize_identifier(self, tool_name: 'str') -> 'str':
         identifier = []
         for index, char in enumerate(tool_name):
             is_valid = (
                 char == "_"
                 or char == "$"
-                or (char.isascii() and char.isalnum() and (index != 0 or char.isalpha()))
+                or (is_ascii(char) and char.isalnum() and (index != 0 or char.isalpha()))
             )
             if is_valid:
                 identifier.append(char)
@@ -513,7 +513,7 @@ class CodeModeManager:
                 identifier.append("_")
         return "".join(identifier) or "_"
 
-    def _coerce_optional_text(self, value: JSONValue) -> str | None:
+    def _coerce_optional_text(self, value: 'JSONValue') -> 'typing.Union[str, None]':
         if value in (None, ""):
             return None
         return str(value)

pycodex/tools/exec_command_tool.py

@@ -10,8 +10,6 @@ Expected behavior:
   `write_stdin`.
 """
 
-from __future__ import annotations
-
 from ..protocol import JSONDict, JSONValue
 from .base_tool import BaseTool, ToolContext
 from .unified_exec_manager import (
@@ -21,6 +19,7 @@ from .unified_exec_manager import (
     UNIFIED_EXEC_OUTPUT_SCHEMA,
     UnifiedExecManager,
 )
+import typing
 
 
 class ExecCommandTool(BaseTool):
@@ -64,10 +63,10 @@ class ExecCommandTool(BaseTool):
     output_schema = UNIFIED_EXEC_OUTPUT_SCHEMA
     supports_parallel = False
 
-    def __init__(self, manager: UnifiedExecManager) -> None:
+    def __init__(self, manager: 'UnifiedExecManager') -> 'None':
         self._manager = manager
 
-    async def run(self, context: ToolContext, args: JSONDict) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
         del context
         cmd = str(args.get("cmd", "")).strip()
         if not cmd:
@@ -83,13 +82,13 @@ class ExecCommandTool(BaseTool):
             max_output_tokens=self._optional_int(args, "max_output_tokens"),
         )
 
-    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
         return str(value)
 
-    def _optional_int(self, args: JSONDict, key: str) -> int | None:
+    def _optional_int(self, args: 'JSONDict', key: 'str') -> 'typing.Union[int, None]':
         value = args.get(key)
         if value in (None, ""):
             return None

pycodex/tools/exec_runtime.js

@@ -1,5 +1,5 @@
-const readline = require('node:readline');
-const { stdin, stdout } = require('node:process');
+const readline = require('readline');
+const { stdin, stdout } = require('process');
 
 const pending = new Map();
 let storedValues = {};
@@ -41,7 +41,7 @@ function image(value) {
     send({
       type: 'output_image',
       image_url: value.image_url,
-      detail: value.detail ?? null,
+      detail: value.detail === undefined ? null : value.detail,
     });
     return;
   }

pycodex/tools/exec_tool.py

@@ -11,8 +11,6 @@ Expected behavior:
   resumed via `wait`.
 """
 
-from __future__ import annotations
-
 from ..protocol import JSONValue
 from .base_tool import BaseTool, ToolContext
 from .code_mode_manager import CodeModeManager
@@ -41,8 +39,8 @@ class ExecTool(BaseTool):
     }
     supports_parallel = False
 
-    def __init__(self, manager: CodeModeManager) -> None:
+    def __init__(self, manager: 'CodeModeManager') -> 'None':
         self._manager = manager
 
-    async def run(self, context: ToolContext, args: JSONValue) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONValue') -> 'JSONValue':
         return await self._manager.exec(str(args), context)

pycodex/tools/grep_files_tool.py

@@ -9,8 +9,6 @@ Expected behavior:
   parameters rather than delegating to a shell transcript.
 """
 
-from __future__ import annotations
-
 import asyncio
 import fnmatch
 import re
@@ -18,6 +16,7 @@ from pathlib import Path
 
 from ..protocol import JSONDict, JSONValue
 from .base_tool import BaseTool, ToolContext
+import typing
 
 DEFAULT_LIMIT = 100
 MAX_LIMIT = 2000
@@ -41,10 +40,10 @@ class GrepFilesTool(BaseTool):
         "required": ["pattern"],
     }
 
-    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
         pattern = str(args.get("pattern", "")).strip()
         include = str(args.get("include", "")).strip() or None
@@ -111,13 +110,13 @@ class GrepFilesTool(BaseTool):
 
     def _search_with_python(
         self,
-        pattern: str,
-        include: str | None,
-        search_path: Path,
-        limit: int,
-    ) -> list[str]:
+        pattern: 'str',
+        include: 'typing.Union[str, None]',
+        search_path: 'Path',
+        limit: 'int',
+    ) -> 'typing.List[str]':
         regex = re.compile(pattern)
-        candidates: list[Path] = []
+        candidates: 'typing.List[Path]' = []
 
         if search_path.is_file():
             candidates = [search_path]
@@ -141,7 +140,7 @@ class GrepFilesTool(BaseTool):
         matches.sort(key=lambda path: path.stat().st_mtime, reverse=True)
         return [str(path) for path in matches[:limit]]
 
-    def _resolve_path(self, path_arg) -> Path:
+    def _resolve_path(self, path_arg) -> 'Path':
         if path_arg in (None, ""):
             return self._working_directory
         path = Path(str(path_arg))

pycodex/tools/list_dir_tool.py

@@ -9,13 +9,12 @@ Expected behavior:
   commands like `find` or `ls -R`.
 """
 
-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_ENTRY_LENGTH = 500
 INDENTATION_SPACES = 2
@@ -38,7 +37,7 @@ class ListDirTool(BaseTool):
         "required": ["dir_path"],
     }
 
-    async def run(self, context: ToolContext, args: JSONDict) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
         del context
         dir_path = Path(str(args.get("dir_path", "")))
         offset = int(args.get("offset", 1))
@@ -74,8 +73,8 @@ class ListDirTool(BaseTool):
             lines.append(f"More than {len(selected)} entries found")
         return "\n".join(lines)
 
-    def _collect_entries(self, root: Path, depth: int) -> list[dict[str, object]]:
-        entries: list[dict[str, object]] = []
+    def _collect_entries(self, root: 'Path', depth: 'int') -> 'typing.List[typing.Dict[str, object]]':
+        entries: 'typing.List[typing.Dict[str, object]]' = []
         queue = deque([(root, Path(), depth)])
 
         while queue:
@@ -106,7 +105,7 @@ class ListDirTool(BaseTool):
         entries.sort(key=lambda entry: entry["name"])
         return entries
 
-    def _entry_kind(self, path: Path) -> str:
+    def _entry_kind(self, path: 'Path') -> 'str':
         if path.is_symlink():
             return "symlink"
         if path.is_dir():
@@ -115,14 +114,14 @@ class ListDirTool(BaseTool):
             return "file"
         return "other"
 
-    def _format_entry_name(self, path: Path) -> str:
+    def _format_entry_name(self, path: 'Path') -> 'str':
         text = path.as_posix()
         return text[:MAX_ENTRY_LENGTH]
 
-    def _format_component(self, name: str) -> str:
+    def _format_component(self, name: 'str') -> 'str':
         return name[:MAX_ENTRY_LENGTH]
 
-    def _format_entry_line(self, entry: dict[str, object]) -> str:
+    def _format_entry_line(self, entry: 'typing.Dict[str, object]') -> 'str':
         indent = " " * (int(entry["depth"]) * INDENTATION_SPACES)
         name = str(entry["display_name"])
         kind = str(entry["kind"])