wcgw 3.0.1rc3__py3-none-any.whl → 3.0.3__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,
@@ -107,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 = []
 
@@ -130,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(
@@ -217,33 +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 * 2
-            ):  # Twice in worst case if screen fails
-                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__(
@@ -266,67 +241,39 @@ 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._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()
-                self.run_bg_expect_thread()
-            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()
-        output = 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:
+    def send(self, s: str | bytes) -> int:
         self.close_bg_expect_thread()
-        output = shell.send(s)
+        output = self._shell.send(s)
         return output
 
-    @requires_shell
-    def sendline(self, shell: "pexpect.spawn[str]", s: str | bytes) -> int:
+    def sendline(self, s: str | bytes) -> int:
         self.close_bg_expect_thread()
-        output = shell.sendline(s)
+        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:
+    def sendintr(self) -> None:
         self.close_bg_expect_thread()
-        shell.sendintr()
+        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
 
     def run_bg_expect_thread(self) -> None:
         """
@@ -337,16 +284,11 @@ class BashState:
             while True:
                 if self._bg_expect_thread_stop_event.is_set():
                     break
-                if self._shell is None:
-                    time.sleep(0.1)
-                    continue
                 output = self._shell.expect([pexpect.EOF, pexpect.TIMEOUT], timeout=0.1)
                 if output == 0:
                     break
 
-        if self._bg_expect_thread and self._bg_expect_thread.is_alive():
-            if not self._bg_expect_thread_stop_event.is_set():
-                return
+        if self._bg_expect_thread:
             self.close_bg_expect_thread()
 
         self._bg_expect_thread = threading.Thread(
@@ -363,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
@@ -393,31 +330,24 @@ 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"
+    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(PROMPT_STATEMENT)
-        self._shell.expect(PROMPT_CONST, timeout=quick_timeout)
+        self.sendline(PROMPT_STATEMENT)
+        self.expect(PROMPT_CONST, timeout=quick_timeout)
         # Reset echo also if it was enabled
         command = "jobs | wc -l"
-        self._shell.sendline(command)
+        self.sendline(command)
         before = ""
         counts = 0
         while not _is_int(before):  # Consume all previous output
             try:
-                self._shell.expect(PROMPT_CONST, 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)
@@ -435,7 +365,6 @@ class BashState:
 
     def _init_shell(self) -> None:
         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:
@@ -461,10 +390,12 @@ class BashState:
 
         self._pending_output = ""
         try:
-            self._ensure_env_and_bg_jobs()
+            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()
@@ -480,13 +411,6 @@ 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
@@ -495,23 +419,22 @@ class BashState:
     def prompt(self) -> str:
         return PROMPT_CONST
 
-    @requires_shell
-    def update_cwd(self, shell: "pexpect.spawn[str]") -> str:
-        shell.sendline("pwd")
-        shell.expect(PROMPT_CONST, 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)
         current_dir = "\n".join(before_lines).strip()
+        if current_dir.startswith("pwd"):
+            current_dir = current_dir[3:].strip()
         self._cwd = current_dir
         return current_dir
 
     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"""
@@ -531,7 +454,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"],
         )
 
@@ -595,7 +518,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
 """
 
 

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 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.
+- 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 (~ allowed)
 - 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(
@@ -62,7 +61,7 @@ TOOL_PROMPTS = [
         name="ReadFiles",
         description="""
 - Read full file content of one or more files.
-- Provide absolute file paths only
+- Provide absolute paths only (~ allowed)
 """,
     ),
     Prompts(
@@ -70,7 +69,7 @@ TOOL_PROMPTS = [
         name="WriteIfEmpty",
         description="""
 - Write content to an empty or non-existent file. Provide file path and content. Use this instead of BashCommand for writing new files.
-- Provide absolute file path only.
+- Provide absolute path only.
 - For editing existing files, use FileEdit instead of this tool.
 """,
     ),
@@ -79,16 +78,11 @@ 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",
         description="""
-- Use absolute file path only.
+- Use absolute path only.
 - Use SEARCH/REPLACE blocks to edit the file.
 - If the edit fails due to block not matching, please retry with correct block till it matches. Re-read the file to ensure you've all the lines correct.
 """

wcgw/client/tools.py

@@ -4,6 +4,7 @@ import glob
 import json
 import mimetypes
 import os
+import subprocess
 import traceback
 from dataclasses import dataclass
 from os.path import expanduser
@@ -38,7 +39,6 @@ from ..types_ import (
     ModesConfig,
     ReadFiles,
     ReadImage,
-    ResetWcgw,
     WriteIfEmpty,
 )
 from .bash_state.bash_state import (
@@ -68,13 +68,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
@@ -83,6 +83,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],
@@ -96,20 +97,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:
@@ -165,7 +172,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],
@@ -175,6 +184,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 = ""
@@ -189,7 +203,7 @@ def initialize(
 
     uname_sysname = os.uname().sysname
     uname_machine = os.uname().machine
-    mode_prompt = get_mode_prompt(context)
+
     output = f"""
 {mode_prompt}
 
@@ -212,20 +226,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
@@ -235,11 +263,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)
@@ -258,9 +287,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)
 
@@ -281,6 +309,30 @@ def expand_user(path: str) -> str:
     return expanduser(path)
 
 
