Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
refactor(Wave 13.5): extract 4 credential CRUD WS handlers + retire dead test_ai_proxy
trohitg7aecc1c1befa
diff --git a/server/main.py b/server/main.pyindex 6edb6c51..b018ada4 100644--- a/server/main.py+++ b/server/main.py@@ -98,6 +98,11 @@ async def lifespan(app: FastAPI):# team-lifecycle handlers (create_team / get_team / ... / get_team_messages).import services.agent_teams # noqa: F401+ # Wave 13.5: services/credentials/__init__.py self-registers the 4+ # credential CRUD handlers (validate_api_key / get_stored_api_key /+ # save_api_key / delete_api_key).+ import services.credentials # noqa: F401+# Wire dependency injectioncontainer.wire(modules=["routers.workflow",diff --git a/server/routers/websocket.py b/server/routers/websocket.pyindex cc19a860..125de503 100644--- a/server/routers/websocket.py+++ b/server/routers/websocket.py@@ -957,236 +957,10 @@ async def handle_get_ai_models(data: Dict[str, Any], websocket: WebSocket) -> Di# ============================================================================-# API Key Handlers-# ============================================================================--@ws_handler("provider", "api_key")-async def handle_validate_api_key(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:- """Validate and store an API key.-- Pure dispatch — looks up the plugin's ``Credential`` subclass in- ``CREDENTIAL_REGISTRY`` and calls its ``validate`` classmethod. The- base ``Credential.validate`` (defined in- ``services/plugin/credential.py``) wires the shared scaffold- (storage + status broadcast + error classification + response- envelope) and dispatches the per-provider probe via the- subclass-supplied ``_probe`` hook. Cloud LLM providers inherit- ``_LLMApiKey._probe`` (``ai_service.fetch_models``); Maps + Apify +- local-LLM credentials override ``_probe`` (or the whole ``validate``- method, in the local-LLM case) with their own bespoke probes.-- The router doesn't know about specific providers — adding a new- provider with a special validator is a single new ``_probe``- override on the plugin's ``Credential`` subclass.- """- from services.plugin.credential import CREDENTIAL_REGISTRY-- provider = data["provider"].lower()- normalized = dict(data, provider=provider)-- cred_cls = CREDENTIAL_REGISTRY.get(provider)- if cred_cls is None:- return {- "success": False,- "valid": False,- "error": f"Unknown provider '{provider}' — no Credential class registered.",- }- return await cred_cls.validate(normalized)---def _lookup_credential_default(storage_key: str) -> Optional[str]:- """Look up a field's catalogue ``default`` for the given storage key.-- Storage keys are either the provider id (``"openai"`` for cloud- providers whose field key is ``apiKey``) or the field key itself- (``"lmstudio_proxy"`` etc. for local-LLM providers). Both shapes- map back to a credential_providers.json field; this helper finds- the one and returns its ``default`` value if declared. Used by- ``handle_get_stored_api_key`` to surface canonical defaults- (e.g. local-LLM Base URL ``http://localhost:1234/v1``) to the- frontend without requiring per-panel pre-fill logic.- """- from services.credential_registry import get_credential_registry- registry = get_credential_registry()- for provider in registry.get_all_providers():- provider_id = provider.get("id") or provider.get("name", "").lower()- for field in (provider.get("fields") or []):- field_key = field.get("key")- if not field_key:- continue- field_storage_key = provider_id if field_key == "apiKey" else field_key- if field_storage_key == storage_key:- default = field.get("default")- return default if default else None- return None---@ws_handler("provider")-async def handle_get_stored_api_key(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:- """Get stored API key for a provider.-- Response uses camelCase (``hasKey`` / ``apiKey``) to match the- ``update_api_key_status`` broadcast shape — every WS payload the- frontend receives for API key state uses the same convention, so no- per-field adapter is needed on the TypeScript side.-- When nothing is stored AND the catalogue declares a ``default``- for this field (e.g. local-LLM canonical Base URL), the default- value is returned in ``apiKey`` with ``hasKey: false``. The- frontend renders the value but tracks ``stored`` separately via- ``hasKey`` so the validated/connected badge stays honest. Lets- users click Fetch on a fresh install without retyping the URL.- """- auth_service = container.auth_service()- provider = data["provider"].lower()- api_key = await auth_service.get_api_key(provider, data.get("session_id", "default"))- if not api_key:- default = _lookup_credential_default(provider)- if default is not None:- return {"provider": provider, "hasKey": False, "apiKey": default}- return {"provider": provider, "hasKey": False}- models = await auth_service.get_stored_models(provider, data.get("session_id", "default"))- return {"provider": provider, "hasKey": True, "apiKey": api_key, "models": models, "timestamp": time.time()}---@ws_handler("provider", "api_key")-async def handle_save_api_key(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:- """Save an API key (without validation).-- Supports client-side idempotency: if the client supplies a- `request_id` (opaque UUID), duplicate calls within 60 s return the- cached result instead of re-running the mutation. Prevents- double-writes on retry / reconnect / double-click.- """- from services.idempotency import get_idempotency_store-- store = get_idempotency_store("credentials")- provider = data["provider"].lower()-- async def _do_save() -> Dict[str, Any]:- auth_service = container.auth_service()- broadcaster = get_status_broadcaster()- await auth_service.store_api_key(- provider=provider,- api_key=data["api_key"].strip(),- models=data.get("models", []),- session_id=data.get("session_id", "default"),- )- # Symmetric broadcast: tells every connected client to refetch- # the catalogue so the `stored` flag flips on this provider.- # Don't claim validity here — save_api_key doesn't validate.- await broadcaster.broadcast_credential_event(- "credential.api_key.saved",- provider=provider,- )- return {"provider": data["provider"]}-- return await store.run(data.get("request_id"), _do_save)---@ws_handler("provider")-async def handle_delete_api_key(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:- """Delete stored API key.-- Idempotent on `request_id` — see `handle_save_api_key`.- """- from services.idempotency import get_idempotency_store-- store = get_idempotency_store("credentials")- provider = data["provider"].lower()-- async def _do_delete() -> Dict[str, Any]:- auth_service = container.auth_service()- broadcaster = get_status_broadcaster()- await auth_service.remove_api_key(provider, data.get("session_id", "default"))- # Two broadcasts: api_key_status clears `apiKeyStatuses[provider]`- # on every connected client (in-memory validation cache); the- # CloudEvents-typed credential.api_key.deleted invalidates the- # catalogue so the `stored` flag flips. Both go through the- # 300 ms invalidateCatalogue debounce — one refetch.- await broadcaster.update_api_key_status(- provider, valid=False, has_key=False, message="deleted", models=[],- )- await broadcaster.broadcast_credential_event(- "credential.api_key.deleted",- provider=provider,- )- return {"provider": data["provider"]}-- return await store.run(data.get("request_id"), _do_delete)---# NOTE: claude / codex auth WS handlers (`claude_code_login`,-# `claude_code_logout`, `claude_code_auth_status`, `codex_cli_*`) are-# owned by `services/cli_agent/_handlers.py` and self-registered into-# `services.ws_handler_registry` on package import — no entries needed-# here. See `services/cli_agent/__init__.py`.----@ws_handler("url")-async def handle_test_ai_proxy(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:- """Test connectivity to an AI proxy server."""- import httpx-- url = data["url"].rstrip("/")- timeout = data.get("timeout", 5.0)-- try:- async with httpx.AsyncClient(timeout=timeout) as client:- # Try common health/models endpoints- for endpoint in ["/v1/models", "/api/tags", "/health", "/"]:- try:- response = await client.get(f"{url}{endpoint}")- if response.status_code < 500:- return {- "success": True,- "url": url,- "status_code": response.status_code,- "endpoint": endpoint,- }- except httpx.RequestError:- continue-- return {- "success": False,- "url": url,- "error": "No responding endpoints found",- }- except httpx.ConnectError:- return {"success": False, "url": url, "error": "Connection refused"}- except httpx.TimeoutException:- return {"success": False, "url": url, "error": "Connection timeout"}- except Exception as e:- return {"success": False, "url": url, "error": str(e)}---# ============================================================================-# Android handlers (5 of them: get_android_devices, execute_android_action,-# android_relay_{connect,disconnect,reconnect}) live in-# ``nodes/android/_handlers.py`` and self-register via-# ``register_ws_handlers``. The plugin's HTTP router lives in-# ``nodes/android/_router.py`` and mounts via the plugin-router loop.-# ============================================================================---# -----------------------------------------------------------------------------# Per-provider credential validators (Maps geocode probe, Apify /users/me,-# Ollama / LM Studio SDK probes) live on their plugins Credential-# subclass via the shared Credential._probe / Credential.validate scaffold-# in services/plugin/credential.py. handle_validate_api_key (above) is a-# pure dispatch through CREDENTIAL_REGISTRY no per-provider branches in-# this router.-# -------------------------------------------------------------------------------# ============================================================================-# Plugin-owned WS handlers (telegram, future plugins, ...) live in their-# own ``nodes/<group>/`` package and self-register via-# ``register_ws_handlers`` at import time. The dispatch table below-# merges them in via ``get_ws_handlers()`` -- no plugin names hardcoded-# in this file.+# API Key Handlers — extracted to services/credentials/handlers.py (Wave 13.5)# ============================================================================+# 4 handlers (validate_api_key / get_stored_api_key / save_api_key /+# delete_api_key) self-register via services/credentials/__init__.py.# ============================================================================@@ -1695,11 +1469,8 @@ MESSAGE_HANDLERS: Dict[str, MessageHandler] = {"execute_ai_node": handle_execute_ai_node,"get_ai_models": handle_get_ai_models,- # API key operations- "validate_api_key": handle_validate_api_key,- "get_stored_api_key": handle_get_stored_api_key,- "save_api_key": handle_save_api_key,- "delete_api_key": handle_delete_api_key,+ # API key operations — extracted to services/credentials/handlers.py+ # (Wave 13.5); registered via ws_handler_registry on package import.# Claude/Codex login handlers live in the plugin folders + framework:# - ``claude_code_login`` / ``claude_code_logout`` registered bydiff --git a/server/services/credentials/__init__.py b/server/services/credentials/__init__.pynew file mode 100644index 00000000..79ca5658--- /dev/null+++ b/server/services/credentials/__init__.py@@ -0,0 +1,18 @@+"""Credential-management WS handlers — Wave 13.5 extraction.++Side-effect import registers the 4 credential CRUD handlers+(validate_api_key / get_stored_api_key / save_api_key / delete_api_key)+into ``ws_handler_registry``. The per-provider validation logic lives+in ``services/plugin/credential.py``'s ``CREDENTIAL_REGISTRY``; these+handlers just shape the request + response envelope around it.+"""++from __future__ import annotations++from services.ws_handler_registry import register_ws_handlers as _register_ws_handlers++from .handlers import WS_HANDLERS as _CREDENTIALS_WS_HANDLERS++_register_ws_handlers(_CREDENTIALS_WS_HANDLERS)++__all__ = ["handlers"]diff --git a/server/services/credentials/handlers.py b/server/services/credentials/handlers.pynew file mode 100644index 00000000..2735ed8c--- /dev/null+++ b/server/services/credentials/handlers.py@@ -0,0 +1,197 @@+"""Credential CRUD WS handlers extracted from ``routers/websocket.py`` (Wave 13.5).++4 handlers:+ - ``validate_api_key`` — dispatch to plugin's ``Credential.validate``.+ - ``get_stored_api_key`` — return stored key + catalogue default fallback.+ - ``save_api_key`` — idempotent store + symmetric broadcast.+ - ``delete_api_key`` — idempotent delete + symmetric broadcast.++Per-provider validation logic lives in ``services/plugin/credential.py``'s+``CREDENTIAL_REGISTRY``. Adding a new provider with a special validator+is a single ``_probe`` override on the plugin's ``Credential`` subclass —+this module stays untouched.+"""++from __future__ import annotations++import time+from typing import Any, Dict, Optional++from fastapi import WebSocket++from core.container import container+from core.logging import get_logger+from services.status_broadcaster import get_status_broadcaster+from services.ws_handler_registry import ws_handler++# ``container`` + ``get_status_broadcaster`` re-imported at module scope+# so existing tests that patch ``services.credentials.handlers.container``+# / ``...get_status_broadcaster`` (formerly patched on ``routers.websocket``)+# keep working without rewriting fixtures. ``services.credentials`` is+# imported lazily from ``main.py`` at lifespan startup, AFTER the+# container is fully initialised — no circular-import risk like Wave+# 13.2's deployment handlers.++logger = get_logger(__name__)+++@ws_handler("provider", "api_key")+async def handle_validate_api_key(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:+ """Validate and store an API key.++ Pure dispatch — looks up the plugin's ``Credential`` subclass in+ ``CREDENTIAL_REGISTRY`` and calls its ``validate`` classmethod. The+ base ``Credential.validate`` (defined in+ ``services/plugin/credential.py``) wires the shared scaffold+ (storage + status broadcast + error classification + response+ envelope) and dispatches the per-provider probe via the+ subclass-supplied ``_probe`` hook.+ """+ from services.plugin.credential import CREDENTIAL_REGISTRY++ provider = data["provider"].lower()+ normalized = dict(data, provider=provider)++ cred_cls = CREDENTIAL_REGISTRY.get(provider)+ if cred_cls is None:+ return {+ "success": False,+ "valid": False,+ "error": f"Unknown provider '{provider}' — no Credential class registered.",+ }+ return await cred_cls.validate(normalized)+++def _lookup_credential_default(storage_key: str) -> Optional[str]:+ """Look up a field's catalogue ``default`` for the given storage key.++ Storage keys are either the provider id (``"openai"`` for cloud+ providers whose field key is ``apiKey``) or the field key itself+ (``"lmstudio_proxy"`` etc. for local-LLM providers). Both shapes+ map back to a credential_providers.json field; this helper finds+ the one and returns its ``default`` value if declared.+ """+ from services.credential_registry import get_credential_registry++ registry = get_credential_registry()+ for provider in registry.get_all_providers():+ provider_id = provider.get("id") or provider.get("name", "").lower()+ for field in (provider.get("fields") or []):+ field_key = field.get("key")+ if not field_key:+ continue+ field_storage_key = provider_id if field_key == "apiKey" else field_key+ if field_storage_key == storage_key:+ default = field.get("default")+ return default if default else None+ return None+++@ws_handler("provider")+async def handle_get_stored_api_key(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:+ """Get stored API key for a provider.++ Response uses camelCase (``hasKey`` / ``apiKey``) to match the+ ``update_api_key_status`` broadcast shape — every WS payload the+ frontend receives for API key state uses the same convention.++ When nothing is stored AND the catalogue declares a ``default`` for+ this field (e.g. local-LLM canonical Base URL), the default is+ returned in ``apiKey`` with ``hasKey: false``. The frontend renders+ the value but tracks ``stored`` separately via ``hasKey`` so the+ validated/connected badge stays honest.+ """+ from core.container import container++ auth_service = container.auth_service()+ provider = data["provider"].lower()+ api_key = await auth_service.get_api_key(provider, data.get("session_id", "default"))+ if not api_key:+ default = _lookup_credential_default(provider)+ if default is not None:+ return {"provider": provider, "hasKey": False, "apiKey": default}+ return {"provider": provider, "hasKey": False}+ models = await auth_service.get_stored_models(provider, data.get("session_id", "default"))+ return {+ "provider": provider,+ "hasKey": True,+ "apiKey": api_key,+ "models": models,+ "timestamp": time.time(),+ }+++@ws_handler("provider", "api_key")+async def handle_save_api_key(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:+ """Save an API key (without validation).++ Supports client-side idempotency: if the client supplies a+ ``request_id`` (opaque UUID), duplicate calls within 60 s return the+ cached result instead of re-running the mutation.+ """+ from core.container import container+ from services.idempotency import get_idempotency_store+ from services.status_broadcaster import get_status_broadcaster++ store = get_idempotency_store("credentials")+ provider = data["provider"].lower()++ async def _do_save() -> Dict[str, Any]:+ auth_service = container.auth_service()+ broadcaster = get_status_broadcaster()+ await auth_service.store_api_key(+ provider=provider,+ api_key=data["api_key"].strip(),+ models=data.get("models", []),+ session_id=data.get("session_id", "default"),+ )+ await broadcaster.broadcast_credential_event(+ "credential.api_key.saved",+ provider=provider,+ )+ return {"provider": data["provider"]}++ return await store.run(data.get("request_id"), _do_save)+++@ws_handler("provider")+async def handle_delete_api_key(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:+ """Delete stored API key. Idempotent on ``request_id``."""+ from core.container import container+ from services.idempotency import get_idempotency_store+ from services.status_broadcaster import get_status_broadcaster++ store = get_idempotency_store("credentials")+ provider = data["provider"].lower()++ async def _do_delete() -> Dict[str, Any]:+ auth_service = container.auth_service()+ broadcaster = get_status_broadcaster()+ await auth_service.remove_api_key(provider, data.get("session_id", "default"))+ await broadcaster.update_api_key_status(+ provider, valid=False, has_key=False, message="deleted", models=[],+ )+ await broadcaster.broadcast_credential_event(+ "credential.api_key.deleted",+ provider=provider,+ )+ return {"provider": data["provider"]}++ return await store.run(data.get("request_id"), _do_delete)+++WS_HANDLERS: Dict[str, Any] = {+ "validate_api_key": handle_validate_api_key,+ "get_stored_api_key": handle_get_stored_api_key,+ "save_api_key": handle_save_api_key,+ "delete_api_key": handle_delete_api_key,+}+++__all__ = [+ "WS_HANDLERS",+ "handle_delete_api_key",+ "handle_get_stored_api_key",+ "handle_save_api_key",+ "handle_validate_api_key",+]diff --git a/server/tests/credentials/test_credential_broadcasts.py b/server/tests/credentials/test_credential_broadcasts.pyindex 6197c2a5..12d21278 100644--- a/server/tests/credentials/test_credential_broadcasts.py+++ b/server/tests/credentials/test_credential_broadcasts.py@@ -74,7 +74,8 @@ class TestCredentialMutationHandlersBroadcast:)def test_save_api_key_broadcasts(self):- from routers import websocket as ws_module+ # Wave 13.5: moved to services.credentials.handlers.+ from services.credentials import handlers as ws_modulesrc = _handler_source(ws_module.handle_save_api_key)assert _BROADCAST_PATTERN.search(src), (@@ -84,7 +85,8 @@ class TestCredentialMutationHandlersBroadcast:)def test_delete_api_key_broadcasts(self):- from routers import websocket as ws_module+ # Wave 13.5: moved to services.credentials.handlers.+ from services.credentials import handlers as ws_modulesrc = _handler_source(ws_module.handle_delete_api_key)# Delete must trigger BOTH broadcasts: api_key_status (clearsdiff --git a/server/tests/credentials/test_websocket_handlers.py b/server/tests/credentials/test_websocket_handlers.pyindex bd3e7a3d..549c2f52 100644--- a/server/tests/credentials/test_websocket_handlers.py+++ b/server/tests/credentials/test_websocket_handlers.py@@ -18,7 +18,10 @@ from unittest.mock import AsyncMock, MagicMock, patchimport pytest-from routers import websocket as ws_module+# Wave 13.5: API key handlers moved from routers.websocket to+# services.credentials.handlers. Aliasing the new module so the existing+# ``ws_module.handle_xxx`` references below keep working unchanged.+from services.credentials import handlers as ws_modulepytestmark = pytest.mark.credentials