Skip to content

Self-improving AI Employees for everyone

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.py
index 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 injection
container.wire(modules=[
"routers.workflow",
diff --git a/server/routers/websocket.py b/server/routers/websocket.py
index 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 by
diff --git a/server/services/credentials/__init__.py b/server/services/credentials/__init__.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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_module
src = _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_module
src = _handler_source(ws_module.handle_delete_api_key)
# Delete must trigger BOTH broadcasts: api_key_status (clears
diff --git a/server/tests/credentials/test_websocket_handlers.py b/server/tests/credentials/test_websocket_handlers.py
index 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, patch
import 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_module
pytestmark = pytest.mark.credentials