intermediary commit

agent/config.py

@@ -7,7 +7,7 @@ class MCPServerConfig(BaseModel):
 
     name: str
     command: str
-    args: list[str]
+    args: list[str] = []
     env: dict[str, str] | None = None
 
 
@@ -15,8 +15,8 @@ class Config(BaseModel):
     """Configuration manager"""
 
     model_name: str
-    tools: list[Tool]
-    system_prompt_path: str
+    tools: list[Tool] = []
+    system_prompt_path: str = ""
     mcp_servers: list[MCPServerConfig] = []
 
 

agent/context_manager/manager.py

@@ -10,9 +10,7 @@ class ContextManager:
 
     def __init__(self):
         self.system_prompt = self._load_system_prompt()
-        self.items: list[Message] = [
-            Message(role="system", content=self.system_prompt)
-        ]
+        self.items: list[Message] = [Message(role="system", content=self.system_prompt)]
 
     def _load_system_prompt(self):
         """Load the system prompt"""
@@ -35,8 +33,10 @@ class ContextManager:
             return
 
         # Always keep system prompt
-        system_msg = self.items[0] if self.items and self.items[0].role == "system" else None
-        messages_to_keep = self.items[-(target_size - 1):]
+        system_msg = (
+            self.items[0] if self.items and self.items[0].role == "system" else None
+        )
+        messages_to_keep = self.items[-(target_size - 1) :]
 
         if system_msg:
             self.items = [system_msg] + messages_to_keep

agent/core/__init__.py

@@ -3,7 +3,13 @@ Core agent implementation
 Contains the main agent logic, decision-making, and orchestration
 """
 
-from agent.core.executor import ToolExecutor
-from agent.core.mcp_client import MCPClient, MCPServerConfig
+from agent.core.mcp_client import McpClient, McpConnectionManager
+from agent.core.tools import ToolRouter, ToolSpec, create_builtin_tools
 
-__all__ = ["ToolExecutor", "MCPClient", "MCPServerConfig"]
+__all__ = [
+    "McpClient",
+    "McpConnectionManager",
+    "ToolRouter",
+    "ToolSpec",
+    "create_builtin_tools",
+]

agent/core/agent_loop.py

@@ -1,15 +1,11 @@
 """
