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

gobby/servers/http.py

@@ -10,7 +10,7 @@ import logging
 import time
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
@@ -19,18 +19,22 @@ from fastapi.responses import JSONResponse
 from gobby.adapters.codex_impl.adapter import CodexAdapter
 from gobby.hooks.broadcaster import HookEventBroadcaster
 from gobby.hooks.hook_manager import HookManager
-from gobby.llm import LLMService, create_llm_service
+from gobby.llm import create_llm_service
 from gobby.mcp_proxy.registries import setup_internal_registries
 from gobby.mcp_proxy.semantic_search import SemanticToolSearch
 from gobby.mcp_proxy.server import GobbyDaemonTools, create_mcp_server
 from gobby.mcp_proxy.services.tool_filter import ToolFilterService
-from gobby.memory.manager import MemoryManager
-from gobby.storage.sessions import LocalSessionManager
-from gobby.storage.tasks import LocalTaskManager
-from gobby.sync.tasks import TaskSyncManager
 from gobby.utils.metrics import get_metrics_collector
 from gobby.utils.version import get_version
 
+if TYPE_CHECKING:
+    from gobby.app_context import ServiceContainer
+    from gobby.config.app import DaemonConfig
+    from gobby.llm import LLMService
+    from gobby.mcp_proxy.manager import MCPClientManager
+    from gobby.servers.websocket import WebSocketServer
+    from gobby.utils.tool_metrics import ToolMetricsManager
+
 logger = logging.getLogger(__name__)
 
 
@@ -44,84 +48,38 @@ class HTTPServer:
 
     def __init__(
         self,
+        services: "ServiceContainer",
         port: int = 8000,
         test_mode: bool = False,
-        mcp_manager: Any | None = None,
-        mcp_db_manager: Any | None = None,
-        config: Any | None = None,
         codex_client: Any | None = None,
-        session_manager: LocalSessionManager | None = None,
-        websocket_server: Any | None = None,
-        task_manager: LocalTaskManager | None = None,
-        task_sync_manager: TaskSyncManager | None = None,
-        message_processor: Any | None = None,
-        message_manager: Any | None = None,  # LocalSessionMessageManager
-        memory_manager: "MemoryManager | None" = None,
-        llm_service: "LLMService | None" = None,
-        memory_sync_manager: Any | None = None,
-        task_validator: Any | None = None,
-        metrics_manager: Any | None = None,
-        agent_runner: Any | None = None,
-        worktree_storage: Any | None = None,
-        clone_storage: Any | None = None,
-        git_manager: Any | None = None,
-        project_id: str | None = None,
     ) -> None:
         """
         Initialize HTTP server.
 
         Args:
+            services: ServiceContainer holding all dependencies
             port: Server port
             test_mode: Run in test mode (disable features that conflict with testing)
-            mcp_manager: MCPClientManager instance for multi-server support
-            mcp_db_manager: LocalMCPManager instance for SQLite-based storage of MCP
-                server configurations and tool schemas. Used by ToolsHandler for
-                progressive tool discovery. Optional; defaults to None.
-            config: DaemonConfig instance for configuration
             codex_client: CodexAppServerClient instance for Codex integration
-            session_manager: LocalSessionManager for session storage
-            websocket_server: Optional WebSocketServer instance for event broadcasting
-            task_manager: LocalTaskManager instance
-            task_sync_manager: TaskSyncManager instance
-            message_processor: SessionMessageProcessor instance
-            message_manager: LocalSessionMessageManager instance for retrieval
-            memory_manager: MemoryManager instance
-            llm_service: LLMService instance
         """
+        self.services = services
         self.port = port
         self.test_mode = test_mode
-        self.mcp_manager = mcp_manager
-        self.config = config
         self.codex_client = codex_client
