gobby 0.2.9__py3-none-any.whl → 0.2.11__py3-none-any.whl

gobby/servers/http.py

@@ -121,12 +121,13 @@ class HTTPServer:
                 )
                 logger.debug("Merge resolution and inter-session messaging subsystems initialized")
 
-            # Setup internal registries (gobby-tasks, gobby-memory, etc.)
+            # Setup internal registries (gobby-tasks, gobby-memory, gobby-pipelines, etc.)
             self._internal_manager = setup_internal_registries(
                 _config=services.config,
                 _session_manager=None,  # Not needed for internal registries
                 memory_manager=services.memory_manager,
                 task_manager=services.task_manager,
+                db=services.mcp_db_manager.db if services.mcp_db_manager else None,
                 sync_manager=services.task_sync_manager,
                 task_validator=services.task_validator,
                 message_manager=services.message_manager,
@@ -142,6 +143,9 @@ class HTTPServer:
                 project_id=services.project_id,
                 tool_proxy_getter=tool_proxy_getter,
                 inter_session_message_manager=inter_session_message_manager,
+                pipeline_executor=services.pipeline_executor,
+                workflow_loader=services.workflow_loader,
+                pipeline_execution_manager=services.pipeline_execution_manager,
             )
             registry_count = len(self._internal_manager)
             logger.debug(f"Internal registries initialized: {registry_count} registries")
@@ -514,6 +518,7 @@ class HTTPServer:
             create_admin_router,
             create_hooks_router,
             create_mcp_router,
+            create_pipelines_router,
             create_plugins_router,
             create_sessions_router,
             create_webhooks_router,
@@ -526,6 +531,7 @@ class HTTPServer:
         app.include_router(create_hooks_router(self))
         app.include_router(create_plugins_router())
         app.include_router(create_webhooks_router())
+        app.include_router(create_pipelines_router(self))
 
     async def _process_shutdown(self) -> None:
         """

gobby/servers/routes/__init__.py

@@ -11,12 +11,14 @@ from gobby.servers.routes.mcp import (
     create_plugins_router,
     create_webhooks_router,
 )
+from gobby.servers.routes.pipelines import create_pipelines_router
 from gobby.servers.routes.sessions import create_sessions_router
 
 __all__ = [
     "create_admin_router",
     "create_hooks_router",
     "create_mcp_router",
+    "create_pipelines_router",
     "create_plugins_router",
     "create_sessions_router",
     "create_webhooks_router",

gobby/servers/routes/admin.py

@@ -290,6 +290,50 @@ def create_admin_router(server: "HTTPServer") -> APIRouter:
             logger.error(f"Failed to export metrics: {e}", exc_info=True)
             raise
 
+    @router.get("/models")
+    async def get_models() -> dict[str, Any]:
+        """
+        Get available LLM providers and their models.
+
+        Returns:
+            Dictionary with providers and their available models
+        """
+        start_time = time.perf_counter()
+
+        providers_data: dict[str, Any] = {}
+        default_provider = None
+        default_model = None
+
+        if server.llm_service is not None:
+            enabled = server.llm_service.enabled_providers
+            if enabled:
+                default_provider = "claude" if "claude" in enabled else enabled[0]
+
+            # Get models for each enabled provider from config
+            if server.services.config and server.services.config.llm_providers:
+                llm_config = server.services.config.llm_providers
+
+                for provider_name in enabled:
+                    provider_config = getattr(llm_config, provider_name, None)
+                    if provider_config:
+                        models = provider_config.get_models_list()
+                        providers_data[provider_name] = {
+                            "models": models,
+                            "auth_mode": provider_config.auth_mode,
+                        }
+                        # Set default model from first provider
+                        if default_model is None and models:
+                            default_model = models[0]
+
+        response_time_ms = (time.perf_counter() - start_time) * 1000
+
+        return {
+            "providers": providers_data,
+            "default_provider": default_provider,
+            "default_model": default_model,
+            "response_time_ms": response_time_ms,
+        }
+
     @router.get("/config")
     async def get_config() -> dict[str, Any]:
         """

gobby/servers/routes/mcp/endpoints/execution.py

@@ -7,7 +7,6 @@ These endpoints handle tool listing, schema retrieval, and tool execution.
 
 import json
 import logging
-import re
 import time
 from typing import TYPE_CHECKING, Any
 
