python-codex 0.4.7__py3-none-any.whl → 0.5.0__py3-none-any.whl

pycodex/agent.py

@@ -152,6 +152,13 @@ class Agent:
         self.context_manager.set_model(model)
         self._last_total_usage_tokens = None
 
+    def set_cwd(self, cwd: "typing.Union[str, Path]") -> "None":
+        if self.is_running:
+            raise RuntimeError("cannot change directory while agent is running")
+        if not self.accepts_input:
+            raise RuntimeError("cannot change directory while agent is closing or closed")
+        self.context_manager.set_cwd(cwd)
+
     def resume(
         self, session_file_path: "typing.Union[str, Path, None]" = None
     ) -> "typing.Union[typing.Dict[str, object], None]":
@@ -400,6 +407,7 @@ class Agent:
             context = ToolContext(
                 turn_id=turn_id,
                 history=self.history,
+                cwd=self.context_manager.cwd,
             )
             if len(batch) == 1:
                 results.append(await self._run_single_tool(turn_id, batch[0], context))

pycodex/bootstrap.py

@@ -86,7 +86,6 @@ def configure_loguru() -> "None":
 def get_tools(
     runtime_environment: "typing.Union[AgentRuntimeEnvironment, None]" = None,
     exec_mode: "bool" = False,
-    cwd: "typing.Union[str, Path, None]" = None,
     toolset: "typing.Union[typing.Iterable[str], None]" = None,
 ):
     from .tools import (
@@ -119,8 +118,8 @@ def get_tools(
 
     runtime_environment = runtime_environment or create_agent_runtime_environment()
     registry = Registry(runtime_environment)
-    code_mode_manager = CodeModeManager(registry, cwd=cwd)
-    unified_exec_manager = UnifiedExecManager(cwd=cwd)
+    code_mode_manager = CodeModeManager(registry)
+    unified_exec_manager = UnifiedExecManager()
     clock_manager = ClockManager()
     exec_tool = ExecTool(code_mode_manager)
     wait_tool = WaitTool(code_mode_manager)
@@ -135,16 +134,16 @@ def get_tools(
     resume_agent_tool = ResumeAgentTool(runtime_environment.subagent_manager)
     wait_agent_tool = WaitAgentTool(runtime_environment.subagent_manager)
     close_agent_tool = CloseAgentTool(runtime_environment.subagent_manager)
-    apply_patch_tool = ApplyPatchTool(cwd=cwd)
-    shell_tool = ShellTool(cwd=cwd)
-    shell_command_tool = ShellCommandTool(cwd=cwd)
+    apply_patch_tool = ApplyPatchTool()
+    shell_tool = ShellTool()
+    shell_command_tool = ShellCommandTool()
     exec_command_tool = ExecCommandTool(unified_exec_manager)
     write_stdin_tool = WriteStdinTool(unified_exec_manager)
     clock_tool = ClockTool(clock_manager)
-    grep_files_tool = GrepFilesTool(cwd=cwd)
+    grep_files_tool = GrepFilesTool()
     read_file_tool = ReadFileTool()
     list_dir_tool = ListDirTool()
-    view_image_tool = ViewImageTool(cwd=cwd)
+    view_image_tool = ViewImageTool()
     tools = (
         shell_tool,
         shell_command_tool,
@@ -200,7 +199,6 @@ def get_tools(
 
 def get_subagent_tools(
     runtime_environment: "typing.Union[AgentRuntimeEnvironment, None]" = None,
-    cwd: "typing.Union[str, Path, None]" = None,
 ):
     from .tools import (
         ApplyPatchTool,
@@ -215,13 +213,13 @@ def get_subagent_tools(
 
     runtime_environment = runtime_environment or create_agent_runtime_environment()
     registry = Registry(runtime_environment)
-    unified_exec_manager = UnifiedExecManager(cwd=cwd)
+    unified_exec_manager = UnifiedExecManager()
     registry.register(ExecCommandTool(unified_exec_manager))
     registry.register(WriteStdinTool(unified_exec_manager))
     registry.register(UpdatePlanTool(runtime_environment.plan_store))
-    registry.register(ApplyPatchTool(cwd=cwd))
+    registry.register(ApplyPatchTool())
     registry.register(WebSearchTool())
-    registry.register(ViewImageTool(cwd=cwd))
+    registry.register(ViewImageTool())
     return registry
 
 
@@ -244,46 +242,41 @@ def build_agent(
     )
     runtime_environment = create_agent_runtime_environment()
 
-    def make_subagent_runtime_builder(base_client):
+    def make_subagent_runtime_builder(parent_agent):
         def build_subagent_runtime(
             model_override: "typing.Union[str, None]",
             reasoning_effort_override: "typing.Union[str, None]",
             initial_history=(),
             session_id: "typing.Union[str, None]" = None,
         ) -> "AgentRuntime":
-            nested_client = base_client.with_overrides(
+            nested_client = parent_agent.model_client.with_overrides(
                 model_override,
                 reasoning_effort_override,
                 session_id=session_id,
                 openai_subagent="collab_spawn",
             )
             subagent_agent_runtime_environment = create_agent_runtime_environment()
-            subagent_agent_runtime_environment.subagent_manager.set_runtime_builder(
-                make_subagent_runtime_builder(nested_client)
-            )
+            inherited_cwd = parent_agent.context_manager.cwd
             sub_agent = Agent(
                 nested_client,
-                get_subagent_tools(
-                    subagent_agent_runtime_environment, cwd=resolved_cwd
-                ),
-                context_config,
+                get_subagent_tools(subagent_agent_runtime_environment),
+                replace(context_config, cwd=inherited_cwd),
                 initial_history=tuple(initial_history),
                 session_id=session_id,
             )
+            subagent_agent_runtime_environment.subagent_manager.set_runtime_builder(
+                make_subagent_runtime_builder(sub_agent)
+            )
             return AgentRuntime(sub_agent)
 
         return build_subagent_runtime
 
-    runtime_environment.subagent_manager.set_runtime_builder(
-        make_subagent_runtime_builder(client)
-    )
     session_id = uuid7_string()
-    return Agent(
+    agent = Agent(
         client,
         get_tools(
             runtime_environment,
             exec_mode=True,
-            cwd=resolved_cwd,
             toolset=toolset,
         ),
         context_config,
@@ -292,6 +285,10 @@ def build_agent(
         ),
         session_id=session_id,
     )
+    runtime_environment.subagent_manager.set_runtime_builder(
+        make_subagent_runtime_builder(agent)
+    )
+    return agent
 
 
 def build_model(

pycodex/context.py

@@ -244,6 +244,16 @@ class ContextManager:
     def set_model(self, model: "str") -> "None":
         self._config = replace(self._config, model=model)
 
+    def set_cwd(self, cwd: "typing.Union[str, Path]") -> "None":
+        path = Path(cwd).expanduser()
+        path = (self.cwd / path).resolve(strict=True)
+        if not path.is_dir():
+            raise NotADirectoryError(str(path))
+        self.cwd = path
+        self._config = replace(self._config, cwd=path)
+        self._workspace_metadata_turn_id = None
+        self._workspace_metadata_cache = None
+
     def resolve_auto_compact_token_limit(self) -> "typing.Union[int, None]":
         if self._config.model_auto_compact_token_limit is not None:
             return self._config.model_auto_compact_token_limit

pycodex/runtime.py

@@ -124,6 +124,7 @@ class AgentRuntime:
                 "help",
                 "history",
                 "title",
+                "cd",
                 "model",
                 "effort",
                 "resume",
@@ -139,6 +140,7 @@ class AgentRuntime:
         recorded_path = self.agent.recorded_session_file_path
         return {
             "session_id": self.agent.session_id,
+            "cwd": str(self.agent.context_manager.cwd),
             "rollout_path": str(rollout_path) if rollout_path is not None else None,
             "recorded_rollout_path": (
                 str(recorded_path) if recorded_path is not None else None
@@ -187,6 +189,11 @@ class AgentRuntime:
         self.agent.set_model(model)
         self.publish_state("model")
 
+    def set_cwd(self, cwd):
+        self.require_idle("change directory")
+        self.agent.set_cwd(cwd)
+        self.publish_state("cwd")
+
     def resume(self, path=None, title=""):
         self.require_idle("resume")
         resumed = self.agent.resume(path)
@@ -275,6 +282,10 @@ class AgentRuntime:
             return {"kind": "help", "commands": self.commands()}
         if command == "history":
             return {"kind": "history", "state": self.snapshot()}
+        if command == "cd":
+            if argument:
+                self.set_cwd(argument)
+            return {"kind": "cwd", "cwd": str(self.agent.context_manager.cwd)}
         if command == "title":
             if argument:
                 self.set_title(argument)

pycodex/tools/apply_patch_tool.py

@@ -92,20 +92,15 @@ class ApplyPatchTool(BaseTool):
     }
     supports_parallel = False
 
-    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":
-        del context
+        cwd = context.cwd
         patch_text = str(args)
         logger.debug(
-            "apply_patch workspace={} bytes={}", self._workspace_root, len(patch_text)
+            "apply_patch workspace={} bytes={}", cwd, len(patch_text)
         )
         try:
             operations = self._parse_patch(patch_text)
-            return self._format_result(self._apply_operations(operations), exit_code=0)
+            return self._format_result(self._apply_operations(operations, cwd), exit_code=0)
         except ApplyPatchError as exc:
             return self._format_result(str(exc), exit_code=1)
 
@@ -239,52 +234,54 @@ class ApplyPatchTool(BaseTool):
     def _apply_operations(
         self,
         operations: "typing.List[typing.Union[typing.Union[_AddFileOp, _DeleteFileOp], _UpdateFileOp]]",
+        cwd: "Path",
     ) -> "str":
         preview: "typing.Dict[Path, typing.Union[str, None]]" = {}
         summaries: "typing.Dict[Path, str]" = {}
 
         for operation in operations:
             if isinstance(operation, _AddFileOp):
-                path = self._resolve_workspace_path(operation.path)
+                path = self._resolve_workspace_path(operation.path, cwd)
                 preview[path] = operation.content
                 summaries[path] = "A"
                 continue
 
             if isinstance(operation, _DeleteFileOp):
-                path = self._resolve_workspace_path(operation.path)
-                self._read_preview_file(path, preview)
+                path = self._resolve_workspace_path(operation.path, cwd)
+                self._read_preview_file(path, preview, cwd)
                 preview[path] = None
                 summaries[path] = "D"
                 continue
 
-            path = self._resolve_workspace_path(operation.path)
-            original = self._read_preview_file(path, preview)
-            updated = self._apply_update(path, original, operation.sections)
+            path = self._resolve_workspace_path(operation.path, cwd)
+            original = self._read_preview_file(path, preview, cwd)
+            updated = self._apply_update(path, original, operation.sections, cwd)
             destination = path
             if operation.move_to is not None:
-                destination = self._resolve_workspace_path(operation.move_to)
+                destination = self._resolve_workspace_path(operation.move_to, cwd)
                 preview[path] = None
                 summaries.pop(path, None)
             preview[destination] = updated
             summaries[destination] = "M"
 
         self._write_preview(preview)
-        return self._format_success(summaries)
+        return self._format_success(summaries, cwd)
 
     def _read_preview_file(
-        self, path: "Path", preview: "typing.Dict[Path, typing.Union[str, None]]"
+        self, path: "Path", preview: "typing.Dict[Path, typing.Union[str, None]]",
+        cwd: "Path",
     ) -> "str":
         if path in preview:
             content = preview[path]
             if content is None:
                 raise ApplyPatchError(
-                    f"apply_patch verification failed: Failed to read {self._display_path(path)}"
+                    f"apply_patch verification failed: Failed to read {self._display_path(path, cwd)}"
                 )
             return content
 
         if not path.exists() or not path.is_file():
             raise ApplyPatchError(
-                f"apply_patch verification failed: Failed to read {self._display_path(path)}"
+                f"apply_patch verification failed: Failed to read {self._display_path(path, cwd)}"
             )
         return path.read_text(encoding="utf-8", errors="replace")
 
@@ -293,6 +290,7 @@ class ApplyPatchTool(BaseTool):
         path: "Path",
         original_text: "str",
         sections: "typing.Tuple[_UpdateSection, ...]",
+        cwd: "Path",
     ) -> "str":
         lines = original_text.splitlines()
         cursor = 0
@@ -308,7 +306,7 @@ class ApplyPatchTool(BaseTool):
             if match_index is None:
                 raise ApplyPatchError(
                     "apply_patch verification failed: Failed to find expected lines in "
-                    f"{self._display_path(path)}"
+                    f"{self._display_path(path, cwd)}"
                 )
             lines[match_index : match_index + len(old_block)] = new_block
             cursor = match_index + len(new_block)
@@ -350,10 +348,10 @@ class ApplyPatchTool(BaseTool):
             path.parent.mkdir(parents=True, exist_ok=True)
             path.write_text(content, encoding="utf-8")
 
-    def _format_success(self, summaries: "typing.Dict[Path, str]") -> "str":
+    def _format_success(self, summaries: "typing.Dict[Path, str]", cwd: "Path") -> "str":
         buckets = {"A": [], "M": [], "D": []}
         for path, status in summaries.items():
-            buckets[status].append(self._display_path(path))
+            buckets[status].append(self._display_path(path, cwd))
         lines = ["Success:"]
         for status in ("A", "M", "D"):
             for rel_path in sorted(buckets[status]):
@@ -365,14 +363,14 @@ class ApplyPatchTool(BaseTool):
             f"Exit code: {exit_code}\n" "Wall time: 0 seconds\n" "Output:\n" f"{output}"
         )
 
-    def _resolve_workspace_path(self, path_text: "str") -> "Path":
+    def _resolve_workspace_path(self, path_text: "str", cwd: "Path") -> "Path":
         path = Path(path_text).expanduser()
-        resolved = path if path.is_absolute() else self._workspace_root / path
+        resolved = path if path.is_absolute() else cwd / path
         return resolved.resolve()
 
-    def _display_path(self, path: "Path") -> "str":
+    def _display_path(self, path: "Path", cwd: "Path") -> "str":
         try:
-            return path.relative_to(self._workspace_root).as_posix()
+            return path.relative_to(cwd).as_posix()
         except ValueError:
             return str(path)
 

pycodex/tools/base_tool.py

@@ -16,6 +16,7 @@ import traceback
 import typing
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
+from pathlib import Path
 
 from ..events import Event
 from ..protocol import (
@@ -40,6 +41,10 @@ if typing.TYPE_CHECKING:
 class ToolContext:
     turn_id: "str"
     history: "typing.Tuple[ConversationItem, ...]"
+    cwd: "Path"
+
+    def resolve_path(self, path=None) -> "Path":
+        return (self.cwd / Path("." if path is None else path).expanduser()).resolve()
 
 
 class StructuredToolOutput:

pycodex/tools/code_mode_manager.py

@@ -60,13 +60,8 @@ class ParsedExecSource:
 
 
 class CodeModeManager:
-    def __init__(
-        self,
-        registry: "ToolRegistry",
-        cwd: "typing.Union[typing.Union[str, Path], None]" = None,
-    ) -> "None":
+    def __init__(self, registry: "ToolRegistry") -> "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: "typing.Dict[str, JSONValue]" = {}
         self._cells: "typing.Dict[str, ExecCell]" = {}
@@ -130,7 +125,7 @@ class CodeModeManager:
         process = await asyncio.create_subprocess_exec(
             "node",
             str(self._runtime_script),
-            cwd=str(self._default_cwd),
+            cwd=str(context.cwd),
             stdin=asyncio.subprocess.PIPE,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
@@ -153,7 +148,7 @@ class CodeModeManager:
                 "tools": self.enabled_tools(),
             },
         )
-        logger.debug("exec start cell_id={} cwd={}", cell_id, self._default_cwd)
+        logger.debug("exec start cell_id={} cwd={}", cell_id, context.cwd)
         return cell
 
     async def _read_stdout(self, cell: "ExecCell", context: "ToolContext") -> "None":
@@ -278,7 +273,7 @@ class CodeModeManager:
                 arguments=message.get("arguments"),
                 tool_type=tool.tool_type,
             ),
-            ToolContext(turn_id=context.turn_id, history=context.history),
+            context,
         )
         if result.is_error:
             payload = {

pycodex/tools/exec_command_tool.py

@@ -87,14 +87,13 @@ class ExecCommandTool(BaseTool):
         return self._manager.running_session_count()
 
     async def run(self, context: "ToolContext", args: "JSONDict") -> "JSONValue":
-        del context
         cmd = str(args.get("cmd", "")).strip()
         if not cmd:
             return "Error: `cmd` is required."
 
         return await self._manager.exec_command(
             cmd=cmd,
-            workdir=self._optional_string(args, "workdir"),
+            cwd=context.resolve_path(args.get("workdir")),
             shell=self._optional_string(args, "shell"),
             login=bool(args.get("login", DEFAULT_LOGIN)),
             tty=bool(args.get("tty", DEFAULT_TTY)),

pycodex/tools/grep_files_tool.py

@@ -53,18 +53,12 @@ class GrepFilesTool(BaseTool):
         "additionalProperties": False,
     }
 
-    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":
-        del context
         pattern = str(args.get("pattern", "")).strip()
         include = str(args.get("include", "")).strip() or None
         limit = min(int(args.get("limit", DEFAULT_LIMIT)), MAX_LIMIT)
         path_arg = args.get("path")
-        search_path = self._resolve_path(path_arg)
+        search_path = context.resolve_path(path_arg)
 
         if not pattern:
             return "Error: `pattern` must not be empty."
@@ -88,7 +82,7 @@ class GrepFilesTool(BaseTool):
         try:
             process = await asyncio.create_subprocess_exec(
                 *command,
-                cwd=str(self._working_directory),
+                cwd=str(context.cwd),
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
             )
@@ -154,11 +148,3 @@ 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":
-        if path_arg in (None, ""):
-            return self._working_directory
-        path = Path(str(path_arg))
-        if not path.is_absolute():
-            path = self._working_directory / path
-        return path.resolve()

pycodex/tools/shell_command_tool.py

@@ -12,8 +12,6 @@ Expected behavior:
 """
 
 import asyncio
-import typing
-from pathlib import Path
 
 from ..protocol import JSONDict, JSONValue
 from .base_tool import BaseTool, ToolContext
@@ -54,13 +52,7 @@ class ShellCommandTool(BaseTool):
     }
     supports_parallel = False
 
-    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":
-        del context
         command = str(args.get("command", "")).strip()
         timeout_ms = int(args.get("timeout_ms", DEFAULT_SHELL_TIMEOUT_MS))
         if not command:
@@ -68,7 +60,7 @@ class ShellCommandTool(BaseTool):
 
         login = bool(args.get("login", True))
         workdir_arg = args.get("workdir")
-        working_directory = self._resolve_workdir(workdir_arg)
+        working_directory = context.resolve_path(workdir_arg)
         shell_args = ["bash", "-lc" if login else "-c", command]
 
         process = await asyncio.create_subprocess_exec(
@@ -111,14 +103,6 @@ class ShellCommandTool(BaseTool):
 
         return "\n".join(pieces)
 
-    def _resolve_workdir(self, workdir_arg) -> "Path":
-        if workdir_arg in (None, ""):
-            return self._working_directory
-        workdir = Path(str(workdir_arg))
-        if not workdir.is_absolute():
-            workdir = self._working_directory / workdir
-        return workdir.resolve()
-
     def _clip_output(self, text: "str") -> "str":
         if len(text) <= MAX_OUTPUT_CHARS:
             return text

pycodex/tools/shell_tool.py

@@ -12,8 +12,6 @@ Expected behavior:
 """
 
 import asyncio
-import typing
-from pathlib import Path
 
 from ..protocol import JSONDict, JSONValue
 from .base_tool import BaseTool, ToolContext
@@ -51,13 +49,7 @@ class ShellTool(BaseTool):
     }
     supports_parallel = False
 
-    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":
-        del context
         command = args.get("command")
         timeout_ms = int(args.get("timeout_ms", DEFAULT_SHELL_TIMEOUT_MS))
         if not isinstance(command, list) or not command:
@@ -66,7 +58,7 @@ class ShellTool(BaseTool):
             return "Error: each `command` entry must be a non-empty string."
 
         workdir_arg = args.get("workdir")
-        working_directory = self._resolve_workdir(workdir_arg)
+        working_directory = context.resolve_path(workdir_arg)
 
         process = await asyncio.create_subprocess_exec(
             *command,
@@ -108,14 +100,6 @@ class ShellTool(BaseTool):
 
         return "\n".join(pieces)
 
-    def _resolve_workdir(self, workdir_arg) -> "Path":
-        if workdir_arg in (None, ""):
-            return self._working_directory
-        workdir = Path(str(workdir_arg))
-        if not workdir.is_absolute():
-            workdir = self._working_directory / workdir
-        return workdir.resolve()
-
     def _clip_output(self, text: "str") -> "str":
         if len(text) <= MAX_OUTPUT_CHARS:
             return text

pycodex/tools/unified_exec_manager.py

@@ -121,10 +121,7 @@ class UnifiedExecSession:
 
 
 class UnifiedExecManager:
-    def __init__(
-        self, cwd: "typing.Union[typing.Union[str, Path], None]" = None
-    ) -> "None":
-        self._default_cwd = Path(cwd or Path.cwd()).resolve()
+    def __init__(self) -> "None":
         self._next_session_id = DEFAULT_SESSION_ID_START
         self._sessions: "typing.Dict[int, UnifiedExecSession]" = {}
         self._lock = threading.Lock()
@@ -146,7 +143,7 @@ class UnifiedExecManager:
     async def exec_command(
         self,
         cmd: "str",
-        workdir: "typing.Union[str, None]" = None,
+        cwd: "Path",
         shell: "typing.Union[str, None]" = None,
         login: "bool" = DEFAULT_LOGIN,
         tty: "bool" = DEFAULT_TTY,
@@ -155,7 +152,6 @@ class UnifiedExecManager:
     ) -> "str":
         session_id = await self._allocate_session_id()
         command = self._build_shell_command(cmd, shell, login)
-        cwd = self._resolve_workdir(workdir)
         logger.debug(
             "exec_command start session_id={} shell_command={} cwd={}",
             session_id,
@@ -381,14 +377,6 @@ class UnifiedExecManager:
                 }
             )
 
-    def _resolve_workdir(self, workdir: "typing.Union[str, None]") -> "Path":
-        if not workdir:
-            return self._default_cwd
-        path = Path(workdir)
-        if not path.is_absolute():
-            path = self._default_cwd / path
-        return path.resolve()
-
     def _build_shell_command(
         self,
         cmd: "str",

pycodex/tools/view_image_tool.py

@@ -15,9 +15,7 @@ Expected behavior:
   item that Codex uses when feeding image tool output back to the model.
 """
 
-import typing
 from importlib.util import find_spec
-from pathlib import Path
 
 from ..protocol import JSONDict, JSONValue
 from ..utils.image_utils import ImageProcessingError, load_image_data_url
@@ -65,13 +63,7 @@ class ViewImageTool(BaseTool):
     }
     output_schema = VIEW_IMAGE_OUTPUT_SCHEMA
 
-    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: "JSONDict") -> "JSONValue":
-        del context
         path_value = str(args.get("path", "")).strip()
         if not path_value:
             return "Error: `path` is required."
@@ -88,10 +80,7 @@ class ViewImageTool(BaseTool):
                 f"`{detail_value}`."
             )
 
-        path = Path(path_value)
-        if not path.is_absolute():
-            path = self._workspace_root / path
-        path = path.resolve()
+        path = context.resolve_path(path_value)
         if not path.exists():
             return f"Error: unable to locate image at `{path}`."
         if not path.is_file():

pycodex/utils/event_helpers.py

@@ -26,6 +26,8 @@ def format_command_result(result: "typing.Dict[str, object]") -> "str":
         return "Extra commands: " + ", ".join("/" + name for name in result["commands"])
     if kind in {"title", "title_changed"}:
         return "Session: " + (result["title"] or "untitled")
+    if kind == "cwd":
+        return "Current directory: " + result["cwd"]
     if kind == "models":
         return (
             "Current model: "