-        self.session_manager = session_manager
-        self.task_manager = task_manager
-        self.task_sync_manager = task_sync_manager
-        self.message_processor = message_processor
-        self.message_manager = message_manager
-        self.memory_manager = memory_manager
-        self.websocket_server = websocket_server
-        self.llm_service = llm_service
-        self.memory_sync_manager = memory_sync_manager
-        self.task_validator = task_validator
-        self.metrics_manager = metrics_manager
-        self.agent_runner = agent_runner
-        self.worktree_storage = worktree_storage
-        self.clone_storage = clone_storage
-        self.git_manager = git_manager
-        self.project_id = project_id
-
-        # Initialize WebSocket broadcaster
-        # Note: websocket_server might be None if disabled
-        self.broadcaster = HookEventBroadcaster(websocket_server, config)
+
+        # WebSocket server reference (set by GobbyRunner after construction)
+        self.websocket_server: WebSocketServer | None = None
+
+        self.broadcaster = HookEventBroadcaster(services.websocket_server, services.config)
 
         self._start_time: float = time.time()
 
-        # Create LLM service if not provided
-        if not self.llm_service and config:
+        # Create LLM service if not provided in container (fallback)
+        if not services.llm_service and services.config:
             try:
-                self.llm_service = create_llm_service(config)
+                services.llm_service = create_llm_service(services.config)
                 logger.debug(
-                    f"LLM service initialized with providers: {self.llm_service.enabled_providers}"
+                    f"LLM service initialized with providers: {services.llm_service.enabled_providers}"
                 )
             except Exception as e:
                 logger.error(f"Failed to initialize LLM service: {e}")
@@ -130,12 +88,13 @@ class HTTPServer:
         self._mcp_server = None
         self._internal_manager = None
         self._tools_handler = None
-        self._mcp_db_manager = mcp_db_manager
-        if mcp_manager:
+
+        if services.mcp_manager:
             # Determine WebSocket port
             ws_port = 60888
-            if config and hasattr(config, "websocket") and config.websocket:
-                ws_port = config.websocket.port
+            cfg = services.config
+            if cfg and hasattr(cfg, "websocket") and cfg.websocket:
+                ws_port = cfg.websocket.port
 
             # Create a lazy getter for tool_proxy that will be available after
             # GobbyDaemonTools is created. This allows in-process agents to route
@@ -149,84 +108,90 @@ class HTTPServer:
             merge_storage = None
             merge_resolver = None
             inter_session_message_manager = None
-            if mcp_db_manager:
+            if self.services.mcp_db_manager:
                 from gobby.storage.inter_session_messages import InterSessionMessageManager
                 from gobby.storage.merge_resolutions import MergeResolutionManager
                 from gobby.worktrees.merge.resolver import MergeResolver
 
-                merge_storage = MergeResolutionManager(mcp_db_manager.db)
+                merge_storage = MergeResolutionManager(self.services.mcp_db_manager.db)
                 merge_resolver = MergeResolver()
-                merge_resolver._llm_service = self.llm_service
-                inter_session_message_manager = InterSessionMessageManager(mcp_db_manager.db)
+                merge_resolver._llm_service = services.llm_service
+                inter_session_message_manager = InterSessionMessageManager(
+                    self.services.mcp_db_manager.db
+                )
                 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=config,
+                _config=services.config,
                 _session_manager=None,  # Not needed for internal registries
-                memory_manager=memory_manager,
-                task_manager=task_manager,
-                sync_manager=task_sync_manager,
-                task_validator=self.task_validator,
-                message_manager=message_manager,
-                local_session_manager=session_manager,
-                metrics_manager=self.metrics_manager,
-                llm_service=self.llm_service,
-                agent_runner=self.agent_runner,
-                worktree_storage=self.worktree_storage,
-                clone_storage=self.clone_storage,
-                git_manager=self.git_manager,
+                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,
+                local_session_manager=services.session_manager,
+                metrics_manager=services.metrics_manager,
+                llm_service=services.llm_service,
+                agent_runner=services.agent_runner,
+                worktree_storage=services.worktree_storage,
+                clone_storage=services.clone_storage,
+                git_manager=services.git_manager,
                 merge_storage=merge_storage,
                 merge_resolver=merge_resolver,
