moonbridge 0.5.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

moonbridge/__init__.py

@@ -1,8 +1,8 @@
-"""MCP server for spawning Kimi K2.5 agents."""
+"""MCP server for spawning AI coding agents."""
 
 from __future__ import annotations
 
-__version__ = "0.5.2"
+__version__ = "0.6.0"
 
 from .server import main, run, server
 

moonbridge/adapters/base.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Protocol
+from typing import Any, Protocol
 
 
 @dataclass(frozen=True)
@@ -18,6 +18,35 @@ class AdapterConfig:
     default_timeout: int = 600
 
 
+@dataclass(frozen=True)
+class AgentResult:
+    """Agent execution result."""
+
+    status: str
+    output: str
+    stderr: str | None
+    returncode: int
+    duration_ms: int
+    agent_index: int
+    message: str | None = None
+    raw: dict[str, Any] | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "status": self.status,
+            "output": self.output,
+            "stderr": self.stderr,
+            "returncode": self.returncode,
+            "duration_ms": self.duration_ms,
+            "agent_index": self.agent_index,
+        }
+        if self.message is not None:
+            payload["message"] = self.message
+        if self.raw is not None:
+            payload["raw"] = self.raw
+        return payload
+
+
 class CLIAdapter(Protocol):
     """Protocol for CLI backend adapters."""
 

moonbridge/adapters/codex.py

@@ -55,6 +55,7 @@ class CodexAdapter:
             "gpt-5.1-codex-mini",
             "gpt-5.1-codex-max",
         ),