-Main agent implementation
+Main agent implementation with integrated tool system and MCP support
 """
 
 import asyncio
+import json
 
-from litellm import (
-    ChatCompletionMessageToolCall,
-    Message,
-    ModelResponse,
-    acompletion,
-)
+from litellm import ChatCompletionMessageToolCall, Message, ModelResponse, acompletion
 
 from agent.config import Config
 from agent.core.session import Event, OpType, Session
@@ -36,14 +32,16 @@ class Handlers:
         iteration = 0
         while iteration < max_iterations:
             messages = session.context_manager.get_messages()
-            print(f"Messages: {messages}")
+            tools = session.tool_router.get_tool_specs_for_llm()
 
             try:
                 response: ModelResponse = await acompletion(
                     model=session.config.model_name,
                     messages=messages,
-                    tools=session.config.tools,
+                    tools=tools,
+                    tool_choice="auto",
                 )
+
                 message = response.choices[0].message
 
                 # Extract content and tool calls
@@ -56,46 +54,58 @@ class Handlers:
                     session.context_manager.add_message(assistant_msg)
 
                     await session.send_event(
-                        Event(
-                            event_type="assistant_message",
-                            data={"message": assistant_msg},
-                        )
+                        Event(event_type="assistant_message", data={"content": content})
                     )
 
                 # If no tool calls, we're done
                 if not tool_calls:
                     break
 
-                for tool_call in tool_calls:
-                    print(f"Executing tool: {tool_call.function.name}")
-                    result = await session.tool_executor.execute_tool(tool_call)
-                    print(result)
-                    tool_output = Message(
-                        role="tool", content=result.output, success=result.success
+                # Execute tools
+                for tc in tool_calls:
+                    tool_name = tc.function.name
+                    tool_args = json.loads(tc.function.arguments)
+
+                    await session.send_event(
+                        Event(
+                            event_type="tool_call",
+                            data={"tool": tool_name, "arguments": tool_args},
+                        )
+                    )
+
+                    output, success = await session.tool_router.execute_tool(
+                        tool_name, tool_args
                     )
-                    session.context_manager.add_message(tool_output)
+
+                    # Add tool result to history
+                    tool_msg = Message(
+                        role="tool",
+                        content=output,
+                        tool_call_id=tc.id,
+                        name=tool_name,
+                    )
+                    session.context_manager.add_message(tool_msg)
 
                     await session.send_event(
                         Event(
                             event_type="tool_output",
-                            data={"message": tool_output},
+                            data={
+                                "tool": tool_name,
+                                "output": output[:200]
+                                + ("..." if len(output) > 200 else ""),
+                                "success": success,
+                            },
                         )
                     )
 
                 iteration += 1
 
             except Exception as e:
-                import traceback
-
                 await session.send_event(
-                    Event(
-                        event_type="error",
-                        data={"error": traceback.print_exc() + str(e)},
-                    )
+                    Event(event_type="error", data={"error": str(e)})
                 )
                 break
 
-        # Send completion event
         await session.send_event(
             Event(
                 event_type="turn_complete",
@@ -153,7 +163,7 @@ async def process_submission(session: Session, submission) -> bool:
 
     if op.op_type == OpType.USER_INPUT:
         text = op.data.get("text", "") if op.data else ""
-        await Handlers.run_agent(session, text, max_iterations=10)
+        await Handlers.user_input(session, text)
         return True
 
     if op.op_type == OpType.INTERRUPT:
@@ -178,23 +188,56 @@ async def process_submission(session: Session, submission) -> bool:
 async def submission_loop(
     submission_queue: asyncio.Queue,
     event_queue: asyncio.Queue,
+    tool_router=None,
     config: Config | None = None,
 ) -> None:
     """
     Main agent loop - processes submissions and dispatches to handlers.
     This is the core of the agent (like submission_loop in codex.rs:1259-1340)
     """
+    # Import here to avoid circular imports
+    from agent.core.mcp_client import McpConnectionManager
+    from agent.core.tools import ToolRouter, create_builtin_tools
+
+    # Initialize MCP and tools
+    if tool_router is None:
+        mcp_manager = McpConnectionManager()
+
+        # Add MCP servers from config
+        if config and config.mcp_servers:
+            print("🔌 Initializing MCP connections...")
+            for server_config in config.mcp_servers:
+                try:
+                    await mcp_manager.add_server(
+                        server_name=server_config.name,
+                        command=server_config.command,
+                        args=server_config.args,
+                        env=server_config.env,
+                    )
+                except Exception as e:
+                    print(
+                        f"⚠️  Failed to connect to MCP server {server_config.name}: {e}"
+                    )
+
+        # Create tool router
+        tool_router = ToolRouter(mcp_manager)
+
+        # Register built-in tools
+        for tool in create_builtin_tools():
+            tool_router.register_tool(tool)
+
+        # Register MCP tools
+        tool_router.register_mcp_tools()
+
+        print(f"📦 Registered {len(tool_router.tools)} tools:")
+        for tool_name in tool_router.tools.keys():
+            print(f"   - {tool_name}")
+
+    # Create session and assign tool router
     session = Session(event_queue, config=config)
+    session.tool_router = tool_router
     print("🤖 Agent loop started")
 
-    # Initialize MCP connections
-    if session.config.mcp_servers:
-        try:
-            print(f"Initializing MCP connections for {session.config.mcp_servers}")
-            await session.initialize_mcp()
-        except Exception as e:
-            print(f"⚠️  Error initializing MCP: {e}")
-
     try:
         # Main processing loop
         while session.is_running:
@@ -208,8 +251,12 @@ async def submission_loop(
                 break
             except Exception as e:
                 print(f"❌ Error in agent loop: {e}")
-                await session.send_event(Event(event_type="error", data={"error": str(e)}))
+                await session.send_event(
+                    Event(event_type="error", data={"error": str(e)})
+                )
     finally:
-        await session.cleanup()
+        # Cleanup MCP connections
+        if hasattr(tool_router, "mcp_manager") and tool_router.mcp_manager:
+            await tool_router.mcp_manager.shutdown_all()
 
     print("🛑 Agent loop exited")

agent/core/executor.py

@@ -1,48 +0,0 @@
-"""
-Task execution engine
-"""
-
-import json
-from typing import Any, List
-
-from litellm import ChatCompletionMessageToolCall
-from pydantic import BaseModel
-
-ToolCall = ChatCompletionMessageToolCall
-
-
-class ToolResult(BaseModel):
-    output: str
-    success: bool
-
-
-class ToolExecutor:
-    """Executes planned tasks using available tools"""
-
-    def __init__(self, tools: List[Any] = None, mcp_client=None):
-        self.tools = tools or []
-        self.mcp_client = mcp_client
-
-    async def execute_tool(self, tool_call: ToolCall) -> ToolResult:
-        """Execute a single step in the plan"""
-        tool_name = tool_call.function.name
-
-        # Parse arguments
-        try:
-            if isinstance(tool_call.function.arguments, str):
-                tool_args = json.loads(tool_call.function.arguments)
-            else:
-                tool_args = tool_call.function.arguments
-        except json.JSONDecodeError as e:
-            return ToolResult(
-                output=f"Error parsing tool arguments: {str(e)}", success=False
-            )
-
-        # Check if this is an MCP tool (prefixed with server name)
-        if self.mcp_client and "__" in tool_name:
-            success, result = await self.mcp_client.call_tool(tool_name, tool_args)
-            return ToolResult(output=result, success=success)
-
-        # If not an MCP tool, try local tools
-        # TODO: Implement local tool execution
-        return ToolResult(output=f"Tool {tool_name} not found", success=False)

agent/core/mcp_client.py

@@ -1,149 +1,164 @@
 """
 MCP (Model Context Protocol) client integration for the agent