@@ -36,6 +35,10 @@ def _process_tool_proxy_result(
     """
     Process tool proxy result with consistent metrics, logging, and error handling.
 
+    All errors (including server-not-found) are returned as {success: False, result: {...}}
+    rather than raising HTTPException. This ensures consistent error formatting for
+    MCP clients, which otherwise show errors as "HTTP 404: {body}" instead of clean messages.
+
     Args:
         result: The result from tool_proxy.call_tool()
         server_name: Name of the MCP server
@@ -44,38 +47,28 @@ def _process_tool_proxy_result(
 
     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.inc_counter("mcp_tool_calls_failed_total")
 
-        # Check structured error code first (preferred)
+        # Return all errors consistently as {success: False, result: {...}}
+        # Previously, server-not-found errors raised HTTPException(404), but this
+        # caused MCP clients to format errors as "HTTP 404: {body}" instead of
+        # showing clean error messages. Consistent error envelopes work better
+        # for both MCP clients (via call_tool) and HTTP clients.
         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:
+        if error_code:
             logger.debug(
-                "ToolProxyService returned error without error_code - using regex fallback"
+                f"MCP tool call failed: {server_name}.{tool_name} (error_code={error_code})",
+                extra={
+                    "server": server_name,
+                    "tool": tool_name,
+                    "error_code": error_code,
+                },
             )
-            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
+
+        # Tool-level failure - return failure envelope (not HTTP exception)
         return {
             "success": False,
             "result": result,

gobby/servers/routes/mcp/hooks.py

@@ -113,12 +113,21 @@ def create_hooks_router(server: "HTTPServer") -> APIRouter:
             from gobby.adapters.base import BaseAdapter
             from gobby.adapters.claude_code import ClaudeCodeAdapter
             from gobby.adapters.codex_impl.adapter import CodexNotifyAdapter
+            from gobby.adapters.copilot import CopilotAdapter
+            from gobby.adapters.cursor import CursorAdapter
             from gobby.adapters.gemini import GeminiAdapter
+            from gobby.adapters.windsurf import WindsurfAdapter
 
             if source == "claude":
                 adapter: BaseAdapter = ClaudeCodeAdapter(hook_manager=hook_manager)
             elif source == "antigravity":
                 adapter = ClaudeCodeAdapter(hook_manager=hook_manager)  # Same format as Claude
+            elif source == "cursor":
+                adapter = CursorAdapter(hook_manager=hook_manager)
+            elif source == "windsurf":
+                adapter = WindsurfAdapter(hook_manager=hook_manager)
+            elif source == "copilot":
+                adapter = CopilotAdapter(hook_manager=hook_manager)
             elif source == "gemini":
                 adapter = GeminiAdapter(hook_manager=hook_manager)
             elif source == "codex":
@@ -126,7 +135,7 @@ def create_hooks_router(server: "HTTPServer") -> APIRouter:
             else:
                 raise HTTPException(
                     status_code=400,
-                    detail=f"Unsupported source: {source}. Supported: claude, antigravity, gemini, codex",
+                    detail=f"Unsupported source: {source}. Supported: claude, antigravity, gemini, codex, cursor, windsurf, copilot",
                 )
 
             # Execute hook via adapter

gobby/servers/routes/pipelines.py

@@ -0,0 +1,227 @@
+"""
+Pipeline routes for Gobby HTTP server.
+
+Provides endpoints for running, approving, and monitoring pipelines.
+"""
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from gobby.servers.http import HTTPServer
+
+logger = logging.getLogger(__name__)
+
+
+class PipelineRunRequest(BaseModel):
+    """Request body for POST /api/pipelines/run."""
+
+    name: str
+    inputs: dict[str, Any] = {}
+    project_id: str | None = None
+
+
+class PipelineRunResponse(BaseModel):
+    """Response body for successful pipeline execution."""
+
+    status: str
+    execution_id: str
+    pipeline_name: str
+    outputs: dict[str, Any] | None = None
+
+
+class PipelineApprovalResponse(BaseModel):
+    """Response body when pipeline requires approval."""
+
+    status: str
+    execution_id: str
+    step_id: str
+    token: str
+    message: str
+
+
+def create_pipelines_router(server: "HTTPServer") -> APIRouter:
+    """
+    Create pipelines router with endpoints bound to server instance.
+
+    Args:
+        server: HTTPServer instance for accessing state and dependencies
+
+    Returns:
+        Configured APIRouter with pipeline endpoints
+    """
+    router = APIRouter(prefix="/api/pipelines", tags=["pipelines"])
+
+    @router.post("/run", response_model=None)
+    async def run_pipeline(request: PipelineRunRequest) -> dict[str, Any] | JSONResponse:
+        """
+        Run a pipeline by name.
+
+        Returns:
+            200: Pipeline completed successfully
+            202: Pipeline waiting for approval
+            404: Pipeline not found
+            500: Execution error
+        """
+        from gobby.workflows.pipeline_state import ApprovalRequired
+
+        # Get loader and executor from services
+        loader = server.services.workflow_loader
+        executor = server.services.pipeline_executor
+
+        if loader is None:
+            raise HTTPException(status_code=500, detail="Workflow loader not configured")
+
+        if executor is None:
+            raise HTTPException(status_code=500, detail="Pipeline executor not configured")
+
+        # Load the pipeline
+        pipeline = loader.load_pipeline(request.name)
+        if pipeline is None:
+            raise HTTPException(status_code=404, detail=f"Pipeline '{request.name}' not found")
+
+        try:
+            # Execute the pipeline
+            execution = await executor.execute(
+                pipeline=pipeline,
+                inputs=request.inputs,
+                project_id=request.project_id or "",
+            )
+
+            # Return success response
+            return {
+                "status": execution.status.value,
+                "execution_id": execution.id,
+                "pipeline_name": execution.pipeline_name,
+            }
+
+        except ApprovalRequired as e:
+            # Return 202 Accepted for approval required
+            return JSONResponse(
+                status_code=202,
+                content={
+                    "status": "waiting_approval",
+                    "execution_id": e.execution_id,
+                    "step_id": e.step_id,
+                    "token": e.token,
+                    "message": e.message,
+                },
+            )
+
+        except Exception as e:
+            logger.error(f"Pipeline execution failed: {e}", exc_info=True)
+            raise HTTPException(status_code=500, detail=f"Execution error: {e}") from None
+
+    @router.get("/{execution_id}")
+    async def get_execution(execution_id: str) -> dict[str, Any]:
+        """
+        Get execution details by ID.
+
+        Returns:
+            200: Execution details with steps
+            404: Execution not found
+        """
+        # Get execution manager from services
+        execution_manager = server.services.pipeline_execution_manager
+
+        if execution_manager is None:
+            raise HTTPException(status_code=500, detail="Pipeline execution manager not configured")
+
+        # Fetch execution
+        execution = execution_manager.get_execution(execution_id)
+        if execution is None:
+            raise HTTPException(status_code=404, detail=f"Execution '{execution_id}' not found")
+
+        # Fetch steps
+        steps = execution_manager.get_steps_for_execution(execution_id)
+
+        return {
+            "id": execution.id,
+            "pipeline_name": execution.pipeline_name,
+            "project_id": execution.project_id,
+            "status": execution.status.value,
+            "created_at": execution.created_at,
+            "updated_at": execution.updated_at,
+            "steps": [
+                {
+                    "id": step.id,
+                    "step_id": step.step_id,
+                    "status": step.status.value,
+                }
+                for step in steps
+            ],
+        }
+
+    @router.post("/approve/{token}", response_model=None)
+    async def approve_execution(token: str) -> dict[str, Any] | JSONResponse:
+        """
+        Approve a pipeline execution waiting for approval.
+
+        Returns:
+            200: Execution resumed and completed (or continued)
+            202: Execution resumed but needs another approval
+            404: Invalid token
+        """
+        from gobby.workflows.pipeline_state import ApprovalRequired
+
+        executor = server.services.pipeline_executor
+
+        if executor is None:
+            raise HTTPException(status_code=500, detail="Pipeline executor not configured")
+
+        try:
+            execution = await executor.approve(token, approved_by=None)
+
+            return {
+                "status": execution.status.value,
+                "execution_id": execution.id,
+                "pipeline_name": execution.pipeline_name,
+            }
+
+        except ApprovalRequired as e:
+            # Pipeline needs another approval
+            return JSONResponse(
+                status_code=202,
+                content={
+                    "status": "waiting_approval",
+                    "execution_id": e.execution_id,
+                    "step_id": e.step_id,
+                    "token": e.token,
+                    "message": e.message,
+                },
+            )
+
+        except ValueError as e:
+            raise HTTPException(status_code=404, detail=f"Invalid token: {e}") from None
+
+    @router.post("/reject/{token}")
+    async def reject_execution(token: str) -> dict[str, Any]:
+        """
+        Reject a pipeline execution waiting for approval.
+
+        Returns:
+            200: Execution rejected/cancelled
+            404: Invalid token
+        """
+        executor = server.services.pipeline_executor
+
+        if executor is None:
+            raise HTTPException(status_code=500, detail="Pipeline executor not configured")
+
+        try:
+            execution = await executor.reject(token, rejected_by=None)
+
+            return {
+                "status": execution.status.value,
+                "execution_id": execution.id,
+                "pipeline_name": execution.pipeline_name,
+            }
+
+        except ValueError as e:
+            raise HTTPException(status_code=404, detail=f"Invalid token: {e}") from None
+
+    return router