+        default_timeout=1800,  # 30 minutes - Codex runs long
     )
 
     def build_command(

moonbridge/adapters/kimi.py

@@ -38,6 +38,7 @@ class KimiAdapter:
         install_hint="uv tool install kimi-cli",
         supports_thinking=True,
         known_models=("kimi-k2.5",),
+        default_timeout=600,  # 10 minutes - Kimi is faster
     )
 
     def build_command(

moonbridge/server.py

@@ -1,4 +1,4 @@
-"""MCP server for spawning Kimi K2.5 agents."""
+"""MCP server for spawning AI coding agents."""
 
 from __future__ import annotations
 
@@ -19,6 +19,8 @@ from mcp.server.stdio import stdio_server
 from mcp.types import TextContent, Tool
 
 from moonbridge.adapters import ADAPTER_REGISTRY, CLIAdapter, get_adapter
+from moonbridge.adapters.base import AgentResult
+from moonbridge.tools import build_tools
 
 server = Server("moonbridge")
 
@@ -71,8 +73,20 @@ def _safe_env(adapter: CLIAdapter) -> dict[str, str]:
     return env
 
 
-def _validate_timeout(timeout_seconds: int | None) -> int:
-    value = DEFAULT_TIMEOUT if timeout_seconds is None else int(timeout_seconds)
+def _resolve_timeout(adapter: CLIAdapter, timeout_seconds: int | None) -> int:
+    """Resolve timeout: explicit > adapter-env > adapter-default > global."""
+    if timeout_seconds is not None:
+        value = int(timeout_seconds)
+    else:
+        # Check adapter-specific env var first
+        env_key = f"MOONBRIDGE_{adapter.config.name.upper()}_TIMEOUT"
+        if env_val := os.environ.get(env_key):
+            value = int(env_val)
+        elif adapter.config.default_timeout != 600:
+            # Use adapter default if explicitly set (not the base default)
+            value = adapter.config.default_timeout
+        else:
+            value = DEFAULT_TIMEOUT
     if value < 30 or value > 3600:
         raise ValueError("timeout_seconds must be between 30 and 3600")
     return value
@@ -180,29 +194,6 @@ def _auth_error(stderr: str | None, adapter: CLIAdapter) -> bool:
     return any(pattern in lowered for pattern in adapter.config.auth_patterns)
 
 
-def _result(
-    *,
-    status: str,
-    output: str,
-    stderr: str | None,
-    returncode: int,
-    duration_ms: int,
-    agent_index: int,
-    message: str | None = None,
-) -> dict[str, Any]:
-    payload: dict[str, Any] = {
-        "status": status,
-        "output": output,
-        "stderr": stderr,
-        "returncode": returncode,
-        "duration_ms": duration_ms,
-        "agent_index": agent_index,
-    }
-    if message is not None:
-        payload["message"] = message
-    return payload
-
-
 def _run_cli_sync(
     adapter: CLIAdapter,
     prompt: str,
@@ -212,7 +203,7 @@ def _run_cli_sync(
     agent_index: int,
     model: str | None = None,
     reasoning_effort: str | None = None,
-) -> dict[str, Any]:
+) -> AgentResult:
     start = time.monotonic()
     cmd = adapter.build_command(prompt, thinking, model, reasoning_effort)
     logger.debug("Spawning agent with prompt: %s...", prompt[:100])
@@ -229,7 +220,7 @@ def _run_cli_sync(
     except FileNotFoundError:
         duration_ms = int((time.monotonic() - start) * 1000)
         logger.error("%s CLI not found or not executable", adapter.config.name)
-        return _result(
+        return AgentResult(
             status="error",
             output="",
             stderr=f"{adapter.config.name} CLI not found or not executable",
@@ -240,7 +231,7 @@ def _run_cli_sync(
     except PermissionError as exc:
         duration_ms = int((time.monotonic() - start) * 1000)
         logger.error("Permission denied starting process: %s", exc)
-        return _result(
+        return AgentResult(
             status="error",
             output="",
             stderr=f"Permission denied: {exc}",
@@ -251,7 +242,7 @@ def _run_cli_sync(
     except OSError as exc:
         duration_ms = int((time.monotonic() - start) * 1000)
         logger.error("Failed to start process: %s", exc)
-        return _result(
+        return AgentResult(
             status="error",
             output="",
             stderr=f"Failed to start process: {exc}",
@@ -266,7 +257,7 @@ def _run_cli_sync(
         stderr_value = stderr or None
         if _auth_error(stderr_value, adapter):
             logger.info("Agent %s completed with status: auth_error", agent_index)
-            return _result(
+            return AgentResult(
                 status="auth_error",
                 output=stdout,
                 stderr=stderr_value,
@@ -277,7 +268,7 @@ def _run_cli_sync(
             )
         status = "success" if proc.returncode == 0 else "error"
         logger.info("Agent %s completed with status: %s", agent_index, status)
-        return _result(
+        return AgentResult(
             status=status,
             output=stdout,
             stderr=stderr_value,
@@ -289,7 +280,7 @@ def _run_cli_sync(
         _terminate_process(proc)
         duration_ms = int((time.monotonic() - start) * 1000)
         logger.warning("Agent %s timed out after %s seconds", agent_index, timeout_seconds)
-        return _result(
+        return AgentResult(
             status="timeout",
             output="",
             stderr=None,
@@ -301,7 +292,7 @@ def _run_cli_sync(
         _terminate_process(proc)
         duration_ms = int((time.monotonic() - start) * 1000)
         logger.error("Agent %s failed with error: %s", agent_index, exc)
-        return _result(
+        return AgentResult(
             status="error",
             output="",
             stderr=str(exc),
@@ -328,14 +319,18 @@ def _status_check(cwd: str, adapter: CLIAdapter) -> dict[str, Any]:
         }
     timeout = min(DEFAULT_TIMEOUT, 60)
     result = _run_cli_sync(adapter, "status check", False, cwd, timeout, 0)
-    if result["status"] == "auth_error":
+    if result.status == "auth_error":
         return {"status": "auth_error", "message": adapter.config.auth_message}
-    if result["status"] == "success":
+    if result.status == "success":
         return {
             "status": "success",
             "message": f"{adapter.config.name} CLI available and authenticated",
         }
-    return {"status": "error", "message": f"{adapter.config.name} CLI error", "details": result}
+    return {
+        "status": "error",
+        "message": f"{adapter.config.name} CLI error",
+        "details": result.to_dict(),
+    }
 
 
 def _adapter_info(cwd: str, adapter: CLIAdapter) -> dict[str, Any]:
@@ -344,7 +339,7 @@ def _adapter_info(cwd: str, adapter: CLIAdapter) -> dict[str, Any]:
     if installed:
         timeout = min(DEFAULT_TIMEOUT, 60)
         result = _run_cli_sync(adapter, "status check", False, cwd, timeout, 0)
-        authenticated = result["status"] == "success"
+        authenticated = result.status == "success"
     return {
         "name": adapter.config.name,
         "description": adapter.config.tool_description,
@@ -359,112 +354,13 @@ def _adapter_info(cwd: str, adapter: CLIAdapter) -> dict[str, Any]:
 async def list_tools() -> list[Tool]:
     adapter = get_adapter()
     tool_desc = adapter.config.tool_description
-    parallel_desc = f"{tool_desc} Run multiple agents in parallel."
     status_desc = f"Verify {adapter.config.name} CLI is installed and authenticated"
-    adapter_schema = {
-        "type": "string",
-        "enum": list(ADAPTER_REGISTRY.keys()),
-        "description": "Backend to use (kimi, codex). Defaults to MOONBRIDGE_ADAPTER env or kimi.",
-    }
-    return [
-        Tool(
-            name="spawn_agent",
-            description=tool_desc,
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "prompt": {
-                        "type": "string",
-                        "description": "Instructions for the agent (task, context, constraints)",
-                    },
-                    "adapter": adapter_schema,
-                    "thinking": {
-                        "type": "boolean",
-                        "description": "Enable extended reasoning mode for complex tasks",
-                        "default": False,
-                    },
-                    "timeout_seconds": {
-                        "type": "integer",
-                        "description": "Max execution time (30-3600s)",
-                        "default": DEFAULT_TIMEOUT,
-                        "minimum": 30,
-                        "maximum": 3600,
-                    },
-                    "model": {
-                        "type": "string",
-                        "description": (
-                            "Model to use (e.g., 'gpt-5.2-codex', 'kimi-k2.5'). "
-                            "Falls back to MOONBRIDGE_{ADAPTER}_MODEL or MOONBRIDGE_MODEL env vars."
-                        ),
-                    },
-                    "reasoning_effort": {
-                        "type": "string",
-                        "enum": ["low", "medium", "high", "xhigh"],
-                        "description": (
-                            "Reasoning effort for Codex (low, medium, high, xhigh). "
-                            "Ignored for Kimi (use thinking instead)."
-                        ),
-                    },
-                },
-                "required": ["prompt"],
-            },
-        ),
-        Tool(
-            name="spawn_agents_parallel",
-            description=parallel_desc,
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "agents": {
-                        "type": "array",
-                        "description": "List of agent specs with prompt and optional settings",
-                        "items": {
-                            "type": "object",
-                            "properties": {
-                                "prompt": {"type": "string"},
-                                "adapter": adapter_schema,
-                                "thinking": {"type": "boolean", "default": False},
-                                "timeout_seconds": {
-                                    "type": "integer",
-                                    "description": "Max execution time (30-3600s)",
-                                    "default": DEFAULT_TIMEOUT,
-                                    "minimum": 30,
-                                    "maximum": 3600,
-                                },
-                                "model": {
-                                    "type": "string",
-                                    "description": (
-                                        "Model to use. Falls back to "
-                                        "MOONBRIDGE_{ADAPTER}_MODEL or MOONBRIDGE_MODEL env vars."
-                                    ),
-                                },
-                                "reasoning_effort": {
-                                    "type": "string",
-                                    "enum": ["low", "medium", "high", "xhigh"],
-                                    "description": (
-                                        "Reasoning effort for Codex (low, medium, high, xhigh). "
-                                        "Ignored for Kimi."
-                                    ),
-                                },
-                            },
-                            "required": ["prompt"],
-                        },
-                    },
-                },
-                "required": ["agents"],
-            },
-        ),
-        Tool(
-            name="list_adapters",
-            description="List available adapters and their status",
-            inputSchema={"type": "object", "properties": {}},
-        ),
-        Tool(
-            name="check_status",
-            description=status_desc,
-            inputSchema={"type": "object", "properties": {}},
-        ),
-    ]
+    return build_tools(
+        adapter_names=tuple(ADAPTER_REGISTRY.keys()),
+        default_timeout=DEFAULT_TIMEOUT,
+        tool_description=tool_desc,
+        status_description=status_desc,
+    )
 
 
 async def handle_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
@@ -475,7 +371,7 @@ async def handle_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]
             adapter = get_adapter(arguments.get("adapter"))
             prompt = _validate_prompt(arguments["prompt"])
             thinking = _validate_thinking(adapter, bool(arguments.get("thinking", False)))
-            timeout_seconds = _validate_timeout(arguments.get("timeout_seconds"))
+            timeout_seconds = _resolve_timeout(adapter, arguments.get("timeout_seconds"))
             model = _resolve_model(adapter, arguments.get("model"))
             reasoning_effort = arguments.get("reasoning_effort")
             loop = asyncio.get_running_loop()
@@ -494,16 +390,16 @@ async def handle_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]
                 )
             except asyncio.CancelledError:
                 return _json_text(
-                    _result(
+                    AgentResult(
                         status="cancelled",
                         output="",
                         stderr=None,
                         returncode=-1,
                         duration_ms=0,
                         agent_index=0,
-                    )
+                    ).to_dict()
                 )
-            return _json_text(result)
+            return _json_text(result.to_dict())
 
         if name == "spawn_agents_parallel":
             agents = list(arguments["agents"])
@@ -525,7 +421,7 @@ async def handle_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]
                         prompt,
                         thinking,
                         cwd,
-                        _validate_timeout(spec.get("timeout_seconds")),
+                        _resolve_timeout(adapter, spec.get("timeout_seconds")),
                         idx,
                         model,
                         reasoning_effort,
@@ -535,7 +431,7 @@ async def handle_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]
                 results = await asyncio.gather(*tasks)
             except asyncio.CancelledError:
                 cancelled = [
-                    _result(
+                    AgentResult(
                         status="cancelled",
                         output="",
                         stderr=None,
@@ -545,9 +441,9 @@ async def handle_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]
                     )
                     for idx in range(len(agents))
                 ]
-                return _json_text(cancelled)
-            results.sort(key=lambda item: item["agent_index"])
-            return _json_text(results)
+                return _json_text([item.to_dict() for item in cancelled])
+            results.sort(key=lambda item: item.agent_index)
+            return _json_text([item.to_dict() for item in results])
 
         if name == "list_adapters":
             info = [_adapter_info(cwd, adapter) for adapter in ADAPTER_REGISTRY.values()]

moonbridge/tools.py

@@ -0,0 +1,334 @@
+"""Tool schema definitions for Moonbridge MCP server.
+
+This module provides dataclasses and functions for defining MCP tool schemas
+in a reusable, type-safe manner.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from mcp.types import Tool
+
+
+@dataclass(frozen=True)
+class ParameterDef:
+    """Definition for a JSON Schema parameter."""
+
+    type: str  # "string", "integer", "boolean", "array"
+    description: str
+    default: Any = None
+    enum: tuple[str, ...] | None = None
+    minimum: int | None = None
+    maximum: int | None = None
+    items: dict[str, Any] | None = None  # For array types
+
+
+@dataclass(frozen=True)
+class ToolDef:
+    """Definition for an MCP tool."""
+
+    name: str
+    description_template: str  # May contain {adapter} placeholder
+    parameters: tuple[tuple[str, ParameterDef], ...]  # Ordered (name, param) pairs
+    required: tuple[str, ...] = ()
+
+
+# =============================================================================
+# Reusable parameter definitions
+# =============================================================================
+
+PROMPT_PARAM = ParameterDef(
+    type="string",
+    description="Instructions for the agent (task, context, constraints)",
+)
+
+# Note: ADAPTER_PARAM enum is populated dynamically via build_adapter_param()
+ADAPTER_PARAM_BASE = ParameterDef(
+    type="string",
+    description="Backend to use (kimi, codex). Defaults to MOONBRIDGE_ADAPTER env or kimi.",
+    # enum is set dynamically
+)
+
+THINKING_PARAM = ParameterDef(
+    type="boolean",
+    description="Enable extended reasoning mode for complex tasks",
+    default=False,
+)
+
+# Note: TIMEOUT_PARAM default is populated dynamically
+TIMEOUT_PARAM_BASE = ParameterDef(
+    type="integer",
+    description=(
+        "Max execution time (30-3600s). "
+        "Defaults: Codex=1800s (30min), Kimi=600s (10min). "
+        "Complex implementations may need full 30min+."
+    ),
+    minimum=30,
+    maximum=3600,
+    # default is set dynamically
+)
+
+MODEL_PARAM = ParameterDef(
+    type="string",
+    description=(
+        "Model to use (e.g., 'gpt-5.2-codex', 'kimi-k2.5'). "
+        "Falls back to MOONBRIDGE_{ADAPTER}_MODEL or MOONBRIDGE_MODEL env vars."
+    ),
+)
+
+# Shorter model description for nested items
+MODEL_PARAM_SHORT = ParameterDef(
+    type="string",
+    description=(
+        "Model to use. Falls back to "
+        "MOONBRIDGE_{ADAPTER}_MODEL or MOONBRIDGE_MODEL env vars."
+    ),
+)
+
+REASONING_EFFORT_PARAM = ParameterDef(
+    type="string",
+    description=(
+        "Reasoning effort for Codex (low, medium, high, xhigh). "
+        "Ignored for Kimi (use thinking instead)."
+    ),
+    enum=("low", "medium", "high", "xhigh"),
+)
+
+# Shorter reasoning_effort description for nested items
+REASONING_EFFORT_PARAM_SHORT = ParameterDef(
+    type="string",
+    description=(
+        "Reasoning effort for Codex (low, medium, high, xhigh). "
+        "Ignored for Kimi."
+    ),
+    enum=("low", "medium", "high", "xhigh"),
+)
+
+
+# =============================================================================
+# Helper functions for dynamic parameter creation
+# =============================================================================
+
+
+def _build_adapter_param(adapter_names: tuple[str, ...]) -> ParameterDef:
+    """Create adapter parameter with dynamic enum."""
+    return ParameterDef(
+        type="string",
+        description=ADAPTER_PARAM_BASE.description,
+        enum=adapter_names,
+    )
+
+
+def _build_timeout_param(default_timeout: int) -> ParameterDef:
+    """Create timeout parameter with dynamic default.
+
+    Raises:
+        ValueError: If default_timeout is outside the valid range.
+    """
+    min_timeout = TIMEOUT_PARAM_BASE.minimum
+    max_timeout = TIMEOUT_PARAM_BASE.maximum
+    if min_timeout is not None and default_timeout < min_timeout:
+        raise ValueError(f"default_timeout must be >= {min_timeout}, got {default_timeout}")
+    if max_timeout is not None and default_timeout > max_timeout:
+        raise ValueError(f"default_timeout must be <= {max_timeout}, got {default_timeout}")
+    return ParameterDef(
+        type="integer",
+        description=TIMEOUT_PARAM_BASE.description,
+        default=default_timeout,
+        minimum=min_timeout,
+        maximum=max_timeout,
+    )
+
+
+# =============================================================================
+# Tool definitions
+# =============================================================================
+
+SPAWN_AGENT_TOOL = ToolDef(
+    name="spawn_agent",
+    description_template="{tool_description}",
+    parameters=(
+        ("prompt", PROMPT_PARAM),
+        ("adapter", ADAPTER_PARAM_BASE),  # Will be replaced with dynamic version
+        ("thinking", THINKING_PARAM),
+        ("timeout_seconds", TIMEOUT_PARAM_BASE),  # Will be replaced with dynamic version
+        ("model", MODEL_PARAM),
+        ("reasoning_effort", REASONING_EFFORT_PARAM),
+    ),
+    required=("prompt",),
+)
+
+SPAWN_AGENTS_PARALLEL_TOOL = ToolDef(
+    name="spawn_agents_parallel",
+    description_template="{tool_description} Run multiple agents in parallel.",
+    parameters=(),  # Handled specially due to array items
+    required=("agents",),
+)
+
+LIST_ADAPTERS_TOOL = ToolDef(
+    name="list_adapters",
+    description_template="List available adapters and their status",
+    parameters=(),
+    required=(),
+)
+
+CHECK_STATUS_TOOL = ToolDef(
+    name="check_status",
+    description_template="{status_description}",
+    parameters=(),
+    required=(),
+)
+
+
+# =============================================================================
+# Schema generation functions
+# =============================================================================
+
+
+def _param_to_schema(param: ParameterDef) -> dict[str, Any]:
+    """Convert a ParameterDef to a JSON Schema dict."""
+    schema: dict[str, Any] = {"type": param.type}
+
+    if param.description:
+        schema["description"] = param.description
+    if param.default is not None:
+        schema["default"] = param.default
+    if param.enum is not None:
+        schema["enum"] = list(param.enum)
+    if param.minimum is not None:
+        schema["minimum"] = param.minimum
+    if param.maximum is not None:
+        schema["maximum"] = param.maximum
+    if param.items is not None:
+        schema["items"] = param.items
+
+    return schema
+
+
+def build_input_schema(
+    tool: ToolDef,
+    adapter_names: tuple[str, ...],
+    default_timeout: int,
+) -> dict[str, Any]:
+    """Convert ToolDef to MCP inputSchema dict.
+
+    Args:
+        tool: The tool definition to convert.
+        adapter_names: Tuple of available adapter names for enum.
+        default_timeout: Default timeout value for timeout parameters.
+
+    Returns:
+        A JSON Schema dict suitable for MCP Tool.inputSchema.
+    """
+    properties: dict[str, Any] = {}
+
+    for name, param in tool.parameters:
+        # Handle dynamic parameters
+        if name == "adapter":
+            param = _build_adapter_param(adapter_names)
+        elif name == "timeout_seconds":
+            param = _build_timeout_param(default_timeout)
+
+        properties[name] = _param_to_schema(param)
+
+    schema: dict[str, Any] = {
+        "type": "object",
+        "properties": properties,
+    }
+
+    if tool.required:
+        schema["required"] = list(tool.required)
+
+    return schema
+
+
+def _build_agents_array_schema(
+    adapter_names: tuple[str, ...],
+    default_timeout: int,
+) -> dict[str, Any]:
+    """Build the schema for the agents array in spawn_agents_parallel."""
+    adapter_schema = _param_to_schema(_build_adapter_param(adapter_names))
+    timeout_schema = _param_to_schema(_build_timeout_param(default_timeout))
+
+    return {
+        "type": "array",
+        "description": "List of agent specs with prompt and optional settings",
+        "items": {
+            "type": "object",
+            "properties": {
+                "prompt": {"type": "string"},
+                "adapter": adapter_schema,
+                "thinking": {"type": "boolean", "default": False},
+                "timeout_seconds": timeout_schema,
+                "model": _param_to_schema(MODEL_PARAM_SHORT),
+                "reasoning_effort": _param_to_schema(REASONING_EFFORT_PARAM_SHORT),
+            },
+            "required": ["prompt"],
+        },
+    }
+
+
+def build_tools(
+    adapter_names: tuple[str, ...],
+    default_timeout: int,
+    tool_description: str,
+    status_description: str,
+) -> list[Tool]:
+    """Build all MCP Tool objects from definitions.
+
+    Args:
+        adapter_names: Tuple of available adapter names.
+        default_timeout: Default timeout value in seconds.
+        tool_description: Description for the spawn_agent tool.
+        status_description: Description for the check_status tool.
+
+    Returns:
+        List of MCP Tool objects ready for registration.
+    """
+    # spawn_agent
+    spawn_agent_schema = build_input_schema(
+        SPAWN_AGENT_TOOL, adapter_names, default_timeout
+    )
+
+    # spawn_agents_parallel (special handling for array)
+    parallel_schema: dict[str, Any] = {
+        "type": "object",
+        "properties": {
+            "agents": _build_agents_array_schema(adapter_names, default_timeout),
+        },
+        "required": ["agents"],
+    }
+
+    # list_adapters
+    list_adapters_schema: dict[str, Any] = {"type": "object", "properties": {}}
+
+    # check_status
+    check_status_schema: dict[str, Any] = {"type": "object", "properties": {}}
+
+    return [
+        Tool(
+            name="spawn_agent",
+            description=tool_description,
+            inputSchema=spawn_agent_schema,
+        ),
+        Tool(
+            name="spawn_agents_parallel",
+            description=f"{tool_description} Run multiple agents in parallel.",
+            inputSchema=parallel_schema,
+        ),
+        Tool(
+            name="list_adapters",
+            description="List available adapters and their status",
+            inputSchema=list_adapters_schema,
+        ),
+        Tool(
+            name="check_status",
+            description=status_description,
+            inputSchema=check_status_schema,
+        ),
+    ]
+
+
+__all__ = ["build_tools"]

{moonbridge-0.5.2.dist-info → moonbridge-0.6.0.dist-info}/METADATA

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: moonbridge
-Version: 0.5.2
-Summary: MCP server for spawning Kimi K2.5 agents
+Version: 0.6.0
+Summary: MCP server for spawning AI coding agents (Kimi, Codex, and more)
 Project-URL: Homepage, https://github.com/misty-step/moonbridge
 Project-URL: Repository, https://github.com/misty-step/moonbridge
 Project-URL: Issues, https://github.com/misty-step/moonbridge/issues
 Author-email: Phaedrus <hello@mistystep.io>
 License-Expression: MIT
 License-File: LICENSE
-Keywords: agent,ai,claude,kimi,mcp
+Keywords: agent,ai,claude,codex,kimi,mcp
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -31,7 +31,7 @@ Description-Content-Type: text/markdown
 
 **Your MCP client just got a team.**
 
-Spawn Kimi K2.5 agents from Claude Code, Cursor, or any MCP client. Run 10 approaches in parallel for the cost of one Claude request.
+Spawn AI coding agents from Claude Code, Cursor, or any MCP client. Run 10 approaches in parallel for a fraction of the cost.
 
 ```bash
 uvx moonbridge
@@ -39,10 +39,12 @@ uvx moonbridge
 
 ## Quick Start
 
-1. **Install Kimi CLI and authenticate:**
-   ```bash
-   uv tool install --python 3.13 kimi-cli && kimi login
-   ```
+1. **Install at least one supported CLI:**
+
+   | Adapter | Install | Authenticate |
+   |---------|---------|--------------|
+   | Kimi (default) | `uv tool install --python 3.13 kimi-cli` | `kimi login` |
+   | Codex | `npm install -g @openai/codex` | Set `OPENAI_API_KEY` |
 
 2. **Add to MCP config** (`~/.mcp.json`):
    ```json
@@ -94,7 +96,8 @@ export MOONBRIDGE_SKIP_UPDATE_CHECK=1
 |------|----------|
 | `spawn_agent` | Single task: "Write tests for auth.ts" |
 | `spawn_agents_parallel` | Go wide: 10 agents, 10 approaches, pick the best |
-| `check_status` | Verify Kimi CLI is installed and authenticated |
+| `check_status` | Verify the configured CLI is installed and authenticated |
+| `list_adapters` | Show available adapters and their status |
 
 ### Example: Parallel Exploration
 
@@ -117,7 +120,10 @@ Three approaches. One request. You choose the winner.
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
 | `prompt` | string | Yes | Task description for the agent |
-| `thinking` | boolean | No | Enable reasoning mode (default: false) |
+| `adapter` | string | No | Backend to use: `kimi`, `codex` (default: `kimi`) |
+| `model` | string | No | Model override (e.g., `gpt-5.2-codex`) |
+| `thinking` | boolean | No | Enable reasoning mode (Kimi only) |
+| `reasoning_effort` | string | No | Reasoning budget: `low`, `medium`, `high`, `xhigh` (Codex only) |
 | `timeout_seconds` | integer | No | Override default timeout (30-3600) |
 
 **`spawn_agents_parallel`**
@@ -126,7 +132,10 @@ Three approaches. One request. You choose the winner.
 |-----------|------|----------|-------------|
 | `agents` | array | Yes | List of agent configs (max 10) |
 | `agents[].prompt` | string | Yes | Task for this agent |
-| `agents[].thinking` | boolean | No | Enable reasoning for this agent |
+| `agents[].adapter` | string | No | Backend for this agent |
+| `agents[].model` | string | No | Model override for this agent |
+| `agents[].thinking` | boolean | No | Enable reasoning (Kimi only) |
+| `agents[].reasoning_effort` | string | No | Reasoning budget (Codex only) |
 | `agents[].timeout_seconds` | integer | No | Timeout for this agent |
 
 ## Response Format
@@ -136,7 +145,7 @@ All tools return JSON with these fields:
 | Field | Type | Description |
 |-------|------|-------------|
 | `status` | string | `success`, `error`, `timeout`, `auth_error`, or `cancelled` |
-| `output` | string | stdout from Kimi agent |
+| `output` | string | stdout from the agent |
 | `stderr` | string\|null | stderr if any |
 | `returncode` | int | Process exit code (-1 for timeout/error) |
 | `duration_ms` | int | Execution time in milliseconds |
@@ -158,37 +167,60 @@ All tools return JSON with these fields:
 
 ## Troubleshooting
 
-### "Kimi CLI not found"
+### "CLI not found"
 
-Install the Kimi CLI:
+Install the CLI for your chosen adapter:
 
 ```bash
+# Kimi
 uv tool install --python 3.13 kimi-cli
 which kimi
+
+# Codex
+npm install -g @openai/codex
+which codex
 ```
 
 ### "auth_error" responses
 
-Authenticate with Kimi:
+Authenticate with your chosen CLI:
 
 ```bash
+# Kimi
 kimi login
+
+# Codex
+export OPENAI_API_KEY=sk-...
 ```
 
 ### Timeout errors
 
-Increase the timeout for long-running tasks:
+Adapters have sensible defaults: Codex=1800s (30min), Kimi=600s (10min).
+
+For exceptionally long tasks, override explicitly:
 
 ```json
-{"prompt": "...", "timeout_seconds": 1800}
+{"prompt": "...", "timeout_seconds": 3600}
 ```
 
-Or set a global default:
+Or set per-adapter defaults via environment:
 
 ```bash
-export MOONBRIDGE_TIMEOUT=1800
+export MOONBRIDGE_CODEX_TIMEOUT=2400  # 40 minutes
+export MOONBRIDGE_KIMI_TIMEOUT=900    # 15 minutes
 ```
 
+## Timeout Best Practices
+
+| Task Type | Recommended |
+|-----------|-------------|
+| Quick query, status | 60-180s |
+| Simple edits | 300-600s |
+| Feature implementation | 1200-1800s |
+| Large refactor | 1800-3600s |
+
+Priority resolution: explicit param > adapter env > adapter default > global env > 600s fallback
+
 ### "MOONBRIDGE_ALLOWED_DIRS is not set" warning
 
 By default, Moonbridge warns at startup if no directory restrictions are configured. This is expected for local development. For shared/production environments, set allowed directories:

moonbridge-0.6.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+moonbridge/__init__.py,sha256=K5-NRJiYdFbIITQmjIg3_Fkef0UEWhe2hqO3rJ0MZII,198
+moonbridge/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+moonbridge/server.py,sha256=o-u0J-HsVoa7sxaweWPHo_iHDXJfao16eDFe_9bm6RA,17071
+moonbridge/tools.py,sha256=uw338Dilrto2t5dL9XbK4O31-JdB7Vh9RqCXHg20gHI,10126
+moonbridge/version_check.py,sha256=VQueK0O_b-2Xc-XjupJsoW3Zs1Kce5q_BgqBhANGXN8,4579
+moonbridge/adapters/__init__.py,sha256=w3pLvjtC2XnUhf9UzNmniQB3oq4rG8gorSH0tWR-BEE,988
+moonbridge/adapters/base.py,sha256=REoEsAcqEvyVQpTgz6ytd9ioxag--nnvX90YBXMQG8Y,1716
+moonbridge/adapters/codex.py,sha256=GtU4CrJ4zt0WDcKKaOeN7gH4JFIBAo3L7KAZ99zRjiY,2935
+moonbridge/adapters/kimi.py,sha256=ejCxG2OGr0Qr4n0psL6p96_mMJ3lLKMbGcNYWkuC0uA,2189
+moonbridge-0.6.0.dist-info/METADATA,sha256=nJndtrv2GuSSPeNrV6ryJa6-82viUtankQXduB6Nkn4,7298
+moonbridge-0.6.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+moonbridge-0.6.0.dist-info/entry_points.txt,sha256=kgL38HQy3adncDQl_o5sdtPRog56zKdHk6pKKzyR6Ww,54
+moonbridge-0.6.0.dist-info/licenses/LICENSE,sha256=7WMSJoybL2cUot_wb9GUrw5mzfFmtrDzqlMS9ZE709g,1065
+moonbridge-0.6.0.dist-info/RECORD,,

moonbridge-0.5.2.dist-info/RECORD

@@ -1,13 +0,0 @@
-moonbridge/__init__.py,sha256=x3eYCVqjhWKoPmGJvOV3IALPoS1DFO-iZRECuVbNgtQ,198
-moonbridge/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-moonbridge/server.py,sha256=rP3c0hcuUDxC5QqPNWboJZYnMS4hZw6oqkzmg-N0WwM,21194
-moonbridge/version_check.py,sha256=VQueK0O_b-2Xc-XjupJsoW3Zs1Kce5q_BgqBhANGXN8,4579
-moonbridge/adapters/__init__.py,sha256=w3pLvjtC2XnUhf9UzNmniQB3oq4rG8gorSH0tWR-BEE,988
-moonbridge/adapters/base.py,sha256=bj_Ms55h2lwDmEO0CZ1RFSAA9IHgNbX2LI1xgQEftLY,942
-moonbridge/adapters/codex.py,sha256=JTt9B3eXqset6ZrwwlnHzcno5PMdrjY2GdLSNPYkowQ,2873
-moonbridge/adapters/kimi.py,sha256=75QFPTMVpgbgkVGv8GEpIYY1zrIOZ0kJ-aCgd8Tx0TA,2129
-moonbridge-0.5.2.dist-info/METADATA,sha256=aaN1N00Q5oY2bE6faQWW163_goAPVMQDtEEWTlkUnBE,5984
-moonbridge-0.5.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-moonbridge-0.5.2.dist-info/entry_points.txt,sha256=kgL38HQy3adncDQl_o5sdtPRog56zKdHk6pKKzyR6Ww,54
-moonbridge-0.5.2.dist-info/licenses/LICENSE,sha256=7WMSJoybL2cUot_wb9GUrw5mzfFmtrDzqlMS9ZE709g,1065
-moonbridge-0.5.2.dist-info/RECORD,,