wcgw 3.0.1rc2__py3-none-any.whl → 3.0.2__py3-none-any.whl

wcgw/client/bash_state/bash_state.py

@@ -8,8 +8,6 @@ import traceback
 from dataclasses import dataclass
 from typing import (
     Any,
-    Callable,
-    Concatenate,
     Literal,
     Optional,
     ParamSpec,
@@ -32,7 +30,8 @@ from ...types_ import (
 from ..encoder import EncoderDecoder
 from ..modes import BashCommandMode, FileEditMode, WriteIfEmptyMode
 
-PROMPT_CONST = "#" + "@wcgw@#"
+PROMPT_CONST = "wcgw→" + " "
+PROMPT_STATEMENT = "export GIT_PAGER=cat PAGER=cat PROMPT_COMMAND= PS1='wcgw→'' '"
 BASH_CLF_OUTPUT = Literal["repl", "pending"]
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 
@@ -79,9 +78,7 @@ def get_tmpdir() -> str:
 
 def check_if_screen_command_available() -> bool:
     try:
-        subprocess.run(
-            ["screen", "-v"], capture_output=True, check=True, timeout=CONFIG.timeout
-        )
+        subprocess.run(["screen", "-v"], capture_output=True, check=True, timeout=0.2)
         return True
     except (subprocess.CalledProcessError, FileNotFoundError):
         return False
@@ -100,7 +97,7 @@ def cleanup_all_screens_with_name(name: str, console: Console) -> None:
             capture_output=True,
             text=True,
             check=True,
-            timeout=CONFIG.timeout,
+            timeout=0.2,
         )
         output = result.stdout
     except subprocess.CalledProcessError as e:
@@ -108,6 +105,9 @@ def cleanup_all_screens_with_name(name: str, console: Console) -> None:
         output = (e.stdout or "") + (e.stderr or "")
     except FileNotFoundError:
         return
+    except Exception as e:
+        console.log(f"{e}: exception while clearing running screens.")
+        return
 
     sessions_to_kill = []
 
@@ -131,8 +131,8 @@ def cleanup_all_screens_with_name(name: str, console: Console) -> None:
                 check=True,
                 timeout=CONFIG.timeout,
             )