+Based on the official MCP SDK implementation
 """
 
+import os
 from contextlib import AsyncExitStack
-from typing import Optional
+from typing import Any, Optional
 
-from mcp import ClientSession, StdioServerParameters
+from mcp import ClientSession, StdioServerParameters, types
 from mcp.client.stdio import stdio_client
 
 
-class MCPServerConfig:
-    """Configuration for an MCP server"""
+class McpClient:
+    """
+    Client for connecting to MCP servers using the official MCP SDK.
+    Based on codex-rs/core/src/mcp_connection_manager.rs
+    """
 
     def __init__(
         self,
-        name: str,
+        server_name: str,
         command: str,
-        args: list[str],
-        env: Optional[dict[str, str]] = None,
+        args: list[str] | None = None,
+        env: dict[str, str] | None = None,
     ):
-        self.name = name
+        self.server_name = server_name
         self.command = command
-        self.args = args
-        self.env = env
-
-
-class MCPClient:
-    """
-    Manages connections to MCP servers and provides tool access
-    """
-
-    def __init__(self):
-        self.sessions: dict[str, ClientSession] = {}
+        self.args = args or []
+        self.env = env or {}
+        self.session: Optional[ClientSession] = None
+        self.tools: dict[str, dict[str, Any]] = {}
         self.exit_stack = AsyncExitStack()
-        self._tools_cache: Optional[list[dict]] = None
 
-    async def connect_to_server(self, server_config: MCPServerConfig) -> None:
-        """
-        Connect to an MCP server
+    async def start(self) -> None:
+        """Start the MCP server connection using official SDK"""
+        # Merge environment variables
+        full_env = {**dict(os.environ), **self.env} if self.env else None
 
-        Args:
-            server_config: Configuration for the MCP server
-        """
+        # Create server parameters
         server_params = StdioServerParameters(
-            command=server_config.command,
-            args=server_config.args,
-            env=server_config.env,
+            command=self.command,
+            args=self.args,
+            env=full_env,
         )
 
-        stdio_transport = await self.exit_stack.enter_async_context(
+        # Connect using stdio_client
+        read, write = await self.exit_stack.enter_async_context(
             stdio_client(server_params)
         )
-        stdio, write = stdio_transport
-        session = await self.exit_stack.enter_async_context(ClientSession(stdio, write))
-
-        await session.initialize()
-
-        # Store the session
-        self.sessions[server_config.name] = session
-
-        # Invalidate tools cache
-        self._tools_cache = None
-
-        print(f"✅ Connected to MCP server: {server_config.name}")
-
-    async def list_tools(self) -> list[dict]:
-        """
-        Get all available tools from all connected servers
-
-        Returns:
-            List of tool definitions compatible with LiteLLM format
-        """
-        if self._tools_cache is not None:
-            return self._tools_cache
-
-        all_tools = []
-
-        for server_name, session in self.sessions.items():
-            try:
-                response = await session.list_tools()
-                for tool in response.tools:
-                    # Convert MCP tool format to LiteLLM tool format
-                    tool_def = {
-                        "type": "function",
-                        "function": {
-                            "name": f"{server_name}__{tool.name}",  # Prefix with server name
-                            "description": tool.description or "",
-                            "parameters": tool.inputSchema,
-                        },
-                    }
-                    all_tools.append(tool_def)
-            except Exception as e:
-                print(f"⚠️  Error listing tools from {server_name}: {e}")
-
-        self._tools_cache = all_tools
-        return all_tools
 
-    async def call_tool(self, tool_name: str, tool_args: dict) -> tuple[bool, str]:
-        """
-        Call a tool on the appropriate MCP server
+        # Create session
+        self.session = await self.exit_stack.enter_async_context(
+            ClientSession(read, write)
+        )
 
