feat: upgrade CLI with local tools, slash commands, and interrupt support

Replace sandbox tools with local bash/read/write/edit implementations that
execute directly on the user's machine. Add slash commands (/help, /undo,
/compact, /model, /yolo, /status), Ctrl+C interrupt support, HF token
loading, and missing event handlers. Remove lmnr dependency. Fix dict vs
ToolCall bug in context manager sanitization.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

agent/context_manager/manager.py

@@ -141,6 +141,56 @@ class ContextManager:
         self._patch_dangling_tool_calls()
         return self.items
 
+    @staticmethod
+    def _tc_id(tc) -> str:
+        if isinstance(tc, dict):
+            return tc.get("id", "")
+        return tc.id
+
+    @staticmethod
+    def _tc_func_name(tc) -> str:
+        if isinstance(tc, dict):
+            fn = tc.get("function", {})
+            return fn.get("name", "") if isinstance(fn, dict) else getattr(fn, "name", "")
+        return tc.function.name
+
+    @staticmethod
+    def _tc_func_args(tc) -> str:
+        if isinstance(tc, dict):
+            fn = tc.get("function", {})
+            return fn.get("arguments", "{}") if isinstance(fn, dict) else getattr(fn, "arguments", "{}")
+        return tc.function.arguments
+
+    @staticmethod
+    def _tc_set_func_args(tc, value: str) -> None:
+        if isinstance(tc, dict):
+            fn = tc.get("function")
+            if isinstance(fn, dict):
+                fn["arguments"] = value
+            else:
+                fn.arguments = value
+        else:
+            tc.function.arguments = value
+
+    def _sanitize_tool_calls(self) -> None:
+        """Fix malformed tool_call arguments across all assistant messages."""
+        import json
+
+        for msg in self.items:
+            if getattr(msg, "role", None) != "assistant":
+                continue
+            tool_calls = getattr(msg, "tool_calls", None)
+            if not tool_calls:
+                continue
+            for tc in tool_calls:
+                try:
+                    json.loads(self._tc_func_args(tc))
+                except (json.JSONDecodeError, TypeError, ValueError):
+                    logger.warning(
+                        "Sanitizing malformed arguments for tool_call %s (%s)",
+                        self._tc_id(tc), self._tc_func_name(tc),
+                    )
+                    self._tc_set_func_args(tc, "{}")
     def _patch_dangling_tool_calls(self) -> None:
         """Add stub tool results for any tool_calls that lack a matching result.
 
@@ -171,13 +221,14 @@ class ContextManager:
             if getattr(m, "role", None) == "tool"
         }
         for tc in assistant_msg.tool_calls:
-            if tc.id not in answered_ids:
+            tc_id = self._tc_id(tc)
+            if tc_id not in answered_ids:
                 self.items.append(
                     Message(
                         role="tool",
                         content="Tool was not executed (interrupted or error).",
-                        tool_call_id=tc.id,
-                        name=tc.function.name,
+                        tool_call_id=tc_id,
+                        name=self._tc_func_name(tc),
                     )
                 )
 

agent/core/agent_loop.py

@@ -795,6 +795,8 @@ async def submission_loop(
     event_queue: asyncio.Queue,
     config: Config | None = None,
     tool_router: ToolRouter | None = None,
+    session_holder: list | None = None,
+    hf_token: str | None = None,
 ) -> None:
     """
     Main agent loop - processes submissions and dispatches to handlers.