+def try_open_file(file_path: str) -> None:
+    """Try to open a file using the system's default application."""
+    # Determine the appropriate open command based on OS
+    open_cmd = None
+    if os.uname().sysname == "Darwin":  # macOS
+        open_cmd = "open"
+    elif os.uname().sysname == "Linux":
+        # Try common Linux open commands
+        for cmd in ["xdg-open", "gnome-open", "kde-open"]:
+            try:
+                subprocess.run(["which", cmd], timeout=1, capture_output=True)
+                open_cmd = cmd
+                break
+            except:
+                continue
+    
+    # Try to open the file if a command is available
+    if open_cmd:
+        try:
+            subprocess.run([open_cmd, file_path], timeout=2)
+        except:
+            pass
+
+
 MEDIA_TYPES = Literal["image/jpeg", "image/png", "image/gif", "image/webp"]
 
 
@@ -514,7 +566,6 @@ Syntax errors:
 
 TOOLS = (
     BashCommand
-    | ResetWcgw
     | WriteIfEmpty
     | FileEdit
     | ReadImage
@@ -532,8 +583,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":
@@ -613,26 +662,43 @@ 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")
         relevant_files = []
         warnings = ""
+        arg.project_root_path = os.path.expanduser(arg.project_root_path) 
         for fglob in arg.relevant_file_globs:
             fglob = expand_user(fglob)
             if not os.path.isabs(fglob) and arg.project_root_path:
@@ -642,11 +708,15 @@ def get_tool_output(
             if not globs:
                 warnings += f"Warning: No files found for the glob: {fglob}\n"
         relevant_files_data = read_files(relevant_files[:10_000], None, context)
-        output_ = save_memory(arg, relevant_files_data, context.bash_state.serialize())
+        save_path = save_memory(arg, relevant_files_data, context.bash_state.serialize())
         if not relevant_files and arg.relevant_file_globs:
-            output_ = f'Error: No files found for the given globs. Context file successfully saved at "{output_}", but please fix the error.'
+            output_ = f'Error: No files found for the given globs. Context file successfully saved at "{save_path}", but please fix the error.'
         elif warnings:
-            output_ = warnings + "\nContext file successfully saved at " + output_
+            output_ = warnings + "\nContext file successfully saved at " + save_path
+        else:
+            output_ = save_path
+        # Try to open the saved file
+        try_open_file(save_path)
         output = output_, 0.0
     else:
         raise ValueError(f"Unknown tool: {arg}")

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.1rc3.dist-info → wcgw-3.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wcgw
-Version: 3.0.1rc3
+Version: 3.0.3
 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
 
@@ -78,6 +77,7 @@ Empowering chat applications to code, build and run on your local machine.
   - Ask it to run in 'code-writer' mode for code editing and project building. You can provide specific paths with wild card support to prevent other files getting edited.
   - By default it runs in 'wcgw' mode that has no restrictions and full authorisation.
   - More details in [Modes section](#modes)
+- ⚡ **Runs in multiplex terminal** Run `screen -x` to attach to the terminal that the AI runs commands on. See history or interrupt process or interact with the same terminal that AI uses.
 
 ## Top use cases examples
 
@@ -100,7 +100,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 +127,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 +141,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 +173,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 +236,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 +253,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.1rc3.dist-info → wcgw-3.0.3.dist-info}/RECORD

@@ -1,14 +1,14 @@
 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=caj10NHeK5tZ5Gi0L_oXzPcKBycgXeNaLEbXAzYTpqo,23170
-wcgw/client/bash_state/bash_state.py,sha256=2cxzYN6x-vEJ4oasrCgoRyVQKpARKONcaNDLfLPDTG8,29476
+wcgw/client/modes.py,sha256=FjIQOjT5oI7dk9VG0oRemN1A6EHBvHnuSQGKuRbguJI,10352
+wcgw/client/tool_prompts.py,sha256=H36Sr3yH2YuHZTc08Y6rTUWlYWjKMFtIGP6vbAVNwZo,3988
+wcgw/client/tools.py,sha256=hwKF6Wydiw-xqVDBJ2wZJ5BhZhtEQikM0G_YpolZ4zg,25398
+wcgw/client/bash_state/bash_state.py,sha256=RoNR5qyskYPeLtaBkatHNPWhAAJI2AaPJ7Z3gAKvONU,26568
 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
@@ -21,13 +21,13 @@ wcgw/client/repo_ops/paths_model.vocab,sha256=M1pXycYDQehMXtpp-qAgU7rtzeBbCOiJo4
 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=2QLFBLbMeQuixF7Pz9j_hINHTG1CF9IYQZeri7zFuF0,18964
+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.1rc3.dist-info/METADATA,sha256=ymiydLYH56IAV_8FKq98BrGf-tt7Vwumtc8nUBvzs50,13005
-wcgw-3.0.1rc3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-wcgw-3.0.1rc3.dist-info/entry_points.txt,sha256=vd3tj1_Kzfp55LscJ8-6WFMM5hm9cWTfNGFCrWBnH3Q,124
-wcgw-3.0.1rc3.dist-info/licenses/LICENSE,sha256=BvY8xqjOfc3X2qZpGpX3MZEmF-4Dp0LqgKBbT6L_8oI,11142
-wcgw-3.0.1rc3.dist-info/RECORD,,
+wcgw-3.0.3.dist-info/METADATA,sha256=oG6kjnyYUCJzKiINctH5M0mlDo4dEwS88WN15WdafUg,14049
+wcgw-3.0.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+wcgw-3.0.3.dist-info/entry_points.txt,sha256=vd3tj1_Kzfp55LscJ8-6WFMM5hm9cWTfNGFCrWBnH3Q,124
+wcgw-3.0.3.dist-info/licenses/LICENSE,sha256=BvY8xqjOfc3X2qZpGpX3MZEmF-4Dp0LqgKBbT6L_8oI,11142
+wcgw-3.0.3.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
@@ -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 = parse_tool_by_name(
-                                    tool_name, json.loads(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(),
             [],