-        Args:
-            tool_name: Name of the tool (format: "server_name__tool_name")
-            tool_args: Arguments to pass to the tool
+        # Initialize
+        await self.session.initialize()
+
+        # List available tools
+        tools_result = await self.session.list_tools()
+        for tool in tools_result.tools:
+            qualified_name = f"mcp__{self.server_name}__{tool.name}"
+            self.tools[qualified_name] = {
+                "name": tool.name,
+                "description": tool.description or "",
+                "inputSchema": tool.inputSchema,
+            }
+
+    async def call_tool(
+        self, tool_name: str, arguments: dict[str, Any]
+    ) -> tuple[str, bool]:
+        """Execute a tool on the MCP server"""
+        if not self.session:
+            return "Client not connected", False
+
+        # Strip the mcp__servername__ prefix to get the actual tool name
+        actual_tool_name = tool_name.split("__")[-1]
 
-        Returns:
-            Tuple of (success, result_content)
-        """
-        # Parse server name from tool name
-        if "__" not in tool_name:
-            return False, f"Invalid tool name format: {tool_name}"
+        try:
+            result = await self.session.call_tool(actual_tool_name, arguments)
+
+            # Extract text from content
+            text_parts = []
+            for content in result.content:
+                if isinstance(content, types.TextContent):
+                    text_parts.append(content.text)
+                elif isinstance(content, types.ImageContent):
+                    text_parts.append(f"[Image: {content.mimeType}]")
+                elif isinstance(content, types.EmbeddedResource):
+                    text_parts.append(f"[Resource: {content.resource}]")
+
+            output = "\n".join(text_parts) if text_parts else str(result.content)
+            success = not result.isError
+
+            return output, success
+        except Exception as e:
+            return f"Tool call failed: {str(e)}", False
 
-        server_name, actual_tool_name = tool_name.split("__", 1)
+    def get_tools(self) -> dict[str, dict[str, Any]]:
+        """Get all available tools from this server"""
+        return self.tools.copy()
 
-        if server_name not in self.sessions:
-            return False, f"Server not found: {server_name}"
+    async def shutdown(self) -> None:
+        """Shutdown the MCP server connection"""
+        await self.exit_stack.aclose()
 
-        session = self.sessions[server_name]
 
-        try:
-            result = await session.call_tool(actual_tool_name, tool_args)
-
-            # Extract content from result
-            if hasattr(result, "content"):
-                if isinstance(result.content, list):
-                    # Handle list of content items
-                    content_parts = []
-                    for item in result.content:
-                        if hasattr(item, "text"):
-                            content_parts.append(item.text)
-                        else:
-                            content_parts.append(str(item))
-                    content = "\n".join(content_parts)
-                else:
-                    content = str(result.content)
-            else:
-                content = str(result)
-
-            return True, content
+class McpConnectionManager:
+    """
+    Manages multiple MCP server connections.
+    Based on codex-rs/core/src/mcp_connection_manager.rs
+    """
+
+    def __init__(self):
+        self.clients: dict[str, McpClient] = {}
 
+    async def add_server(
+        self,
+        server_name: str,
+        command: str,
+        args: list[str] | None = None,
+        env: dict[str, str] | None = None,
+    ) -> bool:
+        """Add and start an MCP server"""
+        try:
+            client = McpClient(server_name, command, args, env)
+            await client.start()
+            self.clients[server_name] = client
+            print(
+                f"✅ MCP server '{server_name}' connected with {len(client.tools)} tools"
+            )
+            return True
         except Exception as e:
-            return False, f"Error calling tool {tool_name}: {str(e)}"
+            print(f"❌ Failed to start MCP server '{server_name}': {e}")
+            return False
+
+    def list_all_tools(self) -> dict[str, dict[str, Any]]:
+        """Aggregate tools from all connected servers"""
+        all_tools = {}
+        for client in self.clients.values():
+            all_tools.update(client.get_tools())
+        return all_tools
 
-    async def cleanup(self) -> None:
-        """Clean up all MCP connections"""
-        await self.exit_stack.aclose()
-        self.sessions.clear()
-        self._tools_cache = None
+    async def call_tool(
+        self, tool_name: str, arguments: dict[str, Any]
+    ) -> tuple[str, bool]:
+        """Route tool call to the appropriate MCP server"""
+        # Extract server name from qualified tool name: mcp__servername__toolname
+        if tool_name.startswith("mcp__"):
+            parts = tool_name.split("__")
+            if len(parts) >= 3:
+                server_name = parts[1]
+                if server_name in self.clients:
+                    return await self.clients[server_name].call_tool(
+                        tool_name, arguments
+                    )
+
+        return "Unknown MCP tool", False
+
+    async def shutdown_all(self) -> None:
+        """Shutdown all MCP servers"""
+        for client in self.clients.values():
+            await client.shutdown()

agent/core/session.py

@@ -1,13 +1,10 @@
 import asyncio
+from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Literal
-
-from pydantic import BaseModel
+from typing import Any, Optional
 
 from agent.config import Config
 from agent.context_manager.manager import ContextManager
-from agent.core import ToolExecutor
-from agent.core.mcp_client import MCPClient, MCPServerConfig as MCPServerConfigClass
 
 
 class OpType(Enum):
@@ -19,19 +16,10 @@ class OpType(Enum):
     SHUTDOWN = "shutdown"
 
 
-class Event(BaseModel):
-    event_type: Literal[
-        "processing",
-        "assistant_message",
-        "tool_output",
-        "turn_complete",
-        "compacted",
-        "undo_complete",
-        "shutdown",
-        "error",
-        "interrupted",
-    ]
-    data: dict[str, Any] | None = None
+@dataclass
+class Event:
+    event_type: str
+    data: Optional[dict[str, Any]] = None
 
 
 class Session:
@@ -40,7 +28,11 @@ class Session:
     Similar to Session in codex-rs/core/src/codex.rs
     """
 
