Skip to content

Self-improving AI Employees for everyone

refactor: extract DeepAgentService as separate execution engine

trohitg7dbee368517a
diff --git a/server/services/ai.py b/server/services/ai.py
index f7586d71..c5014e90 100644
--- a/server/services/ai.py
+++ b/server/services/ai.py
@@ -913,6 +913,9 @@ class AIService:
# RLM service (lazy import to avoid circular deps)
from services.rlm import RLMService
self.rlm_service = RLMService(auth=self.auth)
+ # Deep Agent service (deepagents package)
+ from services.deep_agent_service import DeepAgentService
+ self.deep_agent_service = DeepAgentService(auth=self.auth)
def detect_provider(self, model: str) -> str:
"""Detect AI provider from model name."""
@@ -1913,8 +1916,7 @@ class AIService:
broadcaster=None,
workflow_id: Optional[str] = None,
context: Optional[Dict[str, Any]] = None,
- database=None,
- node_type: Optional[str] = None) -> Dict[str, Any]:
+ database=None) -> Dict[str, Any]:
"""Execute Chat Agent - conversational AI with memory, skills, and tool calling.
Chat Agent supports:
@@ -2122,52 +2124,6 @@ class AIService:
thinking_content = None
iterations = 1
- # Deep Agent: delegate to deepagents package (create_deep_agent)
- # All tools, system_message, and model are already resolved above.
- if node_type == 'deep_agent':
- from deepagents import create_deep_agent
-
- # Map provider to deepagents model string format
- _da_prefix = {"gemini": "google_genai"}
- model_id = f"{_da_prefix.get(provider, provider)}:{model}"
- max_turns = int(parameters.get('maxTurns', 25))
-
- agent = create_deep_agent(
- model=model_id,
- tools=all_tools if all_tools else None,
- system_prompt=system_message,
- )
-
- da_result = await agent.ainvoke(
- {"messages": [{"role": "user", "content": prompt}]},
- config={"recursion_limit": max_turns * 2},
- )
-
- da_messages = da_result.get("messages", [])
- response_content = ""
- for msg in reversed(da_messages):
- if getattr(msg, "type", None) == "ai" and hasattr(msg, "content"):
- response_content = msg.content if isinstance(msg.content, str) else str(msg.content)
- break
-
- log_execution_time(logger, "deep_agent", start_time, time.time())
- log_api_call(logger, provider, model, "deep_agent", True)
-
- return {
- "success": True,
- "node_id": node_id,
- "node_type": "deep_agent",
- "result": {
- "response": response_content,
- "model": model,
- "provider": provider,
- "messages_count": len(da_messages),
- "finish_reason": "stop",
- "timestamp": datetime.now().isoformat(),
- },
- "execution_time": time.time() - start_time,
- }
-
if all_tools:
# Use LangGraph for tool execution (like AI Agent)
logger.debug(f"[ChatAgent] Using LangGraph with {len(all_tools)} tools")
diff --git a/server/services/deep_agent_service.py b/server/services/deep_agent_service.py
new file mode 100644
index 00000000..513ade45
--- /dev/null
+++ b/server/services/deep_agent_service.py
@@ -0,0 +1,170 @@
+"""DeepAgent execution service.
+
+Follows the same interface as RLMService but replaces LangGraph with
+deepagents.create_deep_agent() for graph creation.
+"""
+
+import time
+from datetime import datetime
+from typing import Dict, Any, List, Optional
+
+from core.logging import get_logger, log_execution_time, log_api_call
+
+logger = get_logger(__name__)
+
+# MachinaOs provider -> deepagents model prefix.
+# deepagents uses "provider:model" strings (see deepagents.utils.resolve_model).
+# Only gemini differs; all others use their MachinaOs name directly.
+_PROVIDER_PREFIX = {"gemini": "google_genai"}
+
+
+class DeepAgentService:
+ """Dedicated service for Deep Agent execution.
+
+ Injected into AIService via composition,
+ following the same pattern as RLMService.
+ """
+
+ def __init__(self, auth=None):
+ self.auth = auth
+
+ async def execute(
+ self,
+ node_id: str,
+ parameters: Dict[str, Any],
+ skill_data: Optional[List[Dict[str, Any]]] = None,
+ tools: Optional[List] = None,
+ teammates: Optional[List[Dict[str, Any]]] = None,
+ broadcaster=None,
+ workflow_id: Optional[str] = None,
+ database=None,
+ ) -> Dict[str, Any]:
+ """Execute Deep Agent via deepagents.create_deep_agent().
+
+ Same interface pattern as RLMService.execute().
+ Reuses existing MachinaOS utilities for shared concerns.
+ """
+ start_time = time.time()
+
+ async def broadcast_status(phase: str, details: Dict[str, Any] = None):
+ if broadcaster:
+ await broadcaster.update_node_status(node_id, "executing", {
+ "phase": phase, "agent_type": "deep_agent", **(details or {})
+ }, workflow_id=workflow_id)
+
+ try:
+ # === Parameter extraction (same pattern as RLMService) ===
+ prompt = parameters.get('prompt', '')
+ system_message = parameters.get('systemMessage', 'You are a helpful assistant')
+
+ # Skill injection (reuse ai.py _build_skill_system_prompt)
+ from services.ai import _build_skill_system_prompt
+ skill_prompt, has_personality = _build_skill_system_prompt(
+ skill_data, log_prefix="[DeepAgent]"
+ )
+ if skill_prompt:
+ if has_personality:
+ system_message = skill_prompt
+ else:
+ system_message = f"{system_message}\n\n{skill_prompt}"
+
+ # Options flattening (same as execute_chat_agent)
+ options = parameters.get('options', {})
+ flattened = {**parameters, **options}
+
+ # Provider/model resolution (reuse ai.py module-level helpers)
+ from services.ai import is_model_valid_for_provider, get_default_model_async
+ provider = parameters.get('provider', 'openai')
+ model = parameters.get('model', '')
+
+ if not model or not is_model_valid_for_provider(model, provider):
+ model = await get_default_model_async(provider, database)
+
+ api_key = flattened.get('api_key') or flattened.get('apiKey')
+ if not api_key and self.auth:
+ api_key = await self.auth.get_api_key(provider)
+ if not api_key:
+ raise ValueError(f"API key required for Deep Agent (provider: {provider})")
+
+ await broadcast_status("initializing", {
+ "message": f"Initializing Deep Agent with {provider}/{model}",
+ "provider": provider, "model": model,
+ })
+
+ # === Build deepagents model string ===
+ prefix = _PROVIDER_PREFIX.get(provider, provider)
+ model_id = f"{prefix}:{model}"
+
+ # === Convert teammates to deepagents SubAgent dicts ===
+ subagents = None
+ if teammates:
+ subagents = [
+ {
+ "name": tm.get("label", tm.get("node_type", "agent")),
+ "description": f"Delegate tasks to {tm.get('label', tm.get('node_type', 'agent'))}",
+ "system_prompt": tm.get("system_prompt", ""),
+ }
+ for tm in teammates
+ ]
+
+ # === Create and invoke deep agent ===
+ from deepagents import create_deep_agent
+
+ max_turns = int(parameters.get('maxTurns', 25))
+
+ await broadcast_status("executing", {
+ "message": f"Running Deep Agent ({model_id})...",
+ "tool_count": len(tools or []),
+ })
+
+ agent = create_deep_agent(
+ model=model_id,
+ tools=tools or None,
+ system_prompt=system_message,
+ subagents=subagents,
+ )
+
+ result = await agent.ainvoke(
+ {"messages": [{"role": "user", "content": prompt}]},
+ config={"recursion_limit": max_turns * 2},
+ )
+
+ # === Extract final AI response ===
+ messages = result.get("messages", [])
+ response_content = ""
+ for msg in reversed(messages):
+ if getattr(msg, "type", None) == "ai" and hasattr(msg, "content"):
+ response_content = msg.content if isinstance(msg.content, str) else str(msg.content)
+ break
+
+ log_execution_time(logger, "deep_agent", start_time, time.time())
+ log_api_call(logger, provider, model, "deep_agent", True)
+
+ return {
+ "success": True,
+ "node_id": node_id,
+ "node_type": "deep_agent",
+ "result": {
+ "response": response_content,
+ "model": model,
+ "provider": provider,
+ "messages_count": len(messages),
+ "finish_reason": "stop",
+ "timestamp": datetime.now().isoformat(),
+ },
+ "execution_time": time.time() - start_time,
+ }
+
+ except Exception as e:
+ logger.error("[DeepAgent] Execution failed", node_id=node_id, error=str(e))
+ log_api_call(logger, provider if 'provider' in dir() else 'unknown',
+ model if 'model' in dir() else 'unknown',
+ "deep_agent", False, error=str(e))
+ return {
+ "success": False,
+ "node_id": node_id,
+ "node_type": "deep_agent",
+ "error": str(e),
+ "execution_time": time.time() - start_time,
+ "timestamp": datetime.now().isoformat(),
+ }
diff --git a/server/services/handlers/__init__.py b/server/services/handlers/__init__.py
index b0db7ae5..e95dc8dd 100644
--- a/server/services/handlers/__init__.py
+++ b/server/services/handlers/__init__.py
@@ -117,6 +117,9 @@ from .crawlee import handle_crawlee_scraper
# RLM agent handler
from .rlm import handle_rlm_agent
+# Deep Agent handler
+from .deep_agent import handle_deep_agent
+
# Tool execution handlers (for AI Agent tool calling)
from .tools import (
execute_tool,
@@ -186,6 +189,8 @@ __all__ = [
'handle_crawlee_scraper',
# RLM
'handle_rlm_agent',
+ # Deep Agent
+ 'handle_deep_agent',
# Tools
'execute_tool',
'handle_task_manager',
diff --git a/server/services/handlers/ai.py b/server/services/handlers/ai.py
index 5c7e98bf..3982e980 100644
--- a/server/services/handlers/ai.py
+++ b/server/services/handlers/ai.py
@@ -11,7 +11,7 @@ if TYPE_CHECKING:
logger = get_logger(__name__)
# Team lead types that can create teams
-TEAM_LEAD_TYPES = {'orchestrator_agent', 'ai_employee', 'deep_agent'}
+TEAM_LEAD_TYPES = {'orchestrator_agent', 'ai_employee'}
async def _collect_agent_connections(
@@ -550,6 +550,7 @@ async def handle_chat_agent(
})
logger.info(f"[Teams] Added {len(teammates)} teammates as delegation tools")
+ # Standard execution (no team mode)
return await ai_service.execute_chat_agent(
node_id,
parameters,
@@ -559,8 +560,7 @@ async def handle_chat_agent(
broadcaster=broadcaster,
workflow_id=workflow_id,
context=context,
- database=database,
- node_type=node_type,
+ database=database
)
diff --git a/server/services/handlers/deep_agent.py b/server/services/handlers/deep_agent.py
new file mode 100644
index 00000000..30856e55
--- /dev/null
+++ b/server/services/handlers/deep_agent.py
@@ -0,0 +1,90 @@
+"""Deep Agent handler -- thin wrapper following handle_rlm_agent pattern.
+
+Collects connections, builds tools, delegates to DeepAgentService.
+"""
+
+from typing import Dict, Any, TYPE_CHECKING
+from core.logging import get_logger
+
+if TYPE_CHECKING:
+ from services.ai import AIService
+ from core.database import Database
+
+logger = get_logger(__name__)
+
+
+async def handle_deep_agent(
+ node_id: str,
+ node_type: str,
+ parameters: Dict[str, Any],
+ context: Dict[str, Any],
+ ai_service: "AIService",
+ database: "Database",
+) -> Dict[str, Any]:
+ """Handle Deep Agent node execution.
+
+ Follows handle_rlm_agent pattern:
+ 1. _collect_agent_connections() [REUSE]
+ 2. _collect_teammate_connections() [REUSE]
+ 3. _format_task_context() [REUSE]
+ 4. Tool stripping on task completion [REUSE]
+ 5. Auto-prompt fallback [REUSE]
+ 6. Build LangChain tools from tool_data [ai_service._build_tool_from_node]
+ 7. Delegate to DeepAgentService.execute()
+ """
+ from .ai import _collect_agent_connections, _collect_teammate_connections, _format_task_context
+ from services.status_broadcaster import get_status_broadcaster
+
+ workflow_id = context.get('workflow_id')
+
+ # 1. Collect connections
+ memory_data, skill_data, tool_data, input_data, task_data = await _collect_agent_connections(
+ node_id, context, database, log_prefix="[Deep Agent]"
+ )
+
+ # 2. Task context injection
+ if task_data:
+ task_context = _format_task_context(task_data)
+ original_prompt = parameters.get('prompt', '')
+ parameters = {**parameters, 'prompt': f"{task_context}\n\n{original_prompt}"}
+
+ task_status = task_data.get('status', '')
+ if task_status in ('completed', 'error') and tool_data:
+ tool_data = []
+
+ # 3. Auto-prompt fallback
+ if not parameters.get('prompt') and input_data:
+ prompt = (
+ input_data.get('message') or
+ input_data.get('text') or
+ input_data.get('content') or
+ str(input_data)
+ )
+ parameters = {**parameters, 'prompt': prompt}
+
+ # 4. Build LangChain tools from connected tool nodes
+ built_tools = []
+ if tool_data:
+ for tool_info in tool_data:
+ try:
+ tool, _config = await ai_service._build_tool_from_node(tool_info)
+ if tool:
+ built_tools.append(tool)
+ except Exception as e:
+ logger.warning("[Deep Agent] Failed to build tool from %s: %s",
+ tool_info.get("node_type"), e)
+
+ # 5. Collect teammates for sub-agent delegation
+ teammates = await _collect_teammate_connections(node_id, context, database)
+
+ # 6. Delegate to DeepAgentService
+ broadcaster = get_status_broadcaster()
+ return await ai_service.deep_agent_service.execute(
+ node_id, parameters,
+ skill_data=skill_data if skill_data else None,
+ tools=built_tools if built_tools else None,
+ teammates=teammates if teammates else None,
+ broadcaster=broadcaster,
+ workflow_id=workflow_id,
+ database=database,
+ )
diff --git a/server/services/node_executor.py b/server/services/node_executor.py
index 8ed1728c..9bd59d46 100644
--- a/server/services/node_executor.py
+++ b/server/services/node_executor.py
@@ -41,6 +41,7 @@ from services.handlers import (
handle_rlm_agent,
)
from services.handlers.claude_code import handle_claude_code_agent
+from services.handlers.deep_agent import handle_deep_agent
from services.handlers.telegram import handle_telegram_send
from services.handlers.apify import handle_apify_actor
from services.handlers.crawlee import handle_crawlee_scraper
@@ -138,7 +139,7 @@ class NodeExecutor:
'autonomous_agent': partial(handle_chat_agent, ai_service=self.ai_service, database=self.database),
'orchestrator_agent': partial(handle_chat_agent, ai_service=self.ai_service, database=self.database),
'ai_employee': partial(handle_chat_agent, ai_service=self.ai_service, database=self.database),
- 'deep_agent': partial(handle_chat_agent, ai_service=self.ai_service, database=self.database),
+ 'deep_agent': partial(handle_deep_agent, ai_service=self.ai_service, database=self.database),
'rlm_agent': partial(handle_rlm_agent, ai_service=self.ai_service, database=self.database),
'claude_code_agent': partial(handle_claude_code_agent, ai_service=self.ai_service, database=self.database),
'simpleMemory': handle_simple_memory,