-                project_id=self.project_id,
+                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")
 
             # Initialize tool summarizer config
-            if config:
+            if services.config:
                 from gobby.tools.summarizer import init_summarizer_config
 
-                init_summarizer_config(config.tool_summarizer)
+                init_summarizer_config(services.config.tool_summarizer)
                 logger.debug("Tool summarizer config initialized")
 
             # Create semantic search instance if db available
             semantic_search = None
-            if mcp_db_manager:
-                semantic_search = SemanticToolSearch(db=mcp_db_manager.db)
+            if services.mcp_db_manager:
+                semantic_search = SemanticToolSearch(db=services.mcp_db_manager.db)
                 logger.debug("Semantic tool search initialized")
 
             # Create tool filter for workflow phase restrictions
             tool_filter = None
-            if mcp_db_manager:
-                tool_filter = ToolFilterService(db=mcp_db_manager.db)
+            if services.mcp_db_manager:
+                tool_filter = ToolFilterService(db=services.mcp_db_manager.db)
                 logger.debug("Tool filter service initialized")
 
             # Create fallback resolver for alternative tool suggestions on error
             fallback_resolver = None
-            if semantic_search and self.metrics_manager:
+            if semantic_search and services.metrics_manager:
                 from gobby.mcp_proxy.services.fallback import ToolFallbackResolver
 
                 fallback_resolver = ToolFallbackResolver(
                     semantic_search=semantic_search,
-                    metrics_manager=self.metrics_manager,
+                    metrics_manager=services.metrics_manager,
                 )
                 logger.debug("Fallback resolver initialized")
 
             # Create tools handler
             self._tools_handler = GobbyDaemonTools(
-                mcp_manager=mcp_manager,
+                mcp_manager=services.mcp_manager,
                 daemon_port=port,
                 websocket_port=ws_port,
                 start_time=self._start_time,
                 internal_manager=self._internal_manager,
-                config=config,
-                llm_service=self.llm_service,
-                session_manager=session_manager,
-                memory_manager=memory_manager,
-                config_manager=mcp_db_manager,
+                config=services.config,
+                llm_service=services.llm_service,
+                session_manager=services.session_manager,
+                memory_manager=services.memory_manager,
+                config_manager=services.mcp_db_manager,
                 semantic_search=semantic_search,
                 tool_filter=tool_filter,
                 fallback_resolver=fallback_resolver,
@@ -240,6 +205,83 @@ class HTTPServer:
         self._metrics = get_metrics_collector()
         self._daemon: Any = None  # Set externally by daemon
 
+    # Property accessors for services (delegate to container)
+    @property
+    def config(self) -> "DaemonConfig | None":
+        return self.services.config
+
+    @property
+    def session_manager(self) -> Any:
+        return self.services.session_manager
+
+    @session_manager.setter
+    def session_manager(self, value: Any) -> None:
+        self.services.session_manager = value
+
+    @property
+    def task_manager(self) -> Any:
+        return self.services.task_manager
+
+    @task_manager.setter
+    def task_manager(self, value: Any) -> None:
+        self.services.task_manager = value
+
+    @property
+    def mcp_manager(self) -> "MCPClientManager | None":
+        return self.services.mcp_manager
+
+    @mcp_manager.setter
+    def mcp_manager(self, value: "MCPClientManager | None") -> None:
+        self.services.mcp_manager = value
+
+    @property
+    def llm_service(self) -> "LLMService | None":
+        return self.services.llm_service
+
+    @llm_service.setter
+    def llm_service(self, value: "LLMService | None") -> None:
+        self.services.llm_service = value
+
+    @property
+    def memory_manager(self) -> Any:
+        return self.services.memory_manager
+
+    @memory_manager.setter
+    def memory_manager(self, value: Any) -> None:
+        self.services.memory_manager = value
+
+    @property
+    def message_manager(self) -> Any:
+        return self.services.message_manager
+
+    @message_manager.setter
+    def message_manager(self, value: Any) -> None:
+        self.services.message_manager = value
+
+    @property
+    def message_processor(self) -> Any:
+        return self.services.message_processor
+
+    @message_processor.setter
+    def message_processor(self, value: Any) -> None:
+        self.services.message_processor = value
+
+    @property
+    def metrics_manager(self) -> "ToolMetricsManager | None":
+        return self.services.metrics_manager
+
+    @metrics_manager.setter
+    def metrics_manager(self, value: "ToolMetricsManager | None") -> None:
+        self.services.metrics_manager = value
+
+    @property
+    def _mcp_db_manager(self) -> Any:
+        return self.services.mcp_db_manager
+
+    @_mcp_db_manager.setter
+    def _mcp_db_manager(self, value: Any) -> None:
+        self.services.mcp_db_manager = value
+
     @property
     def tool_proxy(self) -> Any:
         """Get the ToolProxyService instance for routing tool calls with error enrichment."""
@@ -314,30 +356,32 @@ class HTTPServer:
             hook_manager_kwargs: dict[str, Any] = {
                 "daemon_host": "localhost",
                 "daemon_port": self.port,
-                "llm_service": self.llm_service,
-                "config": self.config,
+                "llm_service": self.services.llm_service,
+                "config": self.services.config,
                 "broadcaster": self.broadcaster,
-                "mcp_manager": self.mcp_manager,
-                "message_processor": self.message_processor,
-                "memory_sync_manager": self.memory_sync_manager,
-                "task_sync_manager": self.task_sync_manager,
+                "mcp_manager": self.services.mcp_manager,
+                "message_processor": self.services.message_processor,
+                "memory_sync_manager": self.services.memory_sync_manager,
+                "task_sync_manager": self.services.task_sync_manager,
             }
-            if self.config:
+            if self.services.config:
                 # Pass full log file path from config
-                hook_manager_kwargs["log_file"] = self.config.logging.hook_manager
-                hook_manager_kwargs["log_max_bytes"] = self.config.logging.max_size_mb * 1024 * 1024
-                hook_manager_kwargs["log_backup_count"] = self.config.logging.backup_count
+                hook_manager_kwargs["log_file"] = self.services.config.logging.hook_manager
+                hook_manager_kwargs["log_max_bytes"] = (
+                    self.services.config.logging.max_size_mb * 1024 * 1024
+                )
+                hook_manager_kwargs["log_backup_count"] = self.services.config.logging.backup_count
 
                 app.state.hook_manager = HookManager(**hook_manager_kwargs)
             logger.debug("HookManager initialized in daemon")
 
             # Wire up stop_registry to WebSocket server for stop_request handling
             if (
-                self.websocket_server
+                self.services.websocket_server
                 and hasattr(app.state, "hook_manager")
                 and hasattr(app.state.hook_manager, "_stop_registry")
             ):
-                self.websocket_server.stop_registry = app.state.hook_manager._stop_registry
+                self.services.websocket_server.stop_registry = app.state.hook_manager._stop_registry
                 logger.debug("Stop registry connected to WebSocket server")
 
             # Store server instance for dependency injection
@@ -474,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,
@@ -486,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:
         """
@@ -496,45 +542,48 @@ class HTTPServer:
         try:
             logger.debug("Processing graceful shutdown")
 
-            # Wait for pending background tasks to complete
+            # Cancel pending background tasks immediately instead of polling
             pending_tasks_count = len(self._background_tasks)
             if pending_tasks_count > 0:
                 logger.debug(
-                    "Waiting for pending background tasks to complete",
+                    "Cancelling pending background tasks",
                     extra={"pending_tasks": pending_tasks_count},
                 )
 
-                max_wait = 30.0
-                wait_start = time.perf_counter()
-
-                while (
-                    len(self._background_tasks) > 0
-                    and (time.perf_counter() - wait_start) < max_wait
-                ):
-                    await asyncio.sleep(0.5)
-
-                completed_wait = time.perf_counter() - wait_start
-                remaining_tasks = len(self._background_tasks)
-
-                if remaining_tasks > 0:
-                    logger.warning(
-                        "Shutdown timeout - some background tasks still pending",
-                        extra={
-                            "remaining_tasks": remaining_tasks,
-                            "wait_seconds": completed_wait,
-                        },
-                    )
-                else:
-                    logger.debug(
-                        "All background tasks completed",
-                        extra={"wait_seconds": completed_wait},
+                # Cancel all tasks
+                for task in self._background_tasks:
+                    task.cancel()
+
+                # Wait for cancellation to complete with a short timeout
+                if self._background_tasks:
+                    done, pending = await asyncio.wait(
+                        self._background_tasks,
+                        timeout=5.0,
+                        return_when=asyncio.ALL_COMPLETED,
                     )
 
+                    completed_count = len(done)
+                    remaining_count = len(pending)
+
+                    if remaining_count > 0:
+                        logger.warning(
+                            "Some background tasks did not cancel in time",
+                            extra={
+                                "completed": completed_count,
+                                "remaining": remaining_count,
+                            },
+                        )
+                    else:
+                        logger.debug(
+                            "All background tasks cancelled",
+                            extra={"completed": completed_count},
+                        )
+
             # Disconnect all MCP servers
-            if self.mcp_manager:
+            if self.services.mcp_manager:
                 logger.debug("Disconnecting MCP servers...")
                 try:
-                    await self.mcp_manager.disconnect_all()
+                    await self.services.mcp_manager.disconnect_all()
                     logger.debug("MCP servers disconnected")
                 except Exception as e:
                     logger.warning(f"Error disconnecting MCP servers: {e}")
@@ -560,31 +609,25 @@ class HTTPServer:
 
 
 async def create_server(
+    services: "ServiceContainer",
     port: int = 60887,
     test_mode: bool = False,
-    mcp_manager: Any | None = None,
-    config: Any | None = None,
-    session_manager: LocalSessionManager | None = None,
 ) -> HTTPServer:
     """
     Create HTTP server instance.
 
     Args:
+        services: ServiceContainer holding dependencies
         port: Port to listen on
         test_mode: Enable test mode
-        mcp_manager: MCP client manager
-        config: Daemon configuration
-        session_manager: Local session manager
 
     Returns:
         Configured HTTPServer instance
     """
     return HTTPServer(
+        services=services,
         port=port,
         test_mode=test_mode,
-        mcp_manager=mcp_manager,
-        config=config,
-        session_manager=session_manager,
     )
 
 

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

@@ -175,6 +175,17 @@ def create_admin_router(server: "HTTPServer") -> APIRouter:
             except Exception as e:
                 logger.warning(f"Failed to get memory stats: {e}")
 
+        # Get artifact statistics
+        artifact_stats = {"count": 0}
+        if server.session_manager is not None:
+            try:
+                from gobby.storage.artifacts import LocalArtifactManager
+
+                artifact_manager = LocalArtifactManager(server.session_manager.db)
+                artifact_stats["count"] = artifact_manager.count_artifacts()
+            except Exception as e:
+                logger.warning(f"Failed to get artifact stats: {e}")
+
         # Get skills statistics
         skills_stats: dict[str, Any] = {"total": 0}
         if server._internal_manager:
@@ -231,6 +242,7 @@ def create_admin_router(server: "HTTPServer") -> APIRouter:
             "sessions": session_stats,
             "tasks": task_stats,
             "memory": memory_stats,
+            "artifacts": artifact_stats,
             "skills": skills_stats,
             "plugins": plugin_stats,
             "response_time_ms": response_time_ms,
@@ -278,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]:
         """