-    def __init__(self, event_queue: asyncio.Queue, config: Config | None = None):
+    def __init__(
+        self,
+        event_queue: asyncio.Queue,
+        config: Config | None = None,
+    ):
         self.context_manager = ContextManager()
         self.event_queue = event_queue
         self.config = config or Config(
@@ -48,42 +40,9 @@ class Session:
             tools=[],
             system_prompt_path="",
         )
-
-        # Initialize MCP client
-        self.mcp_client = MCPClient()
-        self.tool_executor = ToolExecutor(mcp_client=self.mcp_client)
-
         self.is_running = True
         self.current_task: asyncio.Task | None = None
-        self._mcp_initialized = False
-
-    async def initialize_mcp(self) -> None:
-        """Initialize MCP server connections"""
-        if self._mcp_initialized:
-            return
-
-        for server_config in self.config.mcp_servers:
-            try:
-                mcp_server_config = MCPServerConfigClass(
-                    name=server_config.name,
-                    command=server_config.command,
-                    args=server_config.args,
-                    env=server_config.env,
-                )
-                await self.mcp_client.connect_to_server(mcp_server_config)
-            except Exception as e:
-                print(f"⚠️  Failed to connect to MCP server {server_config.name}: {e}")
-
-        # Get MCP tools and merge with config tools
-        try:
-            mcp_tools = await self.mcp_client.list_tools()
-            # Merge with existing tools
-            self.config.tools = list(self.config.tools) + mcp_tools
-            print(f"📦 Loaded {len(mcp_tools)} tools from MCP servers")
-        except Exception as e:
-            print(f"⚠️  Error loading MCP tools: {e}")
-
-        self._mcp_initialized = True
+        self.tool_router = None  # Set by submission_loop
 
     async def send_event(self, event: Event) -> None:
         """Send event back to client"""
@@ -93,7 +52,3 @@ class Session:
         """Interrupt current running task"""
         if self.current_task and not self.current_task.done():
             self.current_task.cancel()
-
-    async def cleanup(self) -> None:
-        """Cleanup session resources"""
-        await self.mcp_client.cleanup()

agent/core/tools.py

