gobby 0.2.5__py3-none-any.whl → 0.2.6__py3-none-any.whl

gobby/servers/routes/mcp/tools.py

@@ -7,6 +7,7 @@ Uses FastAPI dependency injection via Depends() for proper testability.
 
 import json
 import logging
+import re
 import time
 from typing import TYPE_CHECKING, Any
 
@@ -29,6 +30,81 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+def _process_tool_proxy_result(
+    result: Any,
+    server_name: str,
+    tool_name: str,
+    response_time_ms: float,
+    metrics_collector: Any,
+) -> dict[str, Any]:
+    """
+    Process tool proxy result with consistent metrics, logging, and error handling.
+
+    Args:
+        result: The result from tool_proxy.call_tool()
+        server_name: Name of the MCP server
+        tool_name: Name of the tool called
+        response_time_ms: Response time in milliseconds
+        metrics_collector: Metrics collector instance
+
+    Returns:
+        Wrapped result dict with success status and response time
+
+    Raises:
+        HTTPException: 404 if server not found/not configured
+    """
+    # Track metrics for tool-level failures vs successes
+    if isinstance(result, dict) and result.get("success") is False:
+        metrics_collector.inc_counter("mcp_tool_calls_failed_total")
+
+        # Check structured error code first (preferred)
+        error_code = result.get("error_code")
+        if error_code in ("SERVER_NOT_FOUND", "SERVER_NOT_CONFIGURED"):
+            # Normalize result to standard error shape while preserving existing fields
+            normalized = {"success": False, "error": result.get("error", "Unknown error")}
+            for key, value in result.items():
+                if key not in normalized:
+                    normalized[key] = value
+            raise HTTPException(status_code=404, detail=normalized)
+
+        # Backward compatibility: fall back to regex matching if no error_code
+        if not error_code:
+            logger.debug(
+                "ToolProxyService returned error without error_code - using regex fallback"
+            )
+            error_msg = str(result.get("error", ""))
+            if re.search(r"server\s+(not\s+found|not\s+configured)", error_msg, re.IGNORECASE):
+                normalized = {"success": False, "error": result.get("error", "Unknown error")}
+                for key, value in result.items():
+                    if key not in normalized:
+                        normalized[key] = value
+                raise HTTPException(status_code=404, detail=normalized)
+
+        # Tool-level failure (not a transport error) - return failure envelope
+        return {
+            "success": False,
+            "result": result,
+            "response_time_ms": response_time_ms,
+        }
+    else:
+        metrics_collector.inc_counter("mcp_tool_calls_succeeded_total")
+        logger.debug(
+            f"MCP tool call successful: {server_name}.{tool_name}",
+            extra={
+                "server": server_name,
+                "tool": tool_name,
+                "response_time_ms": response_time_ms,
+            },
+        )
+
+    # Return 200 with wrapped result for success cases
+    return {
+        "success": True,
+        "result": result,
+        "response_time_ms": response_time_ms,
+    }
+
+
 def create_mcp_router() -> APIRouter:
     """
     Create MCP router with endpoints using dependency injection.
@@ -74,25 +150,39 @@ def create_mcp_router() -> APIRouter:
                         "response_time_ms": response_time_ms,
                     }
                 raise HTTPException(
-                    status_code=404, detail=f"Internal server '{server_name}' not found"
+                    status_code=404,
+                    detail={
+                        "success": False,
+                        "error": f"Internal server '{server_name}' not found",
+                    },
                 )
 
             if mcp_manager is None:
-                raise HTTPException(status_code=503, detail="MCP manager not available")
+                raise HTTPException(
+                    status_code=503, detail={"success": False, "error": "MCP manager not available"}
+                )
 
             # Check if server is configured
             if not mcp_manager.has_server(server_name):
-                raise HTTPException(status_code=404, detail=f"Unknown MCP server: '{server_name}'")
+                raise HTTPException(
+                    status_code=404,
+                    detail={"success": False, "error": f"Unknown MCP server: '{server_name}'"},
+                )
 
             # Use ensure_connected for lazy loading - connects on-demand if not connected
             try:
                 session = await mcp_manager.ensure_connected(server_name)
             except KeyError as e:
-                raise HTTPException(status_code=404, detail=str(e)) from e
+                raise HTTPException(
+                    status_code=404, detail={"success": False, "error": str(e)}
+                ) from e
             except Exception as e:
                 raise HTTPException(
                     status_code=503,
-                    detail=f"MCP server '{server_name}' connection failed: {e}",
+                    detail={
+                        "success": False,
+                        "error": f"MCP server '{server_name}' connection failed: {e}",
+                    },
                 ) from e
 
             # List tools using MCP SDK
@@ -143,14 +233,17 @@ def create_mcp_router() -> APIRouter:
                     exc_info=True,
                     extra={"server": server_name},
                 )
-                raise HTTPException(status_code=500, detail=f"Failed to list tools: {e}") from e
+                raise HTTPException(
+                    status_code=500,
+                    detail={"success": False, "error": f"Failed to list tools: {e}"},
+                ) from e
 
         except HTTPException:
             raise
         except Exception as e:
             metrics.inc_counter("http_requests_errors_total")
             logger.error(f"MCP list tools error: {server_name}", exc_info=True)
-            raise HTTPException(status_code=500, detail=str(e)) from e
+            raise HTTPException(status_code=500, detail={"success": False, "error": str(e)}) from e
 
     @router.get("/servers")
     async def list_mcp_servers(
@@ -212,7 +305,7 @@ def create_mcp_router() -> APIRouter:
         except Exception as e:
             metrics.inc_counter("http_requests_errors_total")
             logger.error(f"List MCP servers error: {e}", exc_info=True)
-            raise HTTPException(status_code=500, detail=str(e)) from e
+            raise HTTPException(status_code=500, detail={"success": False, "error": str(e)}) from e
 
     @router.get("/tools")
     async def list_all_mcp_tools(
@@ -341,7 +434,7 @@ def create_mcp_router() -> APIRouter:
         except Exception as e:
             metrics.inc_counter("http_requests_errors_total")
             logger.error(f"List MCP tools error: {e}", exc_info=True)
-            raise HTTPException(status_code=500, detail=str(e)) from e
+            raise HTTPException(status_code=500, detail={"success": False, "error": str(e)}) from e
 
     @router.post("/tools/schema")
     async def get_tool_schema(
@@ -370,7 +463,8 @@ def create_mcp_router() -> APIRouter:
 
             if not server_name or not tool_name:
                 raise HTTPException(
-                    status_code=400, detail="Required fields: server_name, tool_name"
+                    status_code=400,
+                    detail={"success": False, "error": "Required fields: server_name, tool_name"},
                 )
 
             # Check internal first
@@ -388,11 +482,17 @@ def create_mcp_router() -> APIRouter:
                         }
                     raise HTTPException(
                         status_code=404,
-                        detail=f"Tool '{tool_name}' not found on server '{server_name}'",
+                        detail={
+                            "success": False,
+                            "error": f"Tool '{tool_name}' not found on server '{server_name}'",
+                        },
                     )
 
             if server.mcp_manager is None:
-                raise HTTPException(status_code=503, detail="MCP manager not available")
+                raise HTTPException(
+                    status_code=503,
+                    detail={"success": False, "error": "MCP manager not available"},
+                )
 
             # Get from external MCP server
             try:
@@ -406,15 +506,27 @@ def create_mcp_router() -> APIRouter:
                     "response_time_ms": response_time_ms,
                 }
 
+            except (KeyError, ValueError) as e:
+                # Tool or server not found - 404
+                raise HTTPException(
+                    status_code=404, detail={"success": False, "error": str(e)}
+                ) from e
             except Exception as e:
-                raise HTTPException(status_code=404, detail=str(e)) from e
+                # Connection, timeout, or internal errors - 500
+                logger.error(
+                    f"Failed to get tool schema {server_name}/{tool_name}: {e}", exc_info=True
+                )
+                raise HTTPException(
+                    status_code=500,
+                    detail={"success": False, "error": f"Failed to get tool schema: {e}"},
+                ) from e
 
         except HTTPException:
             raise
         except Exception as e:
             metrics.inc_counter("http_requests_errors_total")
             logger.error(f"Get tool schema error: {e}", exc_info=True)
-            raise HTTPException(status_code=500, detail=str(e)) from e
+            raise HTTPException(status_code=500, detail={"success": False, "error": str(e)}) from e
 
     @router.post("/tools/call")
     async def call_mcp_tool(
@@ -446,9 +558,19 @@ def create_mcp_router() -> APIRouter:
 
             if not server_name or not tool_name:
                 raise HTTPException(
-                    status_code=400, detail="Required fields: server_name, tool_name"
+                    status_code=400,
+                    detail={"success": False, "error": "Required fields: server_name, tool_name"},
+                )
+
+            # Route through ToolProxyService for consistent error enrichment
+            if server.tool_proxy:
+                result = await server.tool_proxy.call_tool(server_name, tool_name, arguments)
+                response_time_ms = (time.perf_counter() - start_time) * 1000
+                return _process_tool_proxy_result(
+                    result, server_name, tool_name, response_time_ms, metrics
                 )
 
+            # Fallback: no tool_proxy available, use direct registry calls
             # Check internal first
             if server._internal_manager and server._internal_manager.is_internal(server_name):
                 registry = server._internal_manager.get_registry(server_name)
@@ -458,10 +580,13 @@ def create_mcp_router() -> APIRouter:
                         available = [t["name"] for t in registry.list_tools()]
                         raise HTTPException(
                             status_code=404,
-                            detail=f"Tool '{tool_name}' not found on '{server_name}'. "
-                            f"Available: {', '.join(available)}. "
-                            f"Use list_tools(server='{server_name}') to see all tools, "
-                            f"or get_tool_schema(server_name='{server_name}', tool_name='...') for full schema.",
+                            detail={
+                                "success": False,
+                                "error": f"Tool '{tool_name}' not found on '{server_name}'. "
+                                f"Available: {', '.join(available)}. "
+                                f"Use list_tools(server='{server_name}') to see all tools, "
+                                f"or get_tool_schema(server_name='{server_name}', tool_name='...') for full schema.",
+                            },
                         )
                     try:
                         result = await registry.call(tool_name, arguments or {})
@@ -481,7 +606,10 @@ def create_mcp_router() -> APIRouter:
                         ) from e
 
             if server.mcp_manager is None:
-                raise HTTPException(status_code=503, detail="MCP manager not available")
+                raise HTTPException(
+                    status_code=503,
+                    detail={"success": False, "error": "MCP manager not available"},
+                )
 
             # Call external MCP tool
             try:
@@ -498,7 +626,9 @@ def create_mcp_router() -> APIRouter:
             except Exception as e:
                 metrics.inc_counter("mcp_tool_calls_failed_total")
                 error_msg = str(e) or f"{type(e).__name__}: (no message)"
-                raise HTTPException(status_code=500, detail=error_msg) from e
+                raise HTTPException(
+                    status_code=500, detail={"success": False, "error": error_msg}
+                ) from e
 
         except HTTPException:
             raise
@@ -506,7 +636,9 @@ def create_mcp_router() -> APIRouter:
             metrics.inc_counter("mcp_tool_calls_failed_total")
             error_msg = str(e) or f"{type(e).__name__}: (no message)"
             logger.error(f"Call MCP tool error: {error_msg}", exc_info=True)
-            raise HTTPException(status_code=500, detail=error_msg) from e
+            raise HTTPException(
+                status_code=500, detail={"success": False, "error": error_msg}
+            ) from e
 
     @router.post("/servers")
     async def add_mcp_server(
@@ -535,7 +667,10 @@ def create_mcp_router() -> APIRouter:
             transport = body.get("transport")
 
             if not name or not transport:
-                raise HTTPException(status_code=400, detail="Required fields: name, transport")
+                raise HTTPException(
+                    status_code=400,
+                    detail={"success": False, "error": "Required fields: name, transport"},
+                )
 
             # Import here to avoid circular imports
             from gobby.mcp_proxy.models import MCPServerConfig
@@ -544,7 +679,11 @@ def create_mcp_router() -> APIRouter:
             project_ctx = get_project_context()
             if not project_ctx or not project_ctx.get("id"):
                 raise HTTPException(
-                    status_code=400, detail="No current project found. Run 'gobby init'."
+                    status_code=400,
+                    detail={
+                        "success": False,
+                        "error": "No current project found. Run 'gobby init'.",
+                    },
                 )
             project_id = project_ctx["id"]
 
@@ -561,7 +700,10 @@ def create_mcp_router() -> APIRouter:
             )
 
             if server.mcp_manager is None:
-                raise HTTPException(status_code=503, detail="MCP manager not available")
+                raise HTTPException(
+                    status_code=503,
+                    detail={"success": False, "error": "MCP manager not available"},
+                )
 
             await server.mcp_manager.add_server(config)
 
@@ -571,13 +713,13 @@ def create_mcp_router() -> APIRouter:
             }
 
         except ValueError as e:
-            raise HTTPException(status_code=400, detail=str(e)) from e
+            raise HTTPException(status_code=400, detail={"success": False, "error": str(e)}) from e
         except HTTPException:
             raise
         except Exception as e:
             metrics.inc_counter("http_requests_errors_total")
             logger.error(f"Add MCP server error: {e}", exc_info=True)
-            raise HTTPException(status_code=500, detail=str(e)) from e
+            raise HTTPException(status_code=500, detail={"success": False, "error": str(e)}) from e
 
     @router.post("/servers/import")
     async def import_mcp_server(
@@ -610,7 +752,10 @@ def create_mcp_router() -> APIRouter:
             if not from_project and not github_url and not query:
                 raise HTTPException(
                     status_code=400,
-                    detail="Specify at least one: from_project, github_url, or query",
+                    detail={
+                        "success": False,
+                        "error": "Specify at least one: from_project, github_url, or query",
+                    },
                 )
 
             # Get current project ID from context
@@ -619,12 +764,19 @@ def create_mcp_router() -> APIRouter:
             project_ctx = get_project_context()
             if not project_ctx or not project_ctx.get("id"):
                 raise HTTPException(
-                    status_code=400, detail="No current project. Run 'gobby init' first."
+                    status_code=400,
+                    detail={
+                        "success": False,
+                        "error": "No current project. Run 'gobby init' first.",
+                    },
                 )
             current_project_id = project_ctx["id"]
 
             if not server.config:
-                raise HTTPException(status_code=500, detail="Daemon configuration not available")
+                raise HTTPException(
+                    status_code=500,
+                    detail={"success": False, "error": "Daemon configuration not available"},
+                )
 
             # Create importer
             from gobby.mcp_proxy.importer import MCPServerImporter
@@ -658,7 +810,7 @@ def create_mcp_router() -> APIRouter:
         except Exception as e:
             metrics.inc_counter("http_requests_errors_total")
             logger.error(f"Import MCP server error: {e}", exc_info=True)
-            raise HTTPException(status_code=500, detail=str(e)) from e
+            raise HTTPException(status_code=500, detail={"success": False, "error": str(e)}) from e
 
     @router.delete("/servers/{name}")
     async def remove_mcp_server(
@@ -678,7 +830,10 @@ def create_mcp_router() -> APIRouter:
 
         try:
             if server.mcp_manager is None:
-                raise HTTPException(status_code=503, detail="MCP manager not available")
+                raise HTTPException(
+                    status_code=503,
+                    detail={"success": False, "error": "MCP manager not available"},
+                )
 
             await server.mcp_manager.remove_server(name)
 
@@ -688,11 +843,11 @@ def create_mcp_router() -> APIRouter:
             }
 
         except ValueError as e:
-            raise HTTPException(status_code=404, detail=str(e)) from e
+            raise HTTPException(status_code=404, detail={"success": False, "error": str(e)}) from e
         except Exception as e:
             metrics.inc_counter("http_requests_errors_total")
             logger.error(f"Remove MCP server error: {e}", exc_info=True)
-            raise HTTPException(status_code=500, detail=str(e)) from e
+            raise HTTPException(status_code=500, detail={"success": False, "error": str(e)}) from e
 
     @router.post("/tools/recommend")
     async def recommend_mcp_tools(
@@ -728,7 +883,10 @@ def create_mcp_router() -> APIRouter:
             cwd = body.get("cwd")
 
             if not task_description:
-                raise HTTPException(status_code=400, detail="Required field: task_description")
+                raise HTTPException(
+                    status_code=400,
+                    detail={"success": False, "error": "Required field: task_description"},
+                )
 
             # For semantic/hybrid modes, resolve project_id from cwd
             project_id = None
@@ -770,7 +928,7 @@ def create_mcp_router() -> APIRouter:
         except Exception as e:
             metrics.inc_counter("http_requests_errors_total")
             logger.error(f"Recommend tools error: {e}", exc_info=True)
-            raise HTTPException(status_code=500, detail=str(e)) from e
+            raise HTTPException(status_code=500, detail={"success": False, "error": str(e)}) from e
 
     @router.post("/tools/search")
     async def search_mcp_tools(
@@ -804,7 +962,10 @@ def create_mcp_router() -> APIRouter:
             cwd = body.get("cwd")
 
             if not query:
-                raise HTTPException(status_code=400, detail="Required field: query")
+                raise HTTPException(
+                    status_code=400,
+                    detail={"success": False, "error": "Required field: query"},
+                )
 
             # Resolve project_id from cwd
             try:
@@ -869,7 +1030,7 @@ def create_mcp_router() -> APIRouter:
         except Exception as e:
             metrics.inc_counter("http_requests_errors_total")
             logger.error(f"Search tools error: {e}", exc_info=True)
-            raise HTTPException(status_code=500, detail=str(e)) from e
+            raise HTTPException(status_code=500, detail={"success": False, "error": str(e)}) from e
 
     @router.post("/tools/embed")
     async def embed_mcp_tools(
@@ -939,7 +1100,7 @@ def create_mcp_router() -> APIRouter:
         except Exception as e:
             metrics.inc_counter("http_requests_errors_total")
             logger.error(f"Embed tools error: {e}", exc_info=True)
-            raise HTTPException(status_code=500, detail=str(e)) from e
+            raise HTTPException(status_code=500, detail={"success": False, "error": str(e)}) from e
 
     @router.get("/status")
     async def get_mcp_status(
@@ -1000,7 +1161,7 @@ def create_mcp_router() -> APIRouter:
         except Exception as e:
             metrics.inc_counter("http_requests_errors_total")
             logger.error(f"Get MCP status error: {e}", exc_info=True)
-            raise HTTPException(status_code=500, detail=str(e)) from e
+            raise HTTPException(status_code=500, detail={"success": False, "error": str(e)}) from e
 
     @router.post("/{server_name}/tools/{tool_name}")
     async def mcp_proxy(
@@ -1030,9 +1191,19 @@ def create_mcp_router() -> APIRouter:
                 args = await request.json()
             except (json.JSONDecodeError, ValueError) as e:
                 raise HTTPException(
-                    status_code=400, detail=f"Invalid JSON in request body: {e}"
+                    status_code=400,
+                    detail={"success": False, "error": f"Invalid JSON in request body: {e}"},
                 ) from e
 
+            # Route through ToolProxyService for consistent error enrichment
+            if server.tool_proxy:
+                result = await server.tool_proxy.call_tool(server_name, tool_name, args)
+                response_time_ms = (time.perf_counter() - start_time) * 1000
+                return _process_tool_proxy_result(
+                    result, server_name, tool_name, response_time_ms, metrics
+                )
+
+            # Fallback: no tool_proxy available, use direct registry calls
             # Check internal registries first (gobby-tasks, gobby-memory, etc.)
             if server._internal_manager and server._internal_manager.is_internal(server_name):
                 registry = server._internal_manager.get_registry(server_name)
@@ -1042,10 +1213,13 @@ def create_mcp_router() -> APIRouter:
                         available = [t["name"] for t in registry.list_tools()]
                         raise HTTPException(
                             status_code=404,
-                            detail=f"Tool '{tool_name}' not found on '{server_name}'. "
-                            f"Available: {', '.join(available)}. "
-                            f"Use list_tools(server='{server_name}') to see all tools, "
-                            f"or get_tool_schema(server_name='{server_name}', tool_name='...') for full schema.",
+                            detail={
+                                "success": False,
+                                "error": f"Tool '{tool_name}' not found on '{server_name}'. "
+                                f"Available: {', '.join(available)}. "
+                                f"Use list_tools(server='{server_name}') to see all tools, "
+                                f"or get_tool_schema(server_name='{server_name}', tool_name='...') for full schema.",
+                            },
                         )
                     try:
                         result = await registry.call(tool_name, args or {})
@@ -1059,13 +1233,22 @@ def create_mcp_router() -> APIRouter:
                     except Exception as e:
                         metrics.inc_counter("mcp_tool_calls_failed_total")
                         error_msg = str(e) or f"{type(e).__name__}: (no message)"
-                        raise HTTPException(status_code=500, detail=error_msg) from e
+                        raise HTTPException(
+                            status_code=500, detail={"success": False, "error": error_msg}
+                        ) from e
                 raise HTTPException(
-                    status_code=404, detail=f"Internal server '{server_name}' not found"
+                    status_code=404,
+                    detail={
+                        "success": False,
+                        "error": f"Internal server '{server_name}' not found",
+                    },
                 )
 
             if server.mcp_manager is None:
-                raise HTTPException(status_code=503, detail="MCP manager not available")
+                raise HTTPException(
+                    status_code=503,
+                    detail={"success": False, "error": "MCP manager not available"},
+                )
 
             # Call MCP tool
             try:
@@ -1096,7 +1279,9 @@ def create_mcp_router() -> APIRouter:
                     f"MCP tool not found: {server_name}.{tool_name}",
                     extra={"server": server_name, "tool": tool_name, "error": str(e)},
                 )
-                raise HTTPException(status_code=404, detail=str(e)) from e
+                raise HTTPException(
+                    status_code=404, detail={"success": False, "error": str(e)}
+                ) from e
             except Exception as e:
                 metrics.inc_counter("mcp_tool_calls_failed_total")
                 error_msg = str(e) or f"{type(e).__name__}: (no message)"
@@ -1105,7 +1290,9 @@ def create_mcp_router() -> APIRouter:
                     exc_info=True,
                     extra={"server": server_name, "tool": tool_name},
                 )
-                raise HTTPException(status_code=500, detail=error_msg) from e
+                raise HTTPException(
+                    status_code=500, detail={"success": False, "error": error_msg}
+                ) from e
 
         except HTTPException:
             raise
@@ -1113,7 +1300,9 @@ def create_mcp_router() -> APIRouter:
             metrics.inc_counter("mcp_tool_calls_failed_total")
             error_msg = str(e) or f"{type(e).__name__}: (no message)"
             logger.error(f"MCP proxy error: {server_name}.{tool_name}", exc_info=True)
-            raise HTTPException(status_code=500, detail=error_msg) from e
+            raise HTTPException(
+                status_code=500, detail={"success": False, "error": error_msg}
+            ) from e
 
     @router.post("/refresh")
     async def refresh_mcp_tools(
@@ -1332,6 +1521,6 @@ def create_mcp_router() -> APIRouter:
         except Exception as e:
             metrics.inc_counter("http_requests_errors_total")
             logger.error(f"Refresh tools error: {e}", exc_info=True)
-            raise HTTPException(status_code=500, detail=str(e)) from e
+            raise HTTPException(status_code=500, detail={"success": False, "error": str(e)}) from e
 
     return router

gobby/servers/websocket.py

@@ -44,7 +44,7 @@ class WebSocketConfig:
     """Configuration for WebSocket server."""
 
     host: str = "localhost"
-    port: int = 8765
+    port: int = 60888
     ping_interval: int = 30  # seconds
     ping_timeout: int = 10  # seconds
     max_message_size: int = 2 * 1024 * 1024  # 2MB
@@ -64,7 +64,7 @@ class WebSocketServer:
 
     Example:
         ```python
-        config = WebSocketConfig(host="0.0.0.0", port=8765)
+        config = WebSocketConfig(host="0.0.0.0", port=60888)
 
         async with WebSocketServer(config, mcp_manager) as server:
             await server.serve_forever()

gobby/sessions/analyzer.py

@@ -32,6 +32,8 @@ class HandoffContext:
     key_decisions: list[str] | None = None
     active_worktree: dict[str, Any] | None = None
     """Worktree context if session is operating in a worktree."""
+    active_skills: list[str] = field(default_factory=list)
+    """List of skill names that were active/injected during the session."""
 
 
 class TranscriptAnalyzer:

gobby/sessions/transcripts/base.py

@@ -39,6 +39,7 @@ class ParsedMessage:
     timestamp: datetime
     raw_json: dict[str, Any]
     usage: TokenUsage | None = None
+    tool_use_id: str | None = None
 
 
 @runtime_checkable