-        except (subprocess.CalledProcessError, FileNotFoundError):
-            console.log(f"Failed to kill screen session: {session}")
+        except Exception as e:
+            console.log(f"Failed to kill screen session: {session}\n{e}")
 
 
 def start_shell(
@@ -146,23 +146,21 @@ def start_shell(
         **os.environ,
         "PS1": PROMPT_CONST,
         "TMPDIR": get_tmpdir(),
-        "TERM": "vt100",
+        "TERM": "xterm-256color",
     }
     try:
         shell = pexpect.spawn(
             cmd,
             env=overrideenv,  # type: ignore[arg-type]
-            echo=False,
+            echo=True,
             encoding="utf-8",
             timeout=CONFIG.timeout,
             cwd=initial_dir,
             codec_errors="backslashreplace",
             dimensions=(500, 160),
         )
-        shell.sendline(
-            f"export PROMPT_COMMAND= PS1={PROMPT_CONST}"
-        )  # Unset prompt command to avoid interfering
-        shell.expect(PROMPT_CONST, timeout=CONFIG.timeout)
+        shell.sendline(PROMPT_STATEMENT)  # Unset prompt command to avoid interfering
+        shell.expect(PROMPT_CONST, timeout=0.2)
     except Exception as e:
         console.print(traceback.format_exc())
         console.log(f"Error starting shell: {e}. Retrying without rc ...")
@@ -170,13 +168,13 @@ def start_shell(
         shell = pexpect.spawn(
             "/bin/bash --noprofile --norc",
             env=overrideenv,  # type: ignore[arg-type]
-            echo=False,
+            echo=True,
             encoding="utf-8",
             timeout=CONFIG.timeout,
             codec_errors="backslashreplace",
         )
-        shell.sendline(f"export PS1={PROMPT_CONST}")
-        shell.expect(PROMPT_CONST, timeout=CONFIG.timeout)
+        shell.sendline(PROMPT_STATEMENT)
+        shell.expect(PROMPT_CONST, timeout=0.2)
 
     shellid = "wcgw." + time.strftime("%H%M%S")
     if over_screen:
@@ -184,20 +182,11 @@ def start_shell(
             raise ValueError("Screen command not available")
         # shellid is just hour, minute, second number
         shell.sendline(f"trap 'screen -X -S {shellid} quit' EXIT")
-        shell.expect(PROMPT_CONST, timeout=CONFIG.timeout)
+        shell.expect(PROMPT_CONST, timeout=0.2)
 
         shell.sendline(f"screen -q -S {shellid} /bin/bash --noprofile --norc")
         shell.expect(PROMPT_CONST, timeout=CONFIG.timeout)
 
-    shell.sendline("stty -icanon -echo")
-    shell.expect(PROMPT_CONST, timeout=CONFIG.timeout)
-
-    shell.sendline("set +o pipefail")
-    shell.expect(PROMPT_CONST, timeout=CONFIG.timeout)
-
-    shell.sendline("export GIT_PAGER=cat PAGER=cat")
-    shell.expect(PROMPT_CONST, timeout=CONFIG.timeout)
-
     return shell, shellid
 
 
@@ -229,31 +218,7 @@ P = ParamSpec("P")
 R = TypeVar("R")
 
 
-def requires_shell(
-    func: Callable[Concatenate["BashState", "pexpect.spawn[str]", P], R],
-) -> Callable[Concatenate["BashState", P], R]:
-    def wrapper(self: "BashState", /, *args: P.args, **kwargs: P.kwargs) -> R:
-        if not self._shell_loading.is_set():
-            if not self._shell_loading.wait(timeout=CONFIG.timeout):
-                raise RuntimeError("Shell initialization timeout")
-
-        if self._shell_error:
-            raise RuntimeError(f"Shell failed to initialize: {self._shell_error}.")
-
-        if not self._shell:
-            raise RuntimeError("Shell not initialized")
-
-        return func(self, self._shell, *args, **kwargs)
-
-    return wrapper
-
-
 class BashState:
-    _shell: Optional["pexpect.spawn[str]"]
-    _shell_id: Optional[str]
-    _shell_lock: threading.Lock
-    _shell_loading: threading.Event
-    _shell_error: Optional[Exception]
     _use_screen: bool
 
     def __init__(
@@ -276,68 +241,41 @@ class BashState:
         self._write_if_empty_mode: WriteIfEmptyMode = (
             write_if_empty_mode or WriteIfEmptyMode("all")
         )
-        self._mode = mode or Modes.wcgw
+        self._mode = mode or "wcgw"
         self._whitelist_for_overwrite: set[str] = whitelist_for_overwrite or set()
-        self._prompt = PROMPT_CONST
         self._bg_expect_thread: Optional[threading.Thread] = None
         self._bg_expect_thread_stop_event = threading.Event()
-        self._shell = None
-        self._shell_id = None
-        self._shell_lock = threading.Lock()
-        self._shell_loading = threading.Event()
-        self._shell_error = None
         self._use_screen = use_screen
-        self._start_shell_loading()
+        self._init_shell()
 
-    def _start_shell_loading(self) -> None:
-        def load_shell() -> None:
-            try:
-                with self._shell_lock:
-                    if self._shell is not None:
-                        return
-                    self._init_shell()
-            except Exception as e:
-                self._shell_error = e
-            finally:
-                self._shell_loading.set()
-
-        threading.Thread(target=load_shell).start()
-
-    @requires_shell
-    def expect(
-        self, shell: "pexpect.spawn[str]", pattern: Any, timeout: Optional[float] = -1
-    ) -> int:
+    def expect(self, pattern: Any, timeout: Optional[float] = -1) -> int:
         self.close_bg_expect_thread()
-        return shell.expect(pattern, timeout)
+        output = self._shell.expect(pattern, timeout)
+        return output
 
-    @requires_shell
-    def send(self, shell: "pexpect.spawn[str]", s: str | bytes) -> int:
-        output = shell.send(s)
-        self.run_bg_expect_thread()
+    def send(self, s: str | bytes) -> int:
+        self.close_bg_expect_thread()
+        output = self._shell.send(s)
         return output
 
-    @requires_shell
-    def sendline(self, shell: "pexpect.spawn[str]", s: str | bytes) -> int:
-        output = shell.sendline(s)
-        self.run_bg_expect_thread()
+    def sendline(self, s: str | bytes) -> int:
+        self.close_bg_expect_thread()
+        output = self._shell.sendline(s)
         return output
 
     @property
-    @requires_shell
-    def linesep(self, shell: "pexpect.spawn[str]") -> Any:
-        return shell.linesep
+    def linesep(self) -> Any:
+        return self._shell.linesep
 
-    @requires_shell
-    def sendintr(self, shell: "pexpect.spawn[str]") -> None:
-        shell.sendintr()
+    def sendintr(self) -> None:
+        self.close_bg_expect_thread()
+        self._shell.sendintr()
 
     @property
-    @requires_shell
-    def before(self, shell: "pexpect.spawn[str]") -> Optional[str]:
-        return shell.before
+    def before(self) -> Optional[str]:
+        return self._shell.before
 
-    @requires_shell
-    def run_bg_expect_thread(self, shell: "pexpect.spawn[str]") -> None:
+    def run_bg_expect_thread(self) -> None:
         """
         Run background expect thread for handling shell interactions.
         """
@@ -346,7 +284,7 @@ class BashState:
             while True:
                 if self._bg_expect_thread_stop_event.is_set():
                     break
-                output = shell.expect([pexpect.EOF, pexpect.TIMEOUT], timeout=0.1)
+                output = self._shell.expect([pexpect.EOF, pexpect.TIMEOUT], timeout=0.1)
                 if output == 0:
                     break
 
@@ -367,13 +305,8 @@ class BashState:
 
     def cleanup(self) -> None:
         self.close_bg_expect_thread()
-        with self._shell_lock:
-            if self._shell:
-                self._shell.close(True)
-                if self._shell_id:
-                    cleanup_all_screens_with_name(self._shell_id, self.console)
-                self._shell = None
-                self._shell_id = None
+        self._shell.close(True)
+        cleanup_all_screens_with_name(self._shell_id, self.console)
 
     def __enter__(self) -> "BashState":
         return self
@@ -397,59 +330,41 @@ class BashState:
     def write_if_empty_mode(self) -> WriteIfEmptyMode:
         return self._write_if_empty_mode
 
-    @requires_shell
-    def ensure_env_and_bg_jobs(self, _: "pexpect.spawn[str]") -> Optional[int]:
-        return self._ensure_env_and_bg_jobs()
-
-    def _ensure_env_and_bg_jobs(self) -> Optional[int]:
-        # Do not add @requires_shell decorator here, as it will cause deadlock
-
-        self.close_bg_expect_thread()
-        assert self._shell is not None, "Bad state, shell is not initialized"
-        if self._prompt != PROMPT_CONST:
-            return None
+    def ensure_env_and_bg_jobs(self) -> Optional[int]:
         quick_timeout = 0.2 if not self.over_screen else 1
         # First reset the prompt in case venv was sourced or other reasons.
-        self._shell.sendline(f"export PS1={self._prompt}")
-        self._shell.expect(self._prompt, timeout=quick_timeout)
+        self.sendline(PROMPT_STATEMENT)
+        self.expect(PROMPT_CONST, timeout=quick_timeout)
         # Reset echo also if it was enabled
-        self._shell.sendline("stty -icanon -echo")
-        self._shell.expect(self._prompt, timeout=quick_timeout)
-        self._shell.sendline("set +o pipefail")
-        self._shell.expect(self._prompt, timeout=quick_timeout)
-        self._shell.sendline("export GIT_PAGER=cat PAGER=cat")
-        self._shell.expect(self._prompt, timeout=quick_timeout)
-        self._shell.sendline("jobs | wc -l")
+        command = "jobs | wc -l"
+        self.sendline(command)
         before = ""
         counts = 0
         while not _is_int(before):  # Consume all previous output
             try:
-                self._shell.expect(self._prompt, timeout=quick_timeout)
+                self.expect(PROMPT_CONST, timeout=quick_timeout)
             except pexpect.TIMEOUT:
                 self.console.print(f"Couldn't get exit code, before: {before}")
                 raise
 
-            before_val = self._shell.before
+            before_val = self.before
             if not isinstance(before_val, str):
                 before_val = str(before_val)
             assert isinstance(before_val, str)
             before_lines = render_terminal_output(before_val)
-            before = "\n".join(before_lines).strip()
+            before = "\n".join(before_lines).replace(command, "").strip()
             counts += 1
             if counts > 100:
                 raise ValueError(
                     "Error in understanding shell output. This shouldn't happen, likely shell is in a bad state, please reset it"
                 )
-
         try:
             return int(before)
         except ValueError:
             raise ValueError(f"Malformed output: {before}")
 
     def _init_shell(self) -> None:
-        self._prompt = PROMPT_CONST
         self._state: Literal["repl"] | datetime.datetime = "repl"
-        self._is_in_docker: Optional[str] = ""
         # Ensure self._cwd exists
         os.makedirs(self._cwd, exist_ok=True)
         try:
@@ -474,13 +389,17 @@ class BashState:
             self.over_screen = False
 
         self._pending_output = ""
-        self._ensure_env_and_bg_jobs()
+        try:
+            self.ensure_env_and_bg_jobs()
+        except ValueError as e:
+            self.console.log("Error while running _ensure_env_and_bg_jobs" + str(e))
+
+        self.run_bg_expect_thread()
 
     def set_pending(self, last_pending_output: str) -> None:
         if not isinstance(self._state, datetime.datetime):
             self._state = datetime.datetime.now()
         self._pending_output = last_pending_output
-        self.run_bg_expect_thread()
 
     def set_repl(self) -> None:
         self._state = "repl"
@@ -492,26 +411,18 @@ class BashState:
             return "repl"
         return "pending"
 
-    @property
-    def is_in_docker(self) -> Optional[str]:
-        return self._is_in_docker
-
-    def set_in_docker(self, docker_image_id: str) -> None:
-        self._is_in_docker = docker_image_id
-
     @property
     def cwd(self) -> str:
         return self._cwd
 
     @property
     def prompt(self) -> str:
-        return self._prompt
+        return PROMPT_CONST
 
-    @requires_shell
-    def update_cwd(self, shell: "pexpect.spawn[str]") -> str:
-        shell.sendline("pwd")
-        shell.expect(self._prompt, timeout=0.2)
-        before_val = shell.before
+    def update_cwd(self) -> str:
+        self.sendline("pwd")
+        self.expect(PROMPT_CONST, timeout=0.2)
+        before_val = self.before
         if not isinstance(before_val, str):
             before_val = str(before_val)
         before_lines = render_terminal_output(before_val)
@@ -521,9 +432,7 @@ class BashState:
 
     def reset_shell(self) -> None:
         self.cleanup()
-        self._shell_loading.clear()
-        self._shell_error = None
-        self._start_shell_loading()
+        self._init_shell()
 
     def serialize(self) -> dict[str, Any]:
         """Serialize BashState to a dictionary for saving"""
@@ -543,7 +452,7 @@ class BashState:
             BashCommandMode.deserialize(state["bash_command_mode"]),
             FileEditMode.deserialize(state["file_edit_mode"]),
             WriteIfEmptyMode.deserialize(state["write_if_empty_mode"]),
-            Modes[str(state["mode"])],
+            state["mode"],
             state["whitelist_for_overwrite"],
         )
 
@@ -607,7 +516,7 @@ WAITING_INPUT_MESSAGE = """A command is already running. NOTE: You can't run mul
 1. Get its output using `send_ascii: [10] or send_specials: ["Enter"]`
 2. Use `send_ascii` or `send_specials` to give inputs to the running program, don't use `BashCommand` OR
 3. kill the previous program by sending ctrl+c first using `send_ascii` or `send_specials`
-4. Send the process in background using `send_specials: ["Ctrl-z"]` followed by BashCommand: `bg`
+4. Interrupt and run the process in background by re-running it using screen
 """
 
 
@@ -637,9 +546,8 @@ def _incremental_text(text: str, last_pending_output: str) -> str:
     # text = render_terminal_output(text[-100_000:])
     text = text[-100_000:]
 
-    last_pending_output_rendered_lines = render_terminal_output(last_pending_output)
-    last_pending_output_rendered = "\n".join(last_pending_output_rendered_lines)
-    last_rendered_lines = last_pending_output_rendered.split("\n")
+    last_rendered_lines = render_terminal_output(last_pending_output)
+    last_pending_output_rendered = "\n".join(last_rendered_lines)
     if not last_rendered_lines:
         return rstrip(render_terminal_output(text))
 
@@ -690,6 +598,27 @@ def execute_bash(
     bash_arg: BashCommand,
     max_tokens: Optional[int],
     timeout_s: Optional[float],
+) -> tuple[str, float]:
+    try:
+        output, cost = _execute_bash(bash_state, enc, bash_arg, max_tokens, timeout_s)
+
+        # Remove echo if it's a command
+        if isinstance(bash_arg.action, Command):
+            command = bash_arg.action.command.strip()
+            if output.startswith(command):
+                output = output[len(command) :]
+
+    finally:
+        bash_state.run_bg_expect_thread()
+    return output, cost
+
+
+def _execute_bash(
+    bash_state: BashState,
+    enc: EncoderDecoder[int],
+    bash_arg: BashCommand,
+    max_tokens: Optional[int],
+    timeout_s: Optional[float],
 ) -> tuple[str, float]:
     try:
         is_interrupt = False

wcgw/client/mcp_server/server.py

@@ -1,5 +1,4 @@
 import importlib
-import json
 import logging
 import os
 from typing import Any
@@ -9,7 +8,7 @@ import mcp_wcgw.types as types
 from mcp_wcgw.server import NotificationOptions, Server
 from mcp_wcgw.server.models import InitializationOptions
 from mcp_wcgw.types import Tool as ToolParam
-from pydantic import AnyUrl, ValidationError
+from pydantic import AnyUrl
 
 from wcgw.client.modes import KTS
 from wcgw.client.tool_prompts import TOOL_PROMPTS
@@ -18,7 +17,13 @@ from ...types_ import (
     Initialize,
 )
 from ..bash_state.bash_state import CONFIG, BashState
-from ..tools import Context, default_enc, get_tool_output, which_tool_name
+from ..tools import (
+    Context,
+    default_enc,
+    get_tool_output,
+    parse_tool_by_name,
+    which_tool_name,
+)
 
 server = Server("wcgw")
 
@@ -104,20 +109,7 @@ async def handle_call_tool(
         raise ValueError("Missing arguments")
 
     tool_type = which_tool_name(name)
-
-    try:
-        tool_call = tool_type(**arguments)
-    except ValidationError:
-
-        def try_json(x: str) -> Any:
-            if not isinstance(x, str):
-                return x
-            try:
-                return json.loads(x)
-            except json.JSONDecodeError:
-                return x
-
-        tool_call = tool_type(**{k: try_json(v) for k, v in arguments.items()})
+    tool_call = parse_tool_by_name(name, arguments)
 
     try:
         assert BASH_STATE

wcgw/client/modes.py

@@ -85,7 +85,7 @@ You are now running in "code_writer" mode.
     base += path_prompt
 
     run_command_common = """
-    - Do not use Ctrl-c or Ctrl-z or interrupt commands without asking the user, because often the programs don't show any update but they still are running.
+    - Do not use Ctrl-c interrupt commands without asking the user, because often the programs don't show any update but they still are running.
     - Do not use echo to write multi-line files, always use FileEdit tool to update a code.
     - Do not provide code snippets unless asked by the user, instead directly add/edit the code.
     - You should use the provided bash execution, reading and writing file tools to complete objective.
@@ -124,7 +124,7 @@ Instructions:
     - Do not provide code snippets unless asked by the user, instead directly add/edit the code.
     - Do not install new tools/packages before ensuring no such tools/package or an alternative already exists.
     - Do not use artifacts if you have access to the repository and not asked by the user to provide artifacts/snippets. Directly create/update using wcgw tools
-    - Do not use Ctrl-c or Ctrl-z or interrupt commands without asking the user, because often the programs don't show any update but they still are running.
+    - Do not use Ctrl-c or interrupt commands without asking the user, because often the programs don't show any update but they still are running.
     - Do not use echo to write multi-line files, always use FileEdit tool to update a code.
     
 Additional instructions:
@@ -138,10 +138,11 @@ ARCHITECT_PROMPT = """You are now running in "architect" mode. This means
 - You are not allowed to edit or update any file. You are not allowed to create any file. 
 - You are not allowed to run any commands that may change disk, system configuration, packages or environment. Only read-only commands are allowed.
 - Only run commands that allows you to explore the repository, understand the system or read anything of relevance. 
-- Do not use Ctrl-c or Ctrl-z or interrupt commands without asking the user, because often the programs don't show any update but they still are running.
+- Do not use Ctrl-c or interrupt commands without asking the user, because often the programs don't show any update but they still are running.
 - You are not allowed to change directory (bash will run in -r mode)
+- Share only snippets when any implementation is requested.
 
-Your response should be in self-critique and brainstorm style.
+Respond only after doing the following:
 - Read as many relevant files as possible. 
 - Be comprehensive in your understanding and search of relevant files.
 - First understand about the project by getting the folder structure (ignoring .git, node_modules, venv, etc.)
@@ -149,17 +150,17 @@ Your response should be in self-critique and brainstorm style.
 
 
 DEFAULT_MODES: dict[Modes, ModeImpl] = {
-    Modes.wcgw: ModeImpl(
+    "wcgw": ModeImpl(
         bash_command_mode=BashCommandMode("normal_mode", "all"),
         write_if_empty_mode=WriteIfEmptyMode("all"),
         file_edit_mode=FileEditMode("all"),
     ),
-    Modes.architect: ModeImpl(
+    "architect": ModeImpl(
         bash_command_mode=BashCommandMode("restricted_mode", "all"),
         write_if_empty_mode=WriteIfEmptyMode([]),
         file_edit_mode=FileEditMode([]),
     ),
-    Modes.code_writer: ModeImpl(
+    "code_writer": ModeImpl(
         bash_command_mode=BashCommandMode("normal_mode", "all"),
         write_if_empty_mode=WriteIfEmptyMode("all"),
         file_edit_mode=FileEditMode("all"),
@@ -172,11 +173,11 @@ def modes_to_state(
 ) -> tuple[BashCommandMode, FileEditMode, WriteIfEmptyMode, Modes]:
     # First get default mode config
     if isinstance(mode, str):
-        mode_impl = DEFAULT_MODES[Modes[mode]]  # converts str to Modes enum
-        mode_name = Modes[mode]
+        mode_impl = DEFAULT_MODES[mode]  # converts str to Modes enum
+        mode_name: Modes = mode
     else:
         # For CodeWriterMode, use code_writer as base and override
-        mode_impl = DEFAULT_MODES[Modes.code_writer]
+        mode_impl = DEFAULT_MODES["code_writer"]
         # Override with custom settings from CodeWriterMode
         mode_impl = ModeImpl(
             bash_command_mode=BashCommandMode(
@@ -186,7 +187,7 @@ def modes_to_state(
             file_edit_mode=FileEditMode(mode.allowed_globs),
             write_if_empty_mode=WriteIfEmptyMode(mode.allowed_globs),
         )
-        mode_name = Modes.code_writer
+        mode_name = "code_writer"
     return (
         mode_impl.bash_command_mode,
         mode_impl.file_edit_mode,
@@ -233,4 +234,4 @@ Provide all relevant file paths in order to understand and solve the the task. E
 (Note to self: this conversation can then be resumed later asking "Resume wcgw task `<generated id>`" which should call Initialize tool)
 """
 
-KTS = {Modes.wcgw: WCGW_KT, Modes.architect: ARCHITECT_KT, Modes.code_writer: WCGW_KT}
+KTS = {"wcgw": WCGW_KT, "architect": ARCHITECT_KT, "code_writer": WCGW_KT}

wcgw/client/tool_prompts.py

@@ -9,7 +9,6 @@ from ..types_ import (
     Initialize,
     ReadFiles,
     ReadImage,
-    ResetWcgw,
     WriteIfEmpty,
 )
 
@@ -30,15 +29,15 @@ TOOL_PROMPTS = [
         name="Initialize",
         description="""
 - Always call this at the start of the conversation before using any of the shell tools from wcgw.
-- This will reset the shell.
 - Use `any_workspace_path` to initialize the shell in the appropriate project directory.
-- If the user has mentioned a workspace or project root, use it to set `any_workspace_path`.
-- If the user has mentioned a folder or file with unclear project root, use the file or folder as `any_workspace_path`.
+- If the user has mentioned a workspace or project root or any other file or folder use it to set `any_workspace_path`.
 - If user has mentioned any files use `initial_files_to_read` to read, use absolute paths only.
-- Leave `any_workspace_path` as empty if no file or folder is mentioned.
 - By default use mode "wcgw"
 - In "code-writer" mode, set the commands and globs which user asked to set, otherwise use 'all'.
-- Call `ResetWcgw` if you want to change the mode later.
+- Use type="first_call" if it's the first call to this tool.
+- Use type="user_asked_mode_change" if in a conversation user has asked to change mode.
+- Use type="reset_shell" if in a conversation shell is not working after multiple tries.
+- Use type="user_asked_change_workspace" if in a conversation user asked to change workspace
 """,
     ),
     Prompts(
@@ -79,11 +78,6 @@ TOOL_PROMPTS = [
         name="ReadImage",
         description="Read an image from the shell.",
     ),
-    Prompts(
-        inputSchema=ResetWcgw.model_json_schema(),
-        name="ResetWcgw",
-        description="Resets the shell. Use either when changing mode, or when all interrupts and prompt reset attempts have failed repeatedly.",
-    ),
     Prompts(
         inputSchema=FileEdit.model_json_schema(),
         name="FileEdit",

wcgw/client/tools.py

@@ -10,6 +10,7 @@ from os.path import expanduser
 from pathlib import Path
 from tempfile import NamedTemporaryFile
 from typing import (
+    Any,
     Callable,
     Literal,
     Optional,
@@ -21,7 +22,7 @@ from typing import (
 from openai.types.chat import (
     ChatCompletionMessageParam,
 )
-from pydantic import BaseModel, TypeAdapter
+from pydantic import BaseModel, TypeAdapter, ValidationError
 from syntax_checker import check_syntax
 
 from wcgw.client.bash_state.bash_state import get_status
@@ -37,7 +38,6 @@ from ..types_ import (
     ModesConfig,
     ReadFiles,
     ReadImage,
-    ResetWcgw,
     WriteIfEmpty,
 )
 from .bash_state.bash_state import (
@@ -67,13 +67,13 @@ INITIALIZED = False
 
 def get_mode_prompt(context: Context) -> str:
     mode_prompt = ""
-    if context.bash_state.mode == Modes.code_writer:
+    if context.bash_state.mode == "code_writer":
         mode_prompt = code_writer_prompt(
             context.bash_state.file_edit_mode.allowed_globs,
             context.bash_state.write_if_empty_mode.allowed_globs,
             "all" if context.bash_state.bash_command_mode.allowed_commands else [],
         )
-    elif context.bash_state.mode == Modes.architect:
+    elif context.bash_state.mode == "architect":
         mode_prompt = ARCHITECT_PROMPT
     else:
         mode_prompt = WCGW_PROMPT
@@ -82,6 +82,7 @@ def get_mode_prompt(context: Context) -> str:
 
 
 def initialize(
+    type: Literal["user_asked_change_workspace", "first_call"],
     context: Context,
     any_workspace_path: str,
     read_files_: list[str],
@@ -95,20 +96,26 @@ def initialize(
 
     memory = ""
     loaded_state = None
-    if task_id_to_resume:
-        try:
-            project_root_path, task_mem, loaded_state = load_memory(
-                task_id_to_resume,
-                max_tokens,
-                lambda x: default_enc.encoder(x),
-                lambda x: default_enc.decoder(x),
-            )
-            memory = "Following is the retrieved task:\n" + task_mem
-            if os.path.exists(project_root_path):
-                any_workspace_path = project_root_path
 
-        except Exception:
-            memory = f'Error: Unable to load task with ID "{task_id_to_resume}" '
+    if type == "first_call":
+        if task_id_to_resume:
+            try:
+                project_root_path, task_mem, loaded_state = load_memory(
+                    task_id_to_resume,
+                    max_tokens,
+                    lambda x: default_enc.encoder(x),
+                    lambda x: default_enc.decoder(x),
+                )
+                memory = "Following is the retrieved task:\n" + task_mem
+                if os.path.exists(project_root_path):
+                    any_workspace_path = project_root_path
+
+            except Exception:
+                memory = f'Error: Unable to load task with ID "{task_id_to_resume}" '
+    elif task_id_to_resume:
+        memory = (
+            "Warning: task can only be resumed in a new conversation. No task loaded."
+        )
 
     folder_to_start = None
     if any_workspace_path:
@@ -164,7 +171,9 @@ def initialize(
             context.console.print(traceback.format_exc())
             context.console.print("Error: couldn't load bash state")
             pass
+        mode_prompt = get_mode_prompt(context)
     else:
+        mode_changed = is_mode_change(mode, context.bash_state)
         state = modes_to_state(mode)
         context.bash_state.load_state(
             state[0],
@@ -174,6 +183,11 @@ def initialize(
             list(context.bash_state.whitelist_for_overwrite),
             str(folder_to_start) if folder_to_start else "",
         )
+        if type == "first_call" or mode_changed:
+            mode_prompt = get_mode_prompt(context)
+        else:
+            mode_prompt = ""
+
     del mode
 
     initial_files_context = ""
@@ -188,7 +202,7 @@ def initialize(
 
     uname_sysname = os.uname().sysname
     uname_machine = os.uname().machine
-    mode_prompt = get_mode_prompt(context)
+
     output = f"""
 {mode_prompt}
 
@@ -211,20 +225,34 @@ Initialized in directory (also cwd): {context.bash_state.cwd}
     return output, context
 
 
-def reset_wcgw(context: Context, reset_wcgw: ResetWcgw) -> str:
-    if reset_wcgw.change_mode:
-        # Convert to the type expected by modes_to_state
-        mode_config: ModesConfig
-        if reset_wcgw.change_mode == "code_writer":
-            if not reset_wcgw.code_writer_config:
-                return "Error: code_writer_config is required when changing to code_writer mode"
-            mode_config = reset_wcgw.code_writer_config
+def is_mode_change(mode_config: ModesConfig, bash_state: BashState) -> bool:
+    allowed = modes_to_state(mode_config)
+    bash_allowed = (
+        bash_state.bash_command_mode,
+        bash_state.file_edit_mode,
+        bash_state.write_if_empty_mode,
+        bash_state.mode,
+    )
+    return allowed != bash_allowed
+
+
+def reset_wcgw(
+    context: Context,
+    starting_directory: str,
+    mode_name: Optional[Modes],
+    change_mode: ModesConfig,
+) -> str:
+    global INITIALIZED
+    if mode_name:
+        # update modes if they're relative
+        if isinstance(change_mode, CodeWriterMode):
+            change_mode.update_relative_globs(starting_directory)
         else:
-            mode_config = reset_wcgw.change_mode
+            assert isinstance(change_mode, str)
 
         # Get new state configuration
         bash_command_mode, file_edit_mode, write_if_empty_mode, mode = modes_to_state(
-            mode_config
+            change_mode
         )
 
         # Reset shell with new mode
@@ -234,11 +262,12 @@ def reset_wcgw(context: Context, reset_wcgw: ResetWcgw) -> str:
             write_if_empty_mode,
             mode,
             list(context.bash_state.whitelist_for_overwrite),
-            reset_wcgw.starting_directory,
+            starting_directory,
         )
         mode_prompt = get_mode_prompt(context)
+        INITIALIZED = True
         return (
-            f"Reset successful with mode change to {reset_wcgw.change_mode}.\n"
+            f"Reset successful with mode change to {mode_name}.\n"
             + mode_prompt
             + "\n"
             + get_status(context.bash_state)
@@ -257,9 +286,8 @@ def reset_wcgw(context: Context, reset_wcgw: ResetWcgw) -> str:
             write_if_empty_mode,
             mode,
             list(context.bash_state.whitelist_for_overwrite),
-            reset_wcgw.starting_directory,
+            starting_directory,
         )
-    global INITIALIZED
     INITIALIZED = True
     return "Reset successful" + get_status(context.bash_state)
 
@@ -513,7 +541,6 @@ Syntax errors:
 
 TOOLS = (
     BashCommand
-    | ResetWcgw
     | WriteIfEmpty
     | FileEdit
     | ReadImage
@@ -531,8 +558,6 @@ def which_tool(args: str) -> TOOLS:
 def which_tool_name(name: str) -> Type[TOOLS]:
     if name == "BashCommand":
         return BashCommand
-    elif name == "ResetWcgw":
-        return ResetWcgw
     elif name == "WriteIfEmpty":
         return WriteIfEmpty
     elif name == "FileEdit":
@@ -549,6 +574,23 @@ def which_tool_name(name: str) -> Type[TOOLS]:
         raise ValueError(f"Unknown tool name: {name}")
 
 
+def parse_tool_by_name(name: str, arguments: dict[str, Any]) -> TOOLS:
+    tool_type = which_tool_name(name)
+    try:
+        return tool_type(**arguments)
+    except ValidationError:
+
+        def try_json(x: str) -> Any:
+            if not isinstance(x, str):
+                return x
+            try:
+                return json.loads(x)
+            except json.JSONDecodeError:
+                return x
+
+        return tool_type(**{k: try_json(v) for k, v in arguments.items()})
+
+
 TOOL_CALLS: list[TOOLS] = []
 
 
@@ -595,21 +637,37 @@ def get_tool_output(
     elif isinstance(arg, ReadFiles):
         context.console.print("Calling read file tool")
         output = read_files(arg.file_paths, max_tokens, context), 0.0
-    elif isinstance(arg, ResetWcgw):
-        context.console.print("Calling reset wcgw tool")
-        output = reset_wcgw(context, arg), 0.0
-
     elif isinstance(arg, Initialize):
         context.console.print("Calling initial info tool")
-        output_, context = initialize(
-            context,
-            arg.any_workspace_path,
-            arg.initial_files_to_read,
-            arg.task_id_to_resume,
-            max_tokens,
-            arg.mode,
-        )
-        output = output_, 0.0
+        if arg.type == "user_asked_mode_change" or arg.type == "reset_shell":
+            workspace_path = (
+                arg.any_workspace_path
+                if os.path.isdir(arg.any_workspace_path)
+                else os.path.dirname(arg.any_workspace_path)
+            )
+            workspace_path = workspace_path if os.path.exists(workspace_path) else ""
+            output = (
+                reset_wcgw(
+                    context,
+                    workspace_path,
+                    arg.mode_name
+                    if is_mode_change(arg.mode, context.bash_state)
+                    else None,
+                    arg.mode,
+                ),
+                0.0,
+            )
+        else:
+            output_, context = initialize(
+                arg.type,
+                context,
+                arg.any_workspace_path,
+                arg.initial_files_to_read,
+                arg.task_id_to_resume,
+                max_tokens,
+                arg.mode,
+            )
+            output = output_, 0.0
 
     elif isinstance(arg, ContextSave):
         context.console.print("Calling task memory tool")

wcgw/relay/serve.py

@@ -19,7 +19,6 @@ from ..types_ import (
     FileEdit,
     Initialize,
     ReadFiles,
-    ResetWcgw,
     WriteIfEmpty,
 )
 
@@ -28,7 +27,6 @@ class Mdata(BaseModel):
     data: (
         BashCommand
         | WriteIfEmpty
-        | ResetWcgw
         | FileEdit
         | ReadFiles
         | Initialize
@@ -160,35 +158,6 @@ async def file_edit_find_replace(
     raise fastapi.HTTPException(status_code=500, detail="Timeout error")
 
 
-class ResetWcgwWithUUID(ResetWcgw):
-    user_id: UUID
-
-
-@app.post("/v1/reset_wcgw")
-async def reset_wcgw(reset_wcgw: ResetWcgwWithUUID) -> str:
-    user_id = reset_wcgw.user_id
-    if user_id not in clients:
-        return "Failure: id not found, ask the user to check it."
-
-    results: Optional[str] = None
-
-    def put_results(result: str) -> None:
-        nonlocal results
-        results = result
-
-    gpts[user_id] = put_results
-
-    await clients[user_id](Mdata(data=reset_wcgw, user_id=user_id))
-
-    start_time = time.time()
-    while time.time() - start_time < 30:
-        if results is not None:
-            return results
-        await asyncio.sleep(0.1)
-
-    raise fastapi.HTTPException(status_code=500, detail="Timeout error")
-
-
 class CommandWithUUID(BashCommand):
     user_id: UUID
 

wcgw/types_.py

@@ -1,5 +1,4 @@
 import os
-from enum import Enum
 from typing import Any, Literal, Optional, Protocol, Sequence, Union
 
 from pydantic import BaseModel as PydanticBaseModel
@@ -13,16 +12,23 @@ class NoExtraArgs(PydanticBaseModel):
 BaseModel = NoExtraArgs
 
 
-class Modes(str, Enum):
-    wcgw = "wcgw"
-    architect = "architect"
-    code_writer = "code_writer"
+Modes = Literal["wcgw", "architect", "code_writer"]
 
 
 class CodeWriterMode(BaseModel):
     allowed_globs: Literal["all"] | list[str]
     allowed_commands: Literal["all"] | list[str]
 
+    def __post_init__(self) -> None:
+        # Patch frequently wrong output trading off accuracy
+        # in rare case there's a file named 'all' or a command named 'all'
+        if len(self.allowed_commands) == 1:
+            if self.allowed_commands[0] == "all":
+                self.allowed_commands = "all"
+        if len(self.allowed_globs) == 1:
+            if self.allowed_globs[0] == "all":
+                self.allowed_globs = "all"
+
     def update_relative_globs(self, workspace_root: str) -> None:
         """Update globs if they're relative paths"""
         if self.allowed_globs != "all":
@@ -36,6 +42,12 @@ ModesConfig = Union[Literal["wcgw", "architect"], CodeWriterMode]
 
 
 class Initialize(BaseModel):
+    type: Literal[
+        "first_call",
+        "user_asked_mode_change",
+        "reset_shell",
+        "user_asked_change_workspace",
+    ]
     any_workspace_path: str
     initial_files_to_read: list[str]
     task_id_to_resume: str
@@ -44,9 +56,9 @@ class Initialize(BaseModel):
 
     def model_post_init(self, __context: Any) -> None:
         if self.mode_name == "code_writer":
-            assert self.code_writer_config is not None, (
-                "code_writer_config can't be null when the mode is code_writer"
-            )
+            assert (
+                self.code_writer_config is not None
+            ), "code_writer_config can't be null when the mode is code_writer"
         return super().model_post_init(__context)
 
     @property
@@ -55,9 +67,9 @@ class Initialize(BaseModel):
             return "wcgw"
         if self.mode_name == "architect":
             return "architect"
-        assert self.code_writer_config is not None, (
-            "code_writer_config can't be null when the mode is code_writer"
-        )
+        assert (
+            self.code_writer_config is not None
+        ), "code_writer_config can't be null when the mode is code_writer"
         return self.code_writer_config
 
 
@@ -74,7 +86,7 @@ class SendText(BaseModel):
 
 
 Specials = Literal[
-    "Enter", "Key-up", "Key-down", "Key-left", "Key-right", "Ctrl-c", "Ctrl-d", "Ctrl-z"
+    "Enter", "Key-up", "Key-down", "Key-left", "Key-right", "Ctrl-c", "Ctrl-d"
 ]
 
 
@@ -104,13 +116,6 @@ class ReadFiles(BaseModel):
     file_paths: list[str]
 
 
-class ResetWcgw(BaseModel):
-    should_reset: Literal[True]
-    change_mode: Optional[Literal["wcgw", "architect", "code_writer"]]
-    code_writer_config: Optional[CodeWriterMode] = None
-    starting_directory: str
-
-
 class FileEdit(BaseModel):
     file_path: str
     file_edit_using_search_replace_blocks: str
@@ -133,7 +138,6 @@ class Mdata(PydanticBaseModel):
     data: (
         BashCommand
         | WriteIfEmpty
-        | ResetWcgw
         | FileEdit
         | str
         | ReadFiles

{wcgw-3.0.1rc2.dist-info → wcgw-3.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wcgw
-Version: 3.0.1rc2
+Version: 3.0.2
 Summary: Shell and coding agent on claude and chatgpt
 Project-URL: Homepage, https://github.com/rusiaaman/wcgw
 Author-email: Aman Rusia <gapypi@arcfu.com>
@@ -43,6 +43,8 @@ Empowering chat applications to code, build and run on your local machine.
 
 ## Updates
 
+- [16 Feb 2025] You can now attach to the working terminal that the AI uses. See the "attach-to-terminal" section below.
+
 - [15 Jan 2025] Modes introduced: architect, code-writer, and all powerful wcgw mode.
 
 - [8 Jan 2025] Context saving tool for saving relevant file paths along with a description in a single file. Can be used as a task checkpoint or for knowledge transfer.
@@ -51,9 +53,6 @@ Empowering chat applications to code, build and run on your local machine.
 
 - [9 Dec 2024] [Vscode extension to paste context on Claude app](https://marketplace.visualstudio.com/items?itemName=AmanRusia.wcgw)
 
-- [01 Dec 2024] Removed author hosted relay server for chatgpt.
-
-- [26 Nov 2024] Introduced claude desktop support through mcp
 
 ## 🚀 Highlights
 
@@ -100,7 +99,7 @@ First install `uv` using homebrew `brew install uv`
 
 (**Important:** use homebrew to install uv. Otherwise make sure `uv` is present in a global location like /usr/bin/)
 
-Then update `claude_desktop_config.json` (~/Library/Application Support/Claude/claude_desktop_config.json)
+Then create or update `claude_desktop_config.json` (~/Library/Application Support/Claude/claude_desktop_config.json) with following json.
 
 ```json
 {
@@ -127,6 +126,8 @@ _If there's an error in setting up_
 
 - If there's an error like "uv ENOENT", make sure `uv` is installed. Then run 'which uv' in the terminal, and use its output in place of "uv" in the configuration.
 - If there's still an issue, check that `uv tool run --from wcgw@latest --python 3.12 wcgw_mcp` runs in your terminal. It should have no output and shouldn't exit.
+- Try removing ~/.cache/uv folder
+- Try using `uv` version `0.6.0` for which this tool was tested.
 - Debug the mcp server using `npx @modelcontextprotocol/inspector@0.1.7 uv tool run --from wcgw@latest --python 3.12 wcgw_mcp`
 
 ### Alternative configuration using smithery (npx required)
@@ -139,6 +140,9 @@ Then to configure wcgw for Claude Desktop automatically via [Smithery](https://s
 npx -y @smithery/cli install wcgw --client claude
 ```
 
+_If there's an error in setting up_
+- Try removing ~/.cache/uv folder
+
 ### Usage
 
 Wait for a few seconds. You should be able to see this icon if everything goes right.
@@ -168,6 +172,21 @@ There are three built-in modes. You may ask Claude to run in one of the modes, l
 
 Note: in code-writer mode either all commands are allowed or none are allowed for now. If you give a list of allowed commands, Claude is instructed to run only those commands, but no actual check happens. (WIP)
 
+#### Attach to the working terminal to investigate
+If you've `screen` command installed, wcgw runs on a screen instance automatically. If you've started wcgw mcp server, you can list the screen sessions:
+
+`screen -ls`
+
+And note down the wcgw screen name which will be something like `93358.wcgw.235521` where the last number is in the hour-minute-second format.
+
+You can then attach to the session using `screen -x 93358.wcgw.235521`
+
+You may interrupt any running command safely.
+
+You can interact with the terminal but beware that the AI might be running in parallel and it may conflict with what you're doing. It's recommended to keep your interactions to minimum. 
+
+You shouldn't exit the session using `exit `or Ctrl-d, instead you should use `ctrl+a+d` to safely detach without destroying the screen session.
+
 ### [Optional] Vs code extension
 
 https://marketplace.visualstudio.com/items?itemName=AmanRusia.wcgw
@@ -216,7 +235,6 @@ The server provides the following MCP tools:
   - Parameters: `any_workspace_path` (string), `initial_files_to_read` (string[]), `mode_name` ("wcgw"|"architect"|"code_writer"), `task_id_to_resume` (string)
 - `BashCommand`: Execute shell commands with timeout control
   - Parameters: `command` (string), `wait_for_seconds` (int, optional)
-- `BashInteraction`: Send keyboard input to running programs
   - Parameters: `send_text` (string) or `send_specials` (["Enter"|"Key-up"|...]) or `send_ascii` (int[]), `wait_for_seconds` (int, optional)
 
 **File Operations:**
@@ -234,7 +252,5 @@ The server provides the following MCP tools:
 
 - `ContextSave`: Save project context and files for Knowledge Transfer or saving task checkpoints to be resumed later
   - Parameters: `id` (string), `project_root_path` (string), `description` (string), `relevant_file_globs` (string[])
-- `ResetShell`: Emergency reset for shell environment
-  - Parameters: `should_reset` (boolean)
 
 All tools support absolute paths and include built-in protections against common errors. See the [MCP specification](https://modelcontextprotocol.io/) for detailed protocol information.

{wcgw-3.0.1rc2.dist-info → wcgw-3.0.2.dist-info}/RECORD

@@ -1,33 +1,33 @@
 wcgw/__init__.py,sha256=qUofQOAXCGcWr2u_B8U-MIMhhYaBUpUwNDcscvRmYfo,90
 wcgw/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wcgw/types_.py,sha256=_r4H9Kebu22nSxD8wvtGhAOGlJheshLBggI2IE9F7tY,3355
+wcgw/types_.py,sha256=KFyfLFrctU9jr3zoQR3nlAMlP17hu91bM7ZeUTdTZ74,3624
 wcgw/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wcgw/client/common.py,sha256=OCH7Tx64jojz3M3iONUrGMadE07W21DiZs5sOxWX1Qc,1456
 wcgw/client/diff-instructions.txt,sha256=tmJ9Fu9XdO_72lYXQQNY9RZyx91bjxrXJf9d_KBz57k,1611
 wcgw/client/memory.py,sha256=8LdYsOhvCOoC1kfvDr85kNy07WnhPMvE6B2FRM2w85Y,2902
-wcgw/client/modes.py,sha256=dBkiMNQevTFNkhplrDsDuSIyeU-wLmAIfAa9Dqowvk8,10387
-wcgw/client/tool_prompts.py,sha256=j82aYnlr1pcinsOYitSrlyYz4-9K3KcqnAfGqot21NQ,4158
-wcgw/client/tools.py,sha256=eXAGPKm7ViG2OgF1m_yLTPehtmkhQFWDoiLEkV7fOMQ,22660
-wcgw/client/bash_state/bash_state.py,sha256=dNCx2KRQSQHYihTsfIqtQNsd8j27CoSMH4I026Cz8pU,29308
+wcgw/client/modes.py,sha256=FjIQOjT5oI7dk9VG0oRemN1A6EHBvHnuSQGKuRbguJI,10352
+wcgw/client/tool_prompts.py,sha256=RzLO3XGMg2VJfURG1BiQzZ6IdDWXfH2syqM1N3w0770,3980
+wcgw/client/tools.py,sha256=UtVH_Q7E7A6ertdY9yPe5ukwSO2zg1Ojlp3z6MqmURI,24402
+wcgw/client/bash_state/bash_state.py,sha256=DND9vNIfFee-Djif3YZhIsnaXamI3TzXE-AhISnICZY,26476
 wcgw/client/encoder/__init__.py,sha256=Y-8f43I6gMssUCWpX5rLYiAFv3D-JPRs4uNEejPlke8,1514
 wcgw/client/file_ops/diff_edit.py,sha256=sIwXSSkWYff_Dp3oHfefqtSuFqLrxbhKvzkCoLuLqDE,18679
 wcgw/client/file_ops/search_replace.py,sha256=Napa7IWaYPGMNdttunKyRDkb90elZE7r23B_o_htRxo,5585
 wcgw/client/mcp_server/Readme.md,sha256=2Z88jj1mf9daYGW1CWaldcJ0moy8owDumhR2glBY3A8,109
 wcgw/client/mcp_server/__init__.py,sha256=mm7xhBIPwJpRT3u-Qsj4cKVMpVyucJoKRlbMP_gRRB0,343
-wcgw/client/mcp_server/server.py,sha256=aF8SLaCsPisQsQ0fOUOpTfP2S4EGEugaLupjCyhHA8o,5371
+wcgw/client/mcp_server/server.py,sha256=ayK6qbzCveoQW7RO80m10cAIS3m-hvxzd15XhjiyxmE,5055
 wcgw/client/repo_ops/display_tree.py,sha256=E5q9mrGBb57NyvudSmRIG-fj4FUqupbzjmARpX8X0XY,4166
 wcgw/client/repo_ops/path_prob.py,sha256=SWf0CDn37rtlsYRQ51ufSxay-heaQoVIhr1alB9tZ4M,2144
 wcgw/client/repo_ops/paths_model.vocab,sha256=M1pXycYDQehMXtpp-qAgU7rtzeBbCOiJo4qcYFY0kqk,315087
 wcgw/client/repo_ops/paths_tokens.model,sha256=jiwwE4ae8ADKuTZISutXuM5Wfyc_FBmN5rxTjoNnCos,1569052
 wcgw/client/repo_ops/repo_context.py,sha256=5NqRxBY0K-SBFXJ0Ybt7llzYOBD8pRkTpruMMJHWxv4,4336
 wcgw/relay/client.py,sha256=BUeEKUsWts8RpYxXwXcyFyjBJhOCS-CxThAlL_-VCOI,3618
-wcgw/relay/serve.py,sha256=Ofq6PjW3zVVA2-9MVviGRiUESTD3sXb-482Q4RV13q8,8664
+wcgw/relay/serve.py,sha256=Vl7Nb68-F910LwHrTElfCNwajF37CfgObUIAdwhrRsI,7886
 wcgw/relay/static/privacy.txt,sha256=s9qBdbx2SexCpC_z33sg16TptmAwDEehMCLz4L50JLc,529
 wcgw_cli/__init__.py,sha256=TNxXsTPgb52OhakIda9wTRh91cqoBqgQRx5TxjzQQFU,21
 wcgw_cli/__main__.py,sha256=wcCrL4PjG51r5wVKqJhcoJPTLfHW0wNbD31DrUN0MWI,28
-wcgw_cli/anthropic_client.py,sha256=hpeqfLxYgfJpLgYmCRvE9r1Iu0ubGiBqmgEFzwKIvCM,18966
+wcgw_cli/anthropic_client.py,sha256=gQc1opw-N5ecqcORbvvHGBW1Ac-Soe7c7APJD25HIfo,19887
 wcgw_cli/cli.py,sha256=-7FBe_lahKyUOhf65iurTA1M1gXXXAiT0OVKQVcZKKo,948
-wcgw_cli/openai_client.py,sha256=oMFAaOkvXQtOY7choylVRJfaF2SnWvRc02ygQhlhVqY,15995
+wcgw_cli/openai_client.py,sha256=o4vfhcfGKqoWYWnn5YxNw4muKyDnFEiPmWpZpufDGMA,16021
 wcgw_cli/openai_utils.py,sha256=xGOb3W5ALrIozV7oszfGYztpj0FnXdD7jAxm5lEIVKY,2439
 mcp_wcgw/__init__.py,sha256=fKCgOdN7cn7gR3YGFaGyV5Goe8A2sEyllLcsRkN0i-g,2601
 mcp_wcgw/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -51,8 +51,8 @@ mcp_wcgw/shared/memory.py,sha256=dBsOghxHz8-tycdSVo9kSujbsC8xb_tYsGmuJobuZnw,281
 mcp_wcgw/shared/progress.py,sha256=ymxOsb8XO5Mhlop7fRfdbmvPodANj7oq6O4dD0iUcnw,1048
 mcp_wcgw/shared/session.py,sha256=e44a0LQOW8gwdLs9_DE9oDsxqW2U8mXG3d5KT95bn5o,10393
 mcp_wcgw/shared/version.py,sha256=d2LZii-mgsPIxpshjkXnOTUmk98i0DT4ff8VpA_kAvE,111
-wcgw-3.0.1rc2.dist-info/METADATA,sha256=J7O32iQuFetYvpv1pNkdHMsHbeV7o-3HYd6QNUzMszk,13005
-wcgw-3.0.1rc2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-wcgw-3.0.1rc2.dist-info/entry_points.txt,sha256=vd3tj1_Kzfp55LscJ8-6WFMM5hm9cWTfNGFCrWBnH3Q,124
-wcgw-3.0.1rc2.dist-info/licenses/LICENSE,sha256=BvY8xqjOfc3X2qZpGpX3MZEmF-4Dp0LqgKBbT6L_8oI,11142
-wcgw-3.0.1rc2.dist-info/RECORD,,
+wcgw-3.0.2.dist-info/METADATA,sha256=VNXS8-pCPvOPt_Xdgq4UIxp4aeZ69V-7DbIe0WGT7Eo,13858
+wcgw-3.0.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+wcgw-3.0.2.dist-info/entry_points.txt,sha256=vd3tj1_Kzfp55LscJ8-6WFMM5hm9cWTfNGFCrWBnH3Q,124
+wcgw-3.0.2.dist-info/licenses/LICENSE,sha256=BvY8xqjOfc3X2qZpGpX3MZEmF-4Dp0LqgKBbT6L_8oI,11142
+wcgw-3.0.2.dist-info/RECORD,,

wcgw_cli/anthropic_client.py

@@ -22,7 +22,7 @@ from anthropic.types import (
     ToolUseBlockParam,
 )
 from dotenv import load_dotenv
-from pydantic import BaseModel
+from pydantic import BaseModel, ValidationError
 from typer import Typer
 
 from wcgw.client.bash_state.bash_state import BashState
@@ -35,7 +35,7 @@ from wcgw.client.tools import (
     default_enc,
     get_tool_output,
     initialize,
-    which_tool_name,
+    parse_tool_by_name,
 )
 
 
@@ -218,6 +218,7 @@ def loop(
     ) as bash_state:
         context = Context(bash_state, system_console)
         system, context = initialize(
+            "first_call",
             context,
             os.getcwd(),
             [],
@@ -379,14 +380,6 @@ def loop(
                                 tool_input = str(tc["input"])
                                 tool_id = str(tc["id"])
 
-                                tool_parsed = which_tool_name(
-                                    tool_name
-                                ).model_validate_json(tool_input)
-
-                                system_console.print(
-                                    f"\n---------------------------------------\n# Assistant invoked tool: {tool_parsed}"
-                                )
-
                                 _histories.append(
                                     {
                                         "role": "assistant",
@@ -394,12 +387,35 @@ def loop(
                                             ToolUseBlockParam(
                                                 id=tool_id,
                                                 name=tool_name,
-                                                input=tool_parsed.model_dump(),
+                                                input=json.loads(tool_input),
                                                 type="tool_use",
                                             )
                                         ],
                                     }
                                 )
+                                try:
+                                    tool_parsed = parse_tool_by_name(
+                                        tool_name, json.loads(tool_input)
+                                    )
+                                except ValidationError:
+                                    error_msg = f"Error parsing tool {tool_name}\n{traceback.format_exc()}"
+                                    system_console.log(
+                                        f"Error parsing tool {tool_name}"
+                                    )
+                                    tool_results.append(
+                                        ToolResultBlockParam(
+                                            type="tool_result",
+                                            tool_use_id=str(tc["id"]),
+                                            content=error_msg,
+                                            is_error=True,
+                                        )
+                                    )
+                                    continue
+
+                                system_console.print(
+                                    f"\n---------------------------------------\n# Assistant invoked tool: {tool_parsed}"
+                                )
+
                                 try:
                                     output_or_dones, _ = get_tool_output(
                                         context,

wcgw_cli/openai_client.py

@@ -182,6 +182,7 @@ def loop(
     ) as bash_state:
         context = Context(bash_state, system_console)
         system, context = initialize(
+            "first_call",
             context,
             os.getcwd(),
             [],