@@ -0,0 +1,184 @@
+"""
+Tool system for the agent
+Provides ToolSpec and ToolRouter for managing both built-in and MCP tools
+"""
+
+import subprocess
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable, Optional
+
+from agent.core.mcp_client import McpConnectionManager
+
+
+@dataclass
+class ToolSpec:
+    """Tool specification for LLM"""
+
+    name: str
+    description: str
+    parameters: dict[str, Any]
+    handler: Optional[Callable[[dict[str, Any]], Awaitable[tuple[str, bool]]]] = None
+
+
+class ToolRouter:
+    """
+    Routes tool calls to appropriate handlers.
+    Based on codex-rs/core/src/tools/router.rs
+    """
+
+    def __init__(self, mcp_manager: Optional[McpConnectionManager] = None):
+        self.tools: dict[str, ToolSpec] = {}
+        self.mcp_manager = mcp_manager
+
+    def register_tool(self, spec: ToolSpec) -> None:
+        """Register a tool with its handler"""
+        self.tools[spec.name] = spec
+
+    def register_mcp_tools(self) -> None:
+        """Register all MCP tools from the connection manager"""
+        if not self.mcp_manager:
+            return
+
+        mcp_tools = self.mcp_manager.list_all_tools()
+        for tool_name, tool_def in mcp_tools.items():
+            spec = ToolSpec(
+                name=tool_name,
+                description=tool_def.get("description", ""),
+                parameters=tool_def.get(
+                    "inputSchema", {"type": "object", "properties": {}}
+                ),
+                handler=None,  # MCP tools use the manager
+            )
+            self.tools[tool_name] = spec
+
+    def get_tool_specs_for_llm(self) -> list[dict[str, Any]]:
+        """Get tool specifications in OpenAI format"""
+        specs = []
+        for tool in self.tools.values():
+            specs.append(
+                {
+                    "type": "function",
+                    "function": {
+                        "name": tool.name,
+                        "description": tool.description,
+                        "parameters": tool.parameters,
+                    },
+                }
+            )
+        return specs
+
+    async def execute_tool(
+        self, tool_name: str, arguments: dict[str, Any]
+    ) -> tuple[str, bool]:
+        """Execute a tool by name"""
+        if tool_name not in self.tools:
+            return f"Unknown tool: {tool_name}", False
+
+        tool = self.tools[tool_name]
+
+        # MCP tool
+        if tool_name.startswith("mcp__") and self.mcp_manager:
+            return await self.mcp_manager.call_tool(tool_name, arguments)
+
+        # Built-in tool with handler
+        if tool.handler:
+            return await tool.handler(arguments)
+
+        return "Tool has no handler", False
+
+
+# ============================================================================
+# BUILT-IN TOOL HANDLERS
+# ============================================================================
+
+
+async def bash_handler(arguments: dict[str, Any]) -> tuple[str, bool]:
+    """Execute bash command"""
+    try:
+        command = arguments.get("command", "")
+        result = subprocess.run(
+            command, shell=True, capture_output=True, text=True, timeout=30
+        )
+        output = result.stdout if result.returncode == 0 else result.stderr
+        success = result.returncode == 0
+        return output, success
+    except Exception as e:
+        return f"Error: {str(e)}", False
+
+
+async def read_file_handler(arguments: dict[str, Any]) -> tuple[str, bool]:
+    """Read file contents"""
+    try:
+        path = arguments.get("path", "")
+        with open(path, "r") as f:
+            content = f.read()
+        return content, True
+    except Exception as e:
+        return f"Error reading file: {str(e)}", False
+
+
+async def write_file_handler(arguments: dict[str, Any]) -> tuple[str, bool]:
+    """Write to file"""
+    try:
+        path = arguments.get("path", "")
+        content = arguments.get("content", "")
+        with open(path, "w") as f:
+            f.write(content)
+        return f"Successfully wrote to {path}", True
+    except Exception as e:
+        return f"Error writing file: {str(e)}", False
+
+
+def create_builtin_tools() -> list[ToolSpec]:
+    """Create built-in tool specifications"""
+    return [
+        ToolSpec(
+            name="bash",
+            description="Execute a bash command and return its output",
+            parameters={
+                "type": "object",
+                "properties": {
+                    "command": {
+                        "type": "string",
+                        "description": "The bash command to execute",
+                    }
+                },
+                "required": ["command"],
+            },
+            handler=bash_handler,
+        ),
+        ToolSpec(
+            name="read_file",
+            description="Read the contents of a file",
+            parameters={
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "Path to the file to read",
+                    }
+                },
+                "required": ["path"],
+            },
+            handler=read_file_handler,
+        ),
+        ToolSpec(
+            name="write_file",
+            description="Write content to a file",
+            parameters={
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "Path to the file to write",
+                    },
+                    "content": {
+                        "type": "string",
+                        "description": "Content to write to the file",
+                    },
+                },
+                "required": ["path", "content"],
+            },
+            handler=write_file_handler,
+        ),
+    ]