@@ -802,7 +804,9 @@ async def submission_loop(
     """
 
     # Create session with tool router
-    session = Session(event_queue, config=config, tool_router=tool_router)
+    session = Session(event_queue, config=config, tool_router=tool_router, hf_token=hf_token)
+    if session_holder is not None:
+        session_holder[0] = session
     logger.info("Agent loop started")
 
     # Retry any failed uploads from previous sessions (fire-and-forget)

agent/core/session.py

@@ -135,6 +135,11 @@ class Session:
     def is_cancelled(self) -> bool:
         return self._cancelled.is_set()
 
+    def update_model(self, model_name: str) -> None:
+        """Switch the active model and update the context window limit."""
+        self.config.model_name = model_name
+        self.context_manager.max_context = _get_max_tokens_safe(model_name)
+
     def increment_turn(self) -> None:
         """Increment turn counter (called after each user interaction)"""
         self.turn_count += 1

agent/core/tools.py

@@ -128,11 +128,11 @@ class ToolRouter:
     Based on codex-rs/core/src/tools/router.rs
     """
 
-    def __init__(self, mcp_servers: dict[str, MCPServerConfig], hf_token: str | None = None):
+    def __init__(self, mcp_servers: dict[str, MCPServerConfig], hf_token: str | None = None, local_mode: bool = False):
         self.tools: dict[str, ToolSpec] = {}
         self.mcp_servers: dict[str, dict[str, Any]] = {}
 
-        for tool in create_builtin_tools():
+        for tool in create_builtin_tools(local_mode=local_mode):
             self.register_tool(tool)
 
         self.mcp_client: Client | None = None
@@ -273,7 +273,7 @@ class ToolRouter:
 # ============================================================================
 
 
-def create_builtin_tools() -> list[ToolSpec]:
+def create_builtin_tools(local_mode: bool = False) -> list[ToolSpec]:
     """Create built-in tool specifications"""
     # in order of importance
     tools = [
@@ -350,8 +350,12 @@ def create_builtin_tools() -> list[ToolSpec]:
         ),
     ]
 
-    # Sandbox tools (highest priority)
-    tools = get_sandbox_tools() + tools
+    # Sandbox or local tools (highest priority)
+    if local_mode:
+        from agent.tools.local_tools import get_local_tools
+        tools = get_local_tools() + tools
+    else:
+        tools = get_sandbox_tools() + tools
 
     tool_names = ", ".join([t.name for t in tools])
     logger.info(f"Loaded {len(tools)} built-in tools: {tool_names}")

agent/main.py

@@ -5,6 +5,7 @@ Interactive CLI chat with the agent
 import asyncio
 import json
 import os
