Skip to content

Self-improving AI Employees for everyone

refactor(Wave 13.4): extract 10 agent-team WS handlers + fix one test

trohitg7bf4dfc6557f
diff --git a/server/main.py b/server/main.py
index 0e2c26ac..6edb6c51 100644
--- a/server/main.py
+++ b/server/main.py
@@ -94,6 +94,10 @@ async def lifespan(app: FastAPI):
# save_global_model + compaction + provider_usage_summary).
import services.settings # noqa: F401
+ # Wave 13.4: services/agent_teams/__init__.py self-registers the 10
+ # team-lifecycle handlers (create_team / get_team / ... / get_team_messages).
+ import services.agent_teams # noqa: F401
+
# Wire dependency injection
container.wire(modules=[
"routers.workflow",
diff --git a/server/routers/websocket.py b/server/routers/websocket.py
index 7c7f0231..cc19a860 100644
--- a/server/routers/websocket.py
+++ b/server/routers/websocket.py
@@ -1570,138 +1570,12 @@ async def handle_get_api_usage_summary(data: Dict[str, Any], websocket: WebSocke
# ============================================================================
-# Agent Team Handlers
+# Agent Team Handlers — extracted to services/agent_teams/handlers.py (Wave 13.4)
# ============================================================================
-
-@ws_handler("workflow_id", "team_lead_node_id")
-async def handle_create_team(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Create a new agent team."""
- from services.agent_team import get_agent_team_service
- service = get_agent_team_service()
- team = await service.create_team(
- team_lead_node_id=data["team_lead_node_id"],
- teammate_node_ids=data.get("teammates", []),
- workflow_id=data["workflow_id"],
- config=data.get("config")
- )
- return {"team": team} if team else {"success": False, "error": "Failed to create team"}
-
-
-@ws_handler("team_id")
-async def handle_get_team(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Get team info."""
- database = container.database()
- team = await database.get_team(data["team_id"])
- return {"team": team} if team else {"success": False, "error": "Team not found"}
-
-
-@ws_handler()
-async def handle_get_team_status(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Get team status with stats.
-
- Can provide team_id directly, or team_lead_node_id to find active team.
- """
- from services.agent_team import get_agent_team_service
-
- try:
- service = get_agent_team_service()
- except RuntimeError:
- # Service not initialized - no active teams
- return {"status": {"members": [], "task_count": 0, "completed_count": 0, "active_count": 0, "pending_count": 0, "failed_count": 0, "active_tasks": []}}
-
- team_id = data.get("team_id")
-
- # If no team_id, try to find by team_lead_node_id
- if not team_id and data.get("team_lead_node_id"):
- # Look up active team for this workflow (most recent)
- # This is a simple approach - check if there's an active team with this lead
- # For now, return empty status - teams are created when AI Employee runs
- return {"status": {"members": [], "task_count": 0, "completed_count": 0, "active_count": 0, "pending_count": 0, "failed_count": 0, "active_tasks": [], "message": "No active team yet"}}
-
- if not team_id:
- return {"status": {"members": [], "task_count": 0, "completed_count": 0, "active_count": 0, "pending_count": 0, "failed_count": 0, "active_tasks": [], "message": "No team connected"}}
-
- status = await service.get_team_status(team_id)
- return {"status": status}
-
-
-@ws_handler("team_id")
-async def handle_dissolve_team(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Dissolve a team."""
- from services.agent_team import get_agent_team_service
- service = get_agent_team_service()
- success = await service.dissolve_team(data["team_id"], data.get("workflow_id"))
- return {"success": success}
-
-
-@ws_handler("team_id", "title", "created_by")
-async def handle_add_team_task(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Add task to team."""
- from services.agent_team import get_agent_team_service
- service = get_agent_team_service()
- task = await service.add_task(
- team_id=data["team_id"],
- title=data["title"],
- created_by=data["created_by"],
- description=data.get("description"),
- priority=data.get("priority", 3),
- depends_on=data.get("depends_on")
- )
- return {"task": task} if task else {"success": False, "error": "Failed to add task"}
-
-
-@ws_handler("team_id", "task_id", "agent_node_id")
-async def handle_claim_team_task(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Claim a task."""
- from services.agent_team import get_agent_team_service
- service = get_agent_team_service()
- task = await service.claim_task(data["team_id"], data["task_id"], data["agent_node_id"])
- return {"task": task} if task else {"success": False, "error": "Task unavailable"}
-
-
-@ws_handler("team_id", "task_id")
-async def handle_complete_team_task(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Complete a task."""
- from services.agent_team import get_agent_team_service
- service = get_agent_team_service()
- success = await service.complete_task(data["team_id"], data["task_id"], data.get("result"))
- return {"success": success}
-
-
-@ws_handler("team_id")
-async def handle_get_team_tasks(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Get team tasks."""
- database = container.database()
- tasks = await database.get_team_tasks(data["team_id"], data.get("status"))
- return {"tasks": tasks}
-
-
-@ws_handler("team_id", "from_agent", "content")
-async def handle_send_team_message(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Send message in team."""
- from services.agent_team import get_agent_team_service
- service = get_agent_team_service()
- msg = await service.send_message(
- team_id=data["team_id"],
- from_agent=data["from_agent"],
- content=data["content"],
- to_agent=data.get("to_agent"),
- message_type=data.get("message_type", "direct")
- )
- return {"message": msg} if msg else {"success": False, "error": "Failed to send message"}
-
-
-@ws_handler("team_id")
-async def handle_get_team_messages(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Get team messages."""
- from services.agent_team import get_agent_team_service
- service = get_agent_team_service()
- messages = await service.get_messages(
- team_id=data["team_id"],
- agent_node_id=data.get("agent_node_id"),
- unread_only=data.get("unread_only", False)
- )
- return {"messages": messages}
+# 10 handlers (create_team / get_team / get_team_status / dissolve_team /
+# add_team_task / claim_team_task / complete_team_task / get_team_tasks /
+# send_team_message / get_team_messages) self-register via
+# services/agent_teams/__init__.py.
# ============================================================================
@@ -1900,17 +1774,8 @@ MESSAGE_HANDLERS: Dict[str, MessageHandler] = {
"get_model_constraints": handle_get_model_constraints,
"refresh_model_registry": handle_refresh_model_registry,
- # Agent Teams
- "create_team": handle_create_team,
- "get_team": handle_get_team,
- "get_team_status": handle_get_team_status,
- "dissolve_team": handle_dissolve_team,
- "add_team_task": handle_add_team_task,
- "claim_team_task": handle_claim_team_task,
- "complete_team_task": handle_complete_team_task,
- "get_team_tasks": handle_get_team_tasks,
- "send_team_message": handle_send_team_message,
- "get_team_messages": handle_get_team_messages,
+ # Agent Teams — extracted to services/agent_teams/handlers.py (Wave 13.4);
+ # registered via ws_handler_registry on package import.
}
diff --git a/server/services/agent_teams/__init__.py b/server/services/agent_teams/__init__.py
new file mode 100644
index 00000000..14463a2d
--- /dev/null
+++ b/server/services/agent_teams/__init__.py
@@ -0,0 +1,17 @@
+"""Agent teams WS handlers — Wave 13.4 extraction.
+
+Side-effect import registers the 10 team-lifecycle handlers into
+``ws_handler_registry``. The team-service business logic stays in the
+existing ``services/agent_team.py`` module (intentional underscore
+mismatch — service vs handlers).
+"""
+
+from __future__ import annotations
+
+from services.ws_handler_registry import register_ws_handlers as _register_ws_handlers
+
+from .handlers import WS_HANDLERS as _AGENT_TEAMS_WS_HANDLERS
+
+_register_ws_handlers(_AGENT_TEAMS_WS_HANDLERS)
+
+__all__ = ["handlers"]
diff --git a/server/services/agent_teams/handlers.py b/server/services/agent_teams/handlers.py
new file mode 100644
index 00000000..bfe3e926
--- /dev/null
+++ b/server/services/agent_teams/handlers.py
@@ -0,0 +1,195 @@
+"""Agent-team WS handlers extracted from ``routers/websocket.py`` (Wave 13.4).
+
+10 handlers wrapping the team lifecycle (create / get / dissolve), task
+queue (add / claim / complete / get), and the in-team message channel
+(send / get). Business logic lives in ``services.agent_team`` (the
+service singleton); these handlers just decode the request and route
+through it.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from fastapi import WebSocket
+
+from core.logging import get_logger
+from services.ws_handler_registry import ws_handler
+
+logger = get_logger(__name__)
+
+
+@ws_handler("workflow_id", "team_lead_node_id")
+async def handle_create_team(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+ """Create a new agent team."""
+ from services.agent_team import get_agent_team_service
+
+ service = get_agent_team_service()
+ team = await service.create_team(
+ team_lead_node_id=data["team_lead_node_id"],
+ teammate_node_ids=data.get("teammates", []),
+ workflow_id=data["workflow_id"],
+ config=data.get("config"),
+ )
+ return {"team": team} if team else {"success": False, "error": "Failed to create team"}
+
+
+@ws_handler("team_id")
+async def handle_get_team(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+ """Get team info."""
+ from core.container import container
+
+ database = container.database()
+ team = await database.get_team(data["team_id"])
+ return {"team": team} if team else {"success": False, "error": "Team not found"}
+
+
+@ws_handler()
+async def handle_get_team_status(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+ """Get team status with stats.
+
+ Can provide team_id directly, or team_lead_node_id to find active team.
+ """
+ from services.agent_team import get_agent_team_service
+
+ empty_status = {
+ "members": [],
+ "task_count": 0,
+ "completed_count": 0,
+ "active_count": 0,
+ "pending_count": 0,
+ "failed_count": 0,
+ "active_tasks": [],
+ }
+
+ try:
+ service = get_agent_team_service()
+ except RuntimeError:
+ return {"status": empty_status}
+
+ team_id = data.get("team_id")
+
+ if not team_id and data.get("team_lead_node_id"):
+ return {"status": {**empty_status, "message": "No active team yet"}}
+
+ if not team_id:
+ return {"status": {**empty_status, "message": "No team connected"}}
+
+ status = await service.get_team_status(team_id)
+ return {"status": status}
+
+
+@ws_handler("team_id")
+async def handle_dissolve_team(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+ """Dissolve a team."""
+ from services.agent_team import get_agent_team_service
+
+ service = get_agent_team_service()
+ success = await service.dissolve_team(data["team_id"], data.get("workflow_id"))
+ return {"success": success}
+
+
+@ws_handler("team_id", "title", "created_by")
+async def handle_add_team_task(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+ """Add task to team."""
+ from services.agent_team import get_agent_team_service
+
+ service = get_agent_team_service()
+ task = await service.add_task(
+ team_id=data["team_id"],
+ title=data["title"],
+ created_by=data["created_by"],
+ description=data.get("description"),
+ priority=data.get("priority", 3),
+ depends_on=data.get("depends_on"),
+ )
+ return {"task": task} if task else {"success": False, "error": "Failed to add task"}
+
+
+@ws_handler("team_id", "task_id", "agent_node_id")
+async def handle_claim_team_task(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+ """Claim a task."""
+ from services.agent_team import get_agent_team_service
+
+ service = get_agent_team_service()
+ task = await service.claim_task(data["team_id"], data["task_id"], data["agent_node_id"])
+ return {"task": task} if task else {"success": False, "error": "Task unavailable"}
+
+
+@ws_handler("team_id", "task_id")
+async def handle_complete_team_task(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+ """Complete a task."""
+ from services.agent_team import get_agent_team_service
+
+ service = get_agent_team_service()
+ success = await service.complete_task(data["team_id"], data["task_id"], data.get("result"))
+ return {"success": success}
+
+
+@ws_handler("team_id")
+async def handle_get_team_tasks(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+ """Get team tasks."""
+ from core.container import container
+
+ database = container.database()
+ tasks = await database.get_team_tasks(data["team_id"], data.get("status"))
+ return {"tasks": tasks}
+
+
+@ws_handler("team_id", "from_agent", "content")
+async def handle_send_team_message(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+ """Send message in team."""
+ from services.agent_team import get_agent_team_service
+
+ service = get_agent_team_service()
+ msg = await service.send_message(
+ team_id=data["team_id"],
+ from_agent=data["from_agent"],
+ content=data["content"],
+ to_agent=data.get("to_agent"),
+ message_type=data.get("message_type", "direct"),
+ )
+ return {"message": msg} if msg else {"success": False, "error": "Failed to send message"}
+
+
+@ws_handler("team_id")
+async def handle_get_team_messages(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+ """Get team messages."""
+ from services.agent_team import get_agent_team_service
+
+ service = get_agent_team_service()
+ messages = await service.get_messages(
+ team_id=data["team_id"],
+ agent_node_id=data.get("agent_node_id"),
+ unread_only=data.get("unread_only", False),
+ )
+ return {"messages": messages}
+
+
+WS_HANDLERS: Dict[str, Any] = {
+ "create_team": handle_create_team,
+ "get_team": handle_get_team,
+ "get_team_status": handle_get_team_status,
+ "dissolve_team": handle_dissolve_team,
+ "add_team_task": handle_add_team_task,
+ "claim_team_task": handle_claim_team_task,
+ "complete_team_task": handle_complete_team_task,
+ "get_team_tasks": handle_get_team_tasks,
+ "send_team_message": handle_send_team_message,
+ "get_team_messages": handle_get_team_messages,
+}
+
+
+__all__ = [
+ "WS_HANDLERS",
+ "handle_add_team_task",
+ "handle_claim_team_task",
+ "handle_complete_team_task",
+ "handle_create_team",
+ "handle_dissolve_team",
+ "handle_get_team",
+ "handle_get_team_messages",
+ "handle_get_team_status",
+ "handle_get_team_tasks",
+ "handle_send_team_message",
+]
diff --git a/server/tests/test_workflow_validator.py b/server/tests/test_workflow_validator.py
index b35a9562..68a6b4d2 100644
--- a/server/tests/test_workflow_validator.py
+++ b/server/tests/test_workflow_validator.py
@@ -277,9 +277,11 @@ class TestExecuteAndDeployHandlersGate:
)
def test_deploy_workflow_calls_validator_unconditionally(self):
- from routers import websocket as ws_module
+ # Wave 13.2: handle_deploy_workflow moved out of routers.websocket
+ # into services/deployment/handlers.py.
+ from services.deployment.handlers import handle_deploy_workflow
- src = self._handler_source(ws_module.handle_deploy_workflow)
+ src = self._handler_source(handle_deploy_workflow)
assert "validate_workflow" in src, (
"handle_deploy_workflow must call validate_workflow — a broken "
"workflow deployed on a schedule is much worse than a failed "