+import time
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Optional
@@ -30,6 +31,15 @@ from agent.utils.terminal_display import (
 
 litellm.drop_params = True
 
+# ── Available models (mirrors backend/routes/agent.py) ──────────────────
+AVAILABLE_MODELS = [
+    {"id": "anthropic/claude-opus-4-6", "label": "Claude Opus 4.6"},
+    {"id": "huggingface/fireworks-ai/MiniMaxAI/MiniMax-M2.5", "label": "MiniMax M2.5"},
+    {"id": "huggingface/novita/moonshotai/kimi-k2.5", "label": "Kimi K2.5"},
+    {"id": "huggingface/novita/zai-org/glm-5", "label": "GLM 5"},
+]
+VALID_MODEL_IDS = {m["id"] for m in AVAILABLE_MODELS}
+
 
 def _safe_get_args(arguments: dict) -> dict:
     """Safely extract args dict from arguments, handling cases where LLM passes string."""
@@ -40,6 +50,20 @@ def _safe_get_args(arguments: dict) -> dict:
     return args if isinstance(args, dict) else {}
 
 
+def _get_hf_token() -> str | None:
+    """Get HF token from environment or huggingface_hub login."""
+    token = os.environ.get("HF_TOKEN")
+    if token:
+        return token
+    try:
+        from huggingface_hub import HfApi
+        api = HfApi()
+        token = api.token
+        if token:
+            return token
+    except Exception:
+        pass
+    return None
 
 @dataclass
 class Operation:
@@ -102,6 +126,22 @@ async def event_listener(
                 if plan_display:
                     print(plan_display)
                 turn_complete_event.set()
+            elif event.event_type == "interrupted":
+                print("\n(interrupted)")
+                turn_complete_event.set()
+            elif event.event_type == "undo_complete":
+                print("Undo complete.")
+                turn_complete_event.set()
+            elif event.event_type == "tool_log":
+                tool = event.data.get("tool", "") if event.data else ""
+                log = event.data.get("log", "") if event.data else ""
+                if log:
+                    print(f"  [{tool}] {log}")
+            elif event.event_type == "tool_state_change":
+                tool = event.data.get("tool", "") if event.data else ""
+                state = event.data.get("state", "") if event.data else ""
+                if state in ("approved", "rejected", "running"):
+                    print(f"  {tool}: {state}")
             elif event.event_type == "error":
                 error = (
                     event.data.get("error", "Unknown error")
@@ -117,7 +157,7 @@ async def event_listener(
             elif event.event_type == "compacted":
                 old_tokens = event.data.get("old_tokens", 0) if event.data else 0
                 new_tokens = event.data.get("new_tokens", 0) if event.data else 0
-                print(f"Compacted context: {old_tokens} → {new_tokens} tokens")
+                print(f"Compacted context: {old_tokens} -> {new_tokens} tokens")
             elif event.event_type == "approval_required":
                 # Handle batch approval format
                 tools_data = event.data.get("tools", []) if event.data else []
@@ -133,7 +173,7 @@ async def event_listener(
                         }
                         for t in tools_data
                     ]
-                    print(f"\n⚡ YOLO MODE: Auto-approving {count} item(s)")
+                    print(f"\n YOLO MODE: Auto-approving {count} item(s)")
                     submission_id[0] += 1
                     approval_submission = Submission(
                         id=f"approval_{submission_id[0]}",
@@ -377,7 +417,7 @@ async def event_listener(
                     if response == "yolo":
                         config.yolo_mode = True
                         print(
-                            "⚡ YOLO MODE ACTIVATED - Auto-approving all future tool calls"
+                            "YOLO MODE ACTIVATED - Auto-approving all future tool calls"
                         )
                         # Auto-approve this item and all remaining
                         approvals.append(
@@ -434,6 +474,93 @@ async def get_user_input(prompt_session: PromptSession) -> str:
     return await prompt_session.prompt_async(HTML("\n<b><cyan>></cyan></b> "))
 
 
+# ── Slash command helpers ────────────────────────────────────────────────
+
+HELP_TEXT = """\
+Commands:
+  /help            Show this help
+  /undo            Undo last turn
+  /compact         Compact context window
+  /model [id]      Show available models or switch model
+  /yolo            Toggle auto-approve mode
+  /status          Show current model, turn count
+  /quit, /exit     Exit the CLI
+"""
+
+
+def _handle_slash_command(
+    cmd: str,
+    config,
+    session_holder: list,
+    submission_queue: asyncio.Queue,
+    submission_id: list[int],
+) -> Submission | None:
+    """
+    Handle a slash command. Returns a Submission to enqueue, or None if
+    the command was handled locally (caller should set turn_complete_event).
+    """
+    parts = cmd.strip().split(None, 1)
+    command = parts[0].lower()
+    arg = parts[1].strip() if len(parts) > 1 else ""
+
+    if command == "/help":
+        print(HELP_TEXT)
+        return None
+
+    if command == "/undo":
+        submission_id[0] += 1
+        return Submission(
+            id=f"sub_{submission_id[0]}",
+            operation=Operation(op_type=OpType.UNDO),
+        )
+
+    if command == "/compact":
+        submission_id[0] += 1
+        return Submission(
+            id=f"sub_{submission_id[0]}",
+            operation=Operation(op_type=OpType.COMPACT),
+        )
+
+    if command == "/model":
+        if not arg:
+            print("Available models:")
+            session = session_holder[0] if session_holder else None
+            current = config.model_name if config else ""
+            for m in AVAILABLE_MODELS:
+                marker = " <-- current" if m["id"] == current else ""
+                print(f"  {m['id']}  ({m['label']}){marker}")
+            return None
+        if arg not in VALID_MODEL_IDS:
+            print(f"Unknown model: {arg}")
+            print(f"Valid: {', '.join(VALID_MODEL_IDS)}")
+            return None
+        session = session_holder[0] if session_holder else None
+        if session:
+            session.update_model(arg)
+            print(f"Model switched to {arg}")
+        else:
+            config.model_name = arg
+            print(f"Model set to {arg} (session not started yet)")
+        return None
+
+    if command == "/yolo":
+        config.yolo_mode = not config.yolo_mode
+        state = "ON" if config.yolo_mode else "OFF"
+        print(f"YOLO mode: {state}")
+        return None
+
+    if command == "/status":
+        session = session_holder[0] if session_holder else None
+        print(f"Model: {config.model_name}")
+        if session:
+            print(f"Turns: {session.turn_count}")
+            print(f"Context items: {len(session.context_manager.items)}")
+        return None
+
+    print(f"Unknown command: {command}. Type /help for available commands.")
+    return None
+
+
 async def main():
     """Interactive chat with the agent"""
     from agent.utils.terminal_display import Colors
@@ -442,21 +569,28 @@ async def main():
     os.system("clear" if os.name != "nt" else "cls")
 
     banner = r"""
-  _   _                   _               _____                   _                    _   
- | | | |_   _  __ _  __ _(_)_ __   __ _  |  ___|_ _  ___ ___     / \   __ _  ___ _ __ | |_ 
+  _   _                   _               _____                   _                    _
+ | | | |_   _  __ _  __ _(_)_ __   __ _  |  ___|_ _  ___ ___     / \   __ _  ___ _ __ | |_
  | |_| | | | |/ _` |/ _` | | '_ \ / _` | | |_ / _` |/ __/ _ \   / _ \ / _` |/ _ \ '_ \| __|
- |  _  | |_| | (_| | (_| | | | | | (_| | |  _| (_| | (_|  __/  / ___ \ (_| |  __/ | | | |_ 
+ |  _  | |_| | (_| | (_| | | | | | (_| | |  _| (_| | (_|  __/  / ___ \ (_| |  __/ | | | |_
  |_| |_|\__,_|\__, |\__, |_|_| |_|\__, | |_|  \__,_|\___\___| /_/   \_\__, |\___|_| |_|\__|
               |___/ |___/         |___/                               |___/
     """
 
     print(format_separator())
     print(f"{Colors.YELLOW} {banner}{Colors.RESET}")
-    print("Type your messages below. Type 'exit', 'quit', or '/quit' to end.\n")
+    print("Type your messages below. Type /help for commands, /quit to exit.\n")
     print(format_separator())
     # Wait for agent to initialize
     print("Initializing agent...")
 
+    # HF token
+    hf_token = _get_hf_token()
+    if hf_token:
+        print("HF token loaded")
+    else:
+        print("Warning: No HF token found. Set HF_TOKEN or run `huggingface-cli login`.")
+
     # Create queues for communication
     submission_queue = asyncio.Queue()
     event_queue = asyncio.Queue()
@@ -470,19 +604,24 @@ async def main():
     config_path = Path(__file__).parent.parent / "configs" / "main_agent_config.json"
     config = load_config(config_path)
 
-    # Create tool router
+    # Create tool router with local mode
     print(f"Loading MCP servers: {', '.join(config.mcpServers.keys())}")
-    tool_router = ToolRouter(config.mcpServers)
+    tool_router = ToolRouter(config.mcpServers, hf_token=hf_token, local_mode=True)
 
     # Create prompt session for input
     prompt_session = PromptSession()
 
+    # Session holder for interrupt/model/status access
+    session_holder = [None]
+
     agent_task = asyncio.create_task(
         submission_loop(
             submission_queue,
             event_queue,
             config=config,
             tool_router=tool_router,
+            session_holder=session_holder,
+            hf_token=hf_token,
         )
     )
 
@@ -500,12 +639,16 @@ async def main():
 
     await ready_event.wait()
 
-    submission_id = 0
+    submission_id = [0]
+    last_interrupt_time = 0.0
 
     try:
         while True:
-            # Wait for previous turn to complete
-            await turn_complete_event.wait()
+            # Wait for previous turn to complete, with interrupt support
+            try:
+                await turn_complete_event.wait()
+            except asyncio.CancelledError:
+                break
             turn_complete_event.clear()
 
             # Get user input
@@ -513,6 +656,21 @@ async def main():
                 user_input = await get_user_input(prompt_session)
             except EOFError:
                 break
+            except KeyboardInterrupt:
+                now = time.monotonic()
+                if now - last_interrupt_time < 3.0:
+                    print("\nDouble Ctrl+C, exiting...")
+                    break
+                last_interrupt_time = now
+                # If agent is busy, cancel it
+                session = session_holder[0]
+                if session and not turn_complete_event.is_set():
+                    session.cancel()
+                    print("\nInterrupting agent...")
+                else:
+                    print("\n(Ctrl+C again within 3s to exit)")
+                    turn_complete_event.set()
+                continue
 
             # Check for exit commands
             if user_input.strip().lower() in ["exit", "quit", "/quit", "/exit"]:
@@ -523,35 +681,50 @@ async def main():
                 turn_complete_event.set()
                 continue
 
+            # Handle slash commands
+            if user_input.strip().startswith("/"):
+                sub = _handle_slash_command(
+                    user_input.strip(), config, session_holder, submission_queue, submission_id
+                )
+                if sub is None:
+                    # Command handled locally, loop back for input
+                    turn_complete_event.set()
+                    continue
+                else:
+                    await submission_queue.put(sub)
+                    continue
+
             # Submit to agent
-            submission_id += 1
+            submission_id[0] += 1
             submission = Submission(
-                id=f"sub_{submission_id}",
+                id=f"sub_{submission_id[0]}",
                 operation=Operation(
                     op_type=OpType.USER_INPUT, data={"text": user_input}
                 ),
             )
-            # print(f"Main submitting: {submission.operation.op_type}")
             await submission_queue.put(submission)
 
     except KeyboardInterrupt:
         print("\n\nInterrupted by user")
 
     # Shutdown
-    print("\n🛑 Shutting down agent...")
+    print("\nShutting down agent...")
     shutdown_submission = Submission(
         id="sub_shutdown", operation=Operation(op_type=OpType.SHUTDOWN)
     )
     await submission_queue.put(shutdown_submission)
 
-    await asyncio.wait_for(agent_task, timeout=5.0)
+    try:
+        await asyncio.wait_for(agent_task, timeout=5.0)
+    except asyncio.TimeoutError:
+        agent_task.cancel()
     listener_task.cancel()
 
-    print("✨ Goodbye!\n")
+    print("Goodbye!\n")
 
 
 if __name__ == "__main__":
     try:
         asyncio.run(main())
     except KeyboardInterrupt:
-        print("\n\n✨ Goodbye!")
+        print("\n\nGoodbye!")

agent/tools/local_tools.py

@@ -0,0 +1,159 @@
+"""
+Local tool implementations — bash/read/write/edit running on the user's machine.
+
+Drop-in replacement for sandbox tools when running in CLI (local) mode.
+Same tool specs (names, parameters) but handlers execute locally via
+subprocess/pathlib instead of going through a remote sandbox.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from agent.tools.sandbox_client import Sandbox
+
+MAX_OUTPUT_CHARS = 30_000
+MAX_LINE_LENGTH = 2000
+DEFAULT_READ_LINES = 2000
+DEFAULT_TIMEOUT = 120
+MAX_TIMEOUT = 600
+
+
+# ── Handlers ────────────────────────────────────────────────────────────
+
+async def _bash_handler(args: dict[str, Any], **_kw) -> tuple[str, bool]:
+    command = args.get("command", "")
+    if not command:
+        return "No command provided.", False
+    work_dir = args.get("work_dir", ".")
+    timeout = min(args.get("timeout") or DEFAULT_TIMEOUT, MAX_TIMEOUT)
+    try:
+        result = subprocess.run(
+            command,
+            shell=True,
+            capture_output=True,
+            text=True,
+            cwd=work_dir,
+            timeout=timeout,
+        )
+        output = result.stdout + result.stderr
+        if len(output) > MAX_OUTPUT_CHARS:
+            output = output[:MAX_OUTPUT_CHARS] + "\n... (output truncated)"
+        if not output.strip():
+            output = "(no output)"
+        return output, result.returncode == 0
+    except subprocess.TimeoutExpired:
+        return f"Command timed out after {timeout}s.", False
+    except Exception as e:
+        return f"bash error: {e}", False
+
+
+async def _read_handler(args: dict[str, Any], **_kw) -> tuple[str, bool]:
+    file_path = args.get("path", "")
+    if not file_path:
+        return "No path provided.", False
+    p = Path(file_path)
+    if not p.exists():
+        return f"File not found: {file_path}", False
+    if p.is_dir():
+        return "Cannot read a directory. Use bash with 'ls' instead.", False
+    try:
+        lines = p.read_text().splitlines()
+    except Exception as e:
+        return f"read error: {e}", False
+
+    offset = max((args.get("offset") or 1), 1)
+    limit = args.get("limit") or DEFAULT_READ_LINES
+
+    selected = lines[offset - 1 : offset - 1 + limit]
+    numbered = []
+    for i, line in enumerate(selected, start=offset):
+        if len(line) > MAX_LINE_LENGTH:
+            line = line[:MAX_LINE_LENGTH] + "..."
+        numbered.append(f"{i:>6}\t{line}")
+    return "\n".join(numbered), True
+
+
+async def _write_handler(args: dict[str, Any], **_kw) -> tuple[str, bool]:
+    file_path = args.get("path", "")
+    content = args.get("content", "")
+    if not file_path:
+        return "No path provided.", False
+    p = Path(file_path)
+    try:
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(content)
+        return f"Wrote {len(content)} bytes to {file_path}", True
+    except Exception as e:
+        return f"write error: {e}", False
+
+
+async def _edit_handler(args: dict[str, Any], **_kw) -> tuple[str, bool]:
+    file_path = args.get("path", "")
+    old_str = args.get("old_str", "")
+    new_str = args.get("new_str", "")
+    replace_all = args.get("replace_all", False)
+
+    if not file_path:
+        return "No path provided.", False
+    if old_str == new_str:
+        return "old_str and new_str must differ.", False
+
+    p = Path(file_path)
+    if not p.exists():
+        return f"File not found: {file_path}", False
+
+    try:
+        text = p.read_text()
+    except Exception as e:
+        return f"edit read error: {e}", False
+
+    count = text.count(old_str)
+    if count == 0:
+        return "old_str not found in file.", False
+    if count > 1 and not replace_all:
+        return (
+            f"old_str appears {count} times. Use replace_all=true to replace all, "
+            "or provide a more specific old_str."
+        ), False
+
+    new_text = text.replace(old_str, new_str) if replace_all else text.replace(old_str, new_str, 1)
+    try:
+        p.write_text(new_text)
+    except Exception as e:
+        return f"edit write error: {e}", False
+
+    replacements = count if replace_all else 1
+    return f"Edited {file_path} ({replacements} replacement{'s' if replacements > 1 else ''})", True
+
+
+# ── Public API ──────────────────────────────────────────────────────────
+
+_HANDLERS = {
+    "bash": _bash_handler,
+    "read": _read_handler,
+    "write": _write_handler,
+    "edit": _edit_handler,
+}
+
+
+def get_local_tools():
+    """Return local ToolSpecs for bash/read/write/edit (no sandbox_create)."""
+    from agent.core.tools import ToolSpec
+
+    tools = []
+    for name, spec in Sandbox.TOOLS.items():
+        handler = _HANDLERS.get(name)
+        if handler is None:
+            continue
+        tools.append(
+            ToolSpec(
+                name=name,
+                description=spec["description"],
+                parameters=spec["parameters"],
+                handler=handler,
+            )
+        )
+    return tools