Skip to content

Self-improving AI Employees for everyone

refactor: modularize deep agent into services/agents/ package

trohitgc9499f3e4fb7
diff --git a/CLAUDE.md b/CLAUDE.md
index cd6b0041..cceb56ac 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -91,6 +91,11 @@ server/services/
│ ├── openai.py # OpenAIProvider (openai SDK)
│ ├── gemini.py # GeminiProvider (google-genai SDK)
│ └── openrouter.py # OpenRouterProvider (extends OpenAIProvider)
+├── agents/ # Deep Agent execution engine (deepagents package)
+│ ├── __init__.py # Exports DeepAgentService
+│ ├── service.py # Orchestration: graph creation + invocation
+│ ├── adapters.py # ToolAdapter, SubAgentAdapter, ResponseExtractor
+│ └── constants.py # PROVIDER_PREFIX, DEFAULT_MAX_TURNS
├── proxy/ # Residential proxy provider management
│ ├── __init__.py # Exports get_proxy_service, ProxyService
│ ├── service.py # ProxyService singleton - provider selection, URL generation
@@ -829,7 +834,7 @@ SPECIALIZED_AGENT_TYPES = {
'autonomous_agent', 'orchestrator_agent', 'ai_employee',
}
# rlm_agent routes to handle_rlm_agent -> RLMService (dedicated handler + service)
-# deep_agent routes to handle_deep_agent -> DeepAgentService (dedicated handler + service)
+# deep_agent routes to handle_deep_agent -> DeepAgentService (services/agents/ package)
```
**Team Lead Types (Agent Teams Pattern):**
diff --git a/docs-internal/deep_agent.md b/docs-internal/deep_agent.md
index 44a37197..220950d8 100644
--- a/docs-internal/deep_agent.md
+++ b/docs-internal/deep_agent.md
@@ -61,20 +61,21 @@ handle_deep_agent() server/services/handlers/deep_agent.py
- input-task -> task_data
2. _format_task_context() [REUSE from handlers/ai.py]
3. Auto-prompt fallback [same pattern as handle_rlm_agent]
- 4. _build_tool_from_node() -> schema stubs
- _make_executable_tool() -> real async coroutines
- 5. _collect_teammate_connections() [REUSE from handlers/ai.py]
- 6. Delegates to ai_service.deep_agent_service.execute()
+ 4. _collect_teammate_connections() [REUSE from handlers/ai.py]
+ 5. Passes raw tool_data + build_tool_fn to service
|
v
-DeepAgentService.execute() server/services/deep_agent_service.py
- Reuses module-level helpers from ai.py:
- - _build_skill_system_prompt() -> system_message
- - is_model_valid_for_provider(), get_default_model_async()
- - _resolve_max_tokens(), _resolve_temperature()
- - self._create_model() -> pre-built BaseChatModel
- - _parse_memory_markdown(), _get_memory_vector_store() [memory load]
- - _append_to_memory_markdown(), _trim_markdown_window() [memory save]
+DeepAgentService.execute() server/services/agents/service.py
+ Orchestration only -- delegates to adapters and shared helpers:
+ - _build_skill_system_prompt() [ai.py] -> system_message
+ - is_model_valid_for_provider() [ai.py] -> model validation
+ - self._create_model() [ai.py] -> pre-built BaseChatModel
+ - ToolAdapter.build_tools() [agents/adapters.py] -> executable tools
+ - SubAgentAdapter.convert() [agents/adapters.py] -> deepagents SubAgent dicts
+ - _parse_memory_markdown() [ai.py] -> memory load
+ - create_deep_agent() + ainvoke() [deepagents] -> graph execution
+ - ResponseExtractor.extract() [agents/adapters.py] -> response + thinking
+ - _append_to_memory_markdown() [ai.py] -> memory save
|
v
deepagents.create_deep_agent() deepagents package
@@ -89,7 +90,7 @@ agent.ainvoke(messages) LangGraph CompiledStateGraph
-> Summarization -> ToolCallPatching -> PromptCaching
|
v
-Extract response + thinking -> save memory -> return result
+ResponseExtractor.extract() -> save memory -> return result
```
---
@@ -169,12 +170,23 @@ Custom tools passed via `tools=` parameter are added alongside (not replacing) t
### Execution Path
-Deep Agent has a **dedicated handler and service** following the RLMService pattern:
+Deep Agent has a **dedicated handler and modular service package** following the RLMService pattern:
-- **Handler** (`handlers/deep_agent.py`): Thin wrapper that collects connections, builds executable tools, delegates to service
-- **Service** (`deep_agent_service.py`): Execution engine that handles skill injection, model resolution, memory lifecycle, and `create_deep_agent()` invocation
+- **Handler** (`handlers/deep_agent.py`): Thin wrapper that collects connections, passes raw `tool_data` to service
+- **Service package** (`services/agents/`): Modular execution engine split into:
+ - `service.py` -- Orchestration: calls adapters and shared helpers
+ - `adapters.py` -- Protocol translation: `ToolAdapter`, `SubAgentAdapter`, `ResponseExtractor`
+ - `constants.py` -- Provider mappings and defaults
- **Composition**: `AIService.__init__` creates `self.deep_agent_service = DeepAgentService(auth=self.auth, model_factory=self.create_model)`
+```
+server/services/agents/ (mirrors services/rlm/)
+ __init__.py - Public API: exports DeepAgentService
+ service.py - Orchestration only
+ adapters.py - ToolAdapter, SubAgentAdapter, ResponseExtractor
+ constants.py - PROVIDER_PREFIX, DEFAULT_MAX_TURNS
+```
+
### Reused Helpers (from ai.py)
| Helper | Used For |
@@ -201,28 +213,24 @@ Deep Agent has a **dedicated handler and service** following the RLMService patt
`_build_tool_from_node()` returns schema-only stubs with `placeholder_func` that echo kwargs back. deepagents' `ToolNode` calls `tool.ainvoke()` directly, so these stubs fail silently.
### Solution
-The handler wraps each stub with a real async coroutine via `_make_executable_tool()`:
+`ToolAdapter` (in `agents/adapters.py`) wraps each schema-only stub with a real async coroutine:
```python
-def _make_executable_tool(tool, config, workflow_id, broadcaster):
- async def _execute(**kwargs):
- from services.handlers.tools import execute_tool
- # Broadcast glow effect to tool node
- # Call execute_tool(tool_name, kwargs, config)
- # Broadcast success/error
- return result
-
- return StructuredTool.from_function(
- name=tool.name,
- description=tool.description,
- coroutine=_execute,
- args_schema=tool.get_input_schema(),
- )
+# agents/adapters.py - ToolAdapter._wrap()
+async def _execute(**kwargs):
+ from services.handlers.tools import execute_tool
+ result = await execute_tool(tool_name, kwargs, config)
+ return result
+
+return StructuredTool.from_function(
+ coroutine=_execute,
+ args_schema=tool.get_input_schema(),
+)
```
This follows the deepagents pattern: `StructuredTool.from_function(coroutine=async_fn, args_schema=...)`.
-Connected MachinaOs tools (calculator, search, WhatsApp, etc.) execute via `handlers/tools.py execute_tool()`, with real-time glow effects broadcast to tool nodes.
+The handler passes raw `tool_data` to the service, which calls `ToolAdapter.build_tools()` to build executable tools. Connected MachinaOs tools (calculator, search, WhatsApp, etc.) execute via `handlers/tools.py execute_tool()`, with real-time glow effects broadcast to tool nodes.
---
@@ -314,20 +322,36 @@ Matches `execute_chat_agent` format for frontend compatibility:
## Key Files
+### Service Package (`server/services/agents/`)
+| File | Description |
+|------|-------------|
+| `server/services/agents/__init__.py` | Public API: exports `DeepAgentService` |
+| `server/services/agents/service.py` | Orchestration: calls adapters, shared helpers, `create_deep_agent()` |
+| `server/services/agents/adapters.py` | `ToolAdapter`, `SubAgentAdapter`, `ResponseExtractor` |
+| `server/services/agents/constants.py` | `PROVIDER_PREFIX`, `DEFAULT_MAX_TURNS` |
+
+### Handler and Wiring
| File | Description |
|------|-------------|
-| `server/services/deep_agent_service.py` | DeepAgentService execution engine |
-| `server/services/handlers/deep_agent.py` | Thin handler with `_make_executable_tool()` |
+| `server/services/handlers/deep_agent.py` | Thin handler: collects connections, passes raw tool_data |
+| `server/services/handlers/__init__.py` | Import/export `handle_deep_agent` |
| `server/services/ai.py` | AIService.__init__ composes `self.deep_agent_service` |
| `server/services/node_executor.py` | Handler registry entry |
-| `server/services/handlers/__init__.py` | Import/export |
| `server/services/handlers/tools.py` | Delegation tuple |
| `server/constants.py` | `AI_AGENT_TYPES` |
+
+### Frontend
+| File | Description |
+|------|-------------|
| `client/src/nodeDefinitions/specializedAgentNodes.ts` | Node definition + `SPECIALIZED_AGENT_TYPES` |
| `client/src/components/AIAgentNode.tsx` | `AGENT_CONFIGS` visual entry |
| `client/src/components/parameterPanel/MiddleSection.tsx` | `AGENT_WITH_SKILLS_TYPES` |
| `client/src/components/parameterPanel/InputSection.tsx` | `AGENT_WITH_SKILLS_TYPES` + `aiAgentTypes` |
| `client/src/contexts/WebSocketContext.tsx` | `LONG_RUNNING_NODE_TYPES` |
+
+### Dependencies
+| File | Description |
+|------|-------------|
| `server/requirements.txt` | `deepagents>=0.4.12` |
| `server/pyproject.toml` | `deepagents>=0.4.12` |
diff --git a/server/services/agents/__init__.py b/server/services/agents/__init__.py
new file mode 100644
index 00000000..a24917cf
--- /dev/null
+++ b/server/services/agents/__init__.py
@@ -0,0 +1,9 @@
+"""DeepAgent service module.
+
+Provides DeepAgentService for executing deep agent completions
+via LangChain deepagents package within MachinaOS.
+"""
+
+from .service import DeepAgentService
+
+__all__ = ["DeepAgentService"]
diff --git a/server/services/agents/adapters.py b/server/services/agents/adapters.py
new file mode 100644
index 00000000..13185b8f
--- /dev/null
+++ b/server/services/agents/adapters.py
@@ -0,0 +1,167 @@
+"""Deep Agent adapters -- protocol translation between MachinaOs and deepagents.
+
+Follows the same pattern as rlm/adapters.py:
+- ToolAdapter: wraps schema-only tools with real executors
+- SubAgentAdapter: converts teammates to deepagents SubAgent dicts
+- ResponseExtractor: extracts response + thinking from multi-format messages
+"""
+
+from typing import Any, Dict, List, Optional
+
+from langchain_core.tools import StructuredTool
+from core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class ToolAdapter:
+ """Wraps schema-only StructuredTools with real async executors.
+
+ _build_tool_from_node() returns tools with placeholder_func (schema only).
+ deepagents' ToolNode calls tool.ainvoke() directly, so each tool needs
+ a real coroutine calling execute_tool() from handlers/tools.py.
+ """
+
+ @staticmethod
+ def build_tools(
+ tool_data: List[Dict[str, Any]],
+ build_tool_fn,
+ workflow_id: str = None,
+ broadcaster=None,
+ ) -> List[StructuredTool]:
+ """Build executable tools from raw tool_data.
+
+ Args:
+ tool_data: Raw tool info dicts from _collect_agent_connections.
+ build_tool_fn: AIService._build_tool_from_node (async).
+ workflow_id: For scoped status broadcasts.
+ broadcaster: For tool node glow effects.
+
+ Returns:
+ List of StructuredTools with real async executors.
+ """
+ # Return coroutine - must be awaited
+ return ToolAdapter._build_tools_async(tool_data, build_tool_fn, workflow_id, broadcaster)
+
+ @staticmethod
+ async def _build_tools_async(tool_data, build_tool_fn, workflow_id, broadcaster):
+ executable = []
+ for tool_info in tool_data:
+ try:
+ tool, config = await build_tool_fn(tool_info)
+ if tool and config:
+ executable.append(
+ ToolAdapter._wrap(tool, config, workflow_id, broadcaster)
+ )
+ except Exception as e:
+ logger.warning("[DeepAgent] Failed to build tool from %s: %s",
+ tool_info.get("node_type"), e)
+ return executable
+
+ @staticmethod
+ def _wrap(tool: StructuredTool, config: Dict, workflow_id: str, broadcaster) -> StructuredTool:
+ """Replace placeholder func with a real async executor."""
+ tool_name = tool.name
+ tool_node_id = config.get('node_id')
+
+ async def _execute(**kwargs) -> Any:
+ from services.handlers.tools import execute_tool
+
+ if tool_node_id and broadcaster:
+ await broadcaster.update_node_status(
+ tool_node_id, "executing",
+ {"message": f"Executing {tool_name}"},
+ workflow_id=workflow_id,
+ )
+
+ cfg = {**config, 'workflow_id': workflow_id}
+ try:
+ result = await execute_tool(tool_name, kwargs, cfg)
+ if tool_node_id and broadcaster:
+ await broadcaster.update_node_status(
+ tool_node_id, "success",
+ {"message": f"{tool_name} completed"},
+ workflow_id=workflow_id,
+ )
+ return result
+ except Exception as e:
+ logger.error("[DeepAgent] Tool %s failed: %s", tool_name, e)
+ if tool_node_id and broadcaster:
+ await broadcaster.update_node_status(
+ tool_node_id, "error",
+ {"message": str(e)},
+ workflow_id=workflow_id,
+ )
+ return {"error": str(e)}
+
+ return StructuredTool.from_function(
+ name=tool.name,
+ description=tool.description,
+ coroutine=_execute,
+ args_schema=tool.get_input_schema(),
+ )
+
+
+class SubAgentAdapter:
+ """Converts MachinaOs teammate dicts to deepagents SubAgent format."""
+
+ @staticmethod
+ def convert(teammates: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+ return [
+ {
+ "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
+ ]
+
+
+class ResponseExtractor:
+ """Extracts response text, thinking content, and iteration count from messages."""
+
+ @staticmethod
+ def extract(messages: list) -> Dict[str, Any]:
+ """Extract response, thinking, and iterations from deepagents result messages.
+
+ Returns:
+ Dict with keys: response, thinking, iterations
+ """
+ response_content = ""
+ thinking_content = None
+ iterations = 0
+
+ # Count iterations (tool-call messages indicate agent loops)
+ for msg in messages:
+ if getattr(msg, "type", None) == "ai" and getattr(msg, "tool_calls", None):
+ iterations += 1
+
+ # Extract final AI response
+ for msg in reversed(messages):
+ if getattr(msg, "type", None) == "ai" and hasattr(msg, "content"):
+ raw = msg.content
+
+ # Handle list content (Gemini format)
+ if isinstance(raw, list):
+ parts = []
+ for block in raw:
+ if isinstance(block, dict) and block.get("type") == "text":
+ parts.append(block.get("text", ""))
+ elif isinstance(block, str):
+ parts.append(block)
+ response_content = "\n".join(parts)
+ elif isinstance(raw, str):
+ response_content = raw
+ else:
+ response_content = str(raw)
+
+ # Extract thinking
+ from services.ai import extract_thinking_from_response
+ _, thinking_content = extract_thinking_from_response(msg)
+ break
+
+ return {
+ "response": response_content,
+ "thinking": thinking_content,
+ "iterations": max(iterations, 1),
+ }
diff --git a/server/services/agents/constants.py b/server/services/agents/constants.py
new file mode 100644
index 00000000..d9808090
--- /dev/null
+++ b/server/services/agents/constants.py
@@ -0,0 +1,10 @@
+"""Deep Agent constants and provider mappings."""
+
+# 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",
+}
+
+DEFAULT_MAX_TURNS = 25
diff --git a/server/services/agents/service.py b/server/services/agents/service.py
new file mode 100644
index 00000000..515a5739
--- /dev/null
+++ b/server/services/agents/service.py
@@ -0,0 +1,256 @@
+"""DeepAgent execution service -- orchestration only.
+
+Delegates to adapters for protocol translation and reuses
+shared helpers from ai.py for config resolution and memory.
+"""
+
+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
+from .adapters import ToolAdapter, SubAgentAdapter, ResponseExtractor
+from .constants import DEFAULT_MAX_TURNS
+
+logger = get_logger(__name__)
+
+
+class DeepAgentService:
+ """Dedicated service for Deep Agent execution.
+
+ Injected into AIService via composition,
+ following the same pattern as RLMService.
+ """
+
+ def __init__(self, auth=None, model_factory=None, token_tracker=None):
+ self.auth = auth
+ self._create_model = model_factory
+ self._track_token_usage = token_tracker
+
+ async def execute(
+ self,
+ node_id: str,
+ parameters: Dict[str, Any],
+ memory_data: Optional[Dict[str, Any]] = None,
+ skill_data: Optional[List[Dict[str, Any]]] = None,
+ tool_data: Optional[List[Dict[str, Any]]] = None,
+ teammates: Optional[List[Dict[str, Any]]] = None,
+ build_tool_fn=None,
+ broadcaster=None,
+ workflow_id: Optional[str] = None,
+ database=None,
+ ) -> Dict[str, Any]:
+ """Execute Deep Agent via deepagents.create_deep_agent().
+
+ Receives raw tool_data (not pre-built tools). Builds executable
+ tools via ToolAdapter, converts teammates via SubAgentAdapter,
+ extracts response via ResponseExtractor.
+ """
+ start_time = time.time()
+ provider = 'unknown'
+ model = 'unknown'
+
+ 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 + skill injection ===
+ from services.ai import _build_skill_system_prompt
+ prompt = parameters.get('prompt', '')
+ system_message = parameters.get('systemMessage', 'You are a helpful assistant')
+
+ skill_prompt, has_personality = _build_skill_system_prompt(skill_data, log_prefix="[DeepAgent]")
+ if skill_prompt:
+ system_message = skill_prompt if has_personality else f"{system_message}\n\n{skill_prompt}"
+
+ # === Provider/model/API key resolution ===
+ from services.ai import (
+ is_model_valid_for_provider, get_default_model_async,
+ _resolve_max_tokens, _resolve_temperature, ThinkingConfig,
+ )
+ options = parameters.get('options', {})
+ flattened = {**parameters, **options}
+
+ provider = parameters.get('provider', 'openai')
+ model = parameters.get('model', '')
+ if model.startswith('[FREE] '):
+ model = model[7:]
+ 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})")
+
+ max_tokens = _resolve_max_tokens(flattened, model, provider)
+ thinking_config = None
+ if flattened.get('thinkingEnabled'):
+ thinking_config = ThinkingConfig(
+ enabled=True,
+ budget=int(flattened.get('thinkingBudget', 2048)),
+ effort=flattened.get('reasoningEffort', 'medium'),
+ level=flattened.get('thinkingLevel', 'medium'),
+ format=flattened.get('reasoningFormat', 'parsed'),
+ )
+ temperature = _resolve_temperature(flattened, model, provider, bool(thinking_config and thinking_config.enabled))
+ proxy_url = await self.auth.get_api_key(f"{provider}_proxy") if self.auth else None
+
+ await broadcast_status("initializing", {"message": f"Initializing Deep Agent with {provider}/{model}", "provider": provider, "model": model})
+
+ # === Model creation ===
+ chat_model = self._create_model(provider, api_key, model, temperature, max_tokens, thinking_config, proxy_url)
+
+ # === Build tools via ToolAdapter ===
+ executable_tools = []
+ if tool_data and build_tool_fn:
+ await broadcast_status("building_tools", {"message": f"Building {len(tool_data)} tool(s)..."})
+ executable_tools = await ToolAdapter._build_tools_async(tool_data, build_tool_fn, workflow_id, broadcaster)
+
+ # === Convert teammates via SubAgentAdapter ===
+ subagents = SubAgentAdapter.convert(teammates) if teammates else None
+
+ # === Load memory ===
+ from services.ai import _parse_memory_markdown, _get_memory_vector_store
+ session_id = None
+ history_count = 0
+ memory_content = None
+ input_messages = []
+
+ if memory_data and memory_data.get('node_id'):
+ session_id = memory_data.get('session_id', 'default')
+ memory_content = memory_data.get('memory_content', '# Conversation History\n\n*No messages yet.*\n')
+
+ await broadcast_status("loading_memory", {"message": "Loading conversation history...", "session_id": session_id})
+
+ history_messages = _parse_memory_markdown(memory_content)
+ history_count = len(history_messages)
+
+ if memory_data.get('long_term_enabled'):
+ store = _get_memory_vector_store(session_id)
+ if store:
+ try:
+ docs = store.similarity_search(prompt, k=memory_data.get('retrieval_count', 3))
+ if docs:
+ system_message = f"{system_message}\n\nRelevant past context:\n" + "\n---\n".join(d.page_content for d in docs)
+ except Exception as e:
+ logger.debug("[DeepAgent Memory] Long-term retrieval skipped: %s", e)
+
+ for msg in history_messages:
+ input_messages.append({"role": getattr(msg, "type", "user"), "content": msg.content})
+
+ input_messages.append({"role": "user", "content": prompt})
+
+ # === Create and invoke deep agent ===
+ from deepagents import create_deep_agent
+ max_turns = int(parameters.get('maxTurns', DEFAULT_MAX_TURNS))
+
+ await broadcast_status("executing", {"message": f"Running Deep Agent ({provider}/{model})...", "tool_count": len(executable_tools)})
+
+ agent = create_deep_agent(
+ model=chat_model,
+ tools=executable_tools or None,
+ system_prompt=system_message,
+ subagents=subagents,
+ )
+ result = await agent.ainvoke(
+ {"messages": input_messages},
+ config={"recursion_limit": max_turns * 2},
+ )
+
+ # === Extract response via ResponseExtractor ===
+ messages = result.get("messages", [])
+ extracted = ResponseExtractor.extract(messages)
+
+ # === Track token usage (same as execute_chat_agent) ===
+ compaction_result = None
+ if session_id and self._track_token_usage:
+ # Find last AI message for usage_metadata
+ ai_response = None
+ for msg in reversed(messages):
+ if getattr(msg, "type", None) == "ai":
+ ai_response = msg
+ break
+ if ai_response:
+ compaction_result = await self._track_token_usage(
+ session_id=session_id,
+ node_id=node_id,
+ provider=provider,
+ model=model,
+ ai_response=ai_response,
+ all_messages=messages,
+ broadcaster=broadcaster,
+ workflow_id=workflow_id,
+ memory_content=memory_content,
+ api_key=api_key,
+ memory_node_id=memory_data.get('node_id') if memory_data else None,
+ )
+
+ # === Save memory ===
+ from services.ai import _append_to_memory_markdown, _trim_markdown_window, is_valid_message_content
+ if memory_data and memory_data.get('node_id') and is_valid_message_content(prompt) and is_valid_message_content(extracted["response"]):
+ await broadcast_status("saving_memory", {"message": "Saving to conversation memory...", "session_id": session_id})
+
+ # If compaction happened, use compacted summary as base
+ if compaction_result and compaction_result.get('success') and compaction_result.get('summary'):
+ updated = compaction_result['summary']
+ else:
+ updated = memory_content or '# Conversation History\n\n*No messages yet.*\n'
+ updated = _append_to_memory_markdown(updated, 'human', prompt)
+ updated = _append_to_memory_markdown(updated, 'ai', extracted["response"])
+ updated, removed = _trim_markdown_window(updated, memory_data.get('window_size', 10))
+
+ if removed and memory_data.get('long_term_enabled'):
+ store = _get_memory_vector_store(session_id)
+ if store:
+ try:
+ store.add_texts(removed)
+ except Exception as e:
+ logger.warning("[DeepAgent Memory] Failed to archive: %s", e)
+
+ if database:
+ params = await database.get_node_parameters(memory_data['node_id']) or {}
+ params['memoryContent'] = updated
+ await database.save_node_parameters(memory_data['node_id'], params)
+
+ log_execution_time(logger, "deep_agent", start_time, time.time())
+ log_api_call(logger, provider, model, "deep_agent", True)
+
+ # === Build result (matches execute_chat_agent format) ===
+ agent_type = "deep_agent"
+ if skill_data and executable_tools:
+ agent_type = "deep_agent_with_skills_and_tools"
+ elif skill_data:
+ agent_type = "deep_agent_with_skills"
+ elif executable_tools:
+ agent_type = "deep_agent_with_tools"
+
+ result_data = {
+ "response": extracted["response"],
+ "thinking": extracted["thinking"],
+ "thinking_enabled": thinking_config.enabled if thinking_config else False,
+ "model": model, "provider": provider,
+ "agent_type": agent_type,
+ "iterations": extracted["iterations"],
+ "messages_count": len(messages),
+ "finish_reason": "stop",
+ "timestamp": datetime.now().isoformat(),
+ "input": {"prompt": prompt, "system_message": system_message},
+ }
+ if session_id:
+ result_data["memory"] = {"session_id": session_id, "history_loaded": history_count}
+ if skill_data:
+ result_data["skills"] = {"connected": [s.get('skill_name', s.get('node_type', '')) for s in skill_data], "count": len(skill_data)}
+ if executable_tools:
+ result_data["tools"] = {"connected": [t.name for t in executable_tools], "count": len(executable_tools)}
+
+ return {"success": True, "node_id": node_id, "node_type": "deep_agent", "result": result_data, "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, model, "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/ai.py b/server/services/ai.py
index 76904a28..eabc168f 100644
--- a/server/services/ai.py
+++ b/server/services/ai.py
@@ -905,8 +905,8 @@ class AIService:
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, model_factory=self.create_model)
+ from services.agents import DeepAgentService
+ self.deep_agent_service = DeepAgentService(auth=self.auth, model_factory=self.create_model, token_tracker=self._track_token_usage)
def detect_provider(self, model: str) -> str:
"""Detect AI provider from model name."""
diff --git a/server/services/deep_agent_service.py b/server/services/deep_agent_service.py
deleted file mode 100644
index efd94363..00000000
--- a/server/services/deep_agent_service.py
+++ /dev/null
@@ -1,330 +0,0 @@
-"""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__)
-
-
-class DeepAgentService:
- """Dedicated service for Deep Agent execution.
-
- Injected into AIService via composition,
- following the same pattern as RLMService.
- """
-
- def __init__(self, auth=None, model_factory=None):
- self.auth = auth
- self._create_model = model_factory
-
- async def execute(
- self,
- node_id: str,
- parameters: Dict[str, Any],
- memory_data: Optional[Dict[str, Any]] = None,
- 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().
- Result structure matches execute_chat_agent for frontend compatibility.
- """
- start_time = time.time()
- provider = 'unknown'
- model = 'unknown'
-
- 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', '')
-
- # Strip [FREE] prefix (OpenRouter models)
- if model.startswith('[FREE] '):
- model = model[7:]
-
- 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})")
-
- # Resolve max_tokens, temperature, thinking config (same as execute_chat_agent)
- from services.ai import _resolve_max_tokens, _resolve_temperature, ThinkingConfig
- max_tokens = _resolve_max_tokens(flattened, model, provider)
- thinking_config = None
- if flattened.get('thinkingEnabled'):
- thinking_config = ThinkingConfig(
- enabled=True,
- budget=int(flattened.get('thinkingBudget', 2048)),
- effort=flattened.get('reasoningEffort', 'medium'),
- level=flattened.get('thinkingLevel', 'medium'),
- format=flattened.get('reasoningFormat', 'parsed'),
- )
- temperature = _resolve_temperature(flattened, model, provider, bool(thinking_config and thinking_config.enabled))
-
- # Check for proxy URL
- proxy_url = await self.auth.get_api_key(f"{provider}_proxy") if self.auth else None
-
- await broadcast_status("initializing", {
- "message": f"Initializing Deep Agent with {provider}/{model}",
- "provider": provider, "model": model,
- })
-
- # === Build BaseChatModel with API key baked in ===
- chat_model = self._create_model(provider, api_key, model, temperature, max_tokens, thinking_config, proxy_url)
-
- # === 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
- ]
-
- # === Load memory if connected (same as execute_chat_agent) ===
- from services.ai import (
- _parse_memory_markdown, _get_memory_vector_store,
- _append_to_memory_markdown, _trim_markdown_window,
- is_valid_message_content,
- )
-
- session_id = None
- history_count = 0
- memory_content = None
- input_messages = []
-
- if memory_data and memory_data.get('node_id'):
- session_id = memory_data.get('session_id', 'default')
- memory_content = memory_data.get('memory_content', '# Conversation History\n\n*No messages yet.*\n')
-
- await broadcast_status("loading_memory", {
- "message": "Loading conversation history...",
- "session_id": session_id,
- })
-
- history_messages = _parse_memory_markdown(memory_content)
- history_count = len(history_messages)
-
- # Long-term memory retrieval
- if memory_data.get('long_term_enabled'):
- store = _get_memory_vector_store(session_id)
- if store:
- try:
- k = memory_data.get('retrieval_count', 3)
- docs = store.similarity_search(prompt, k=k)
- if docs:
- ctx = "\n---\n".join(d.page_content for d in docs)
- system_message = f"{system_message}\n\nRelevant past context:\n{ctx}"
- except Exception as e:
- logger.debug("[DeepAgent Memory] Long-term retrieval skipped: %s", e)
-
- # Convert history to dicts for deepagents message format
- for msg in history_messages:
- input_messages.append({"role": getattr(msg, "type", "user"), "content": msg.content})
-
- logger.info("[DeepAgent Memory] Loaded %d messages from markdown", history_count)
-
- # Build input messages: history + current prompt
- input_messages.append({"role": "user", "content": prompt})
-
- # === 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 ({provider}/{model})...",
- "tool_count": len(tools or []),
- })
-
- agent = create_deep_agent(
- model=chat_model,
- tools=tools or None,
- system_prompt=system_message,
- subagents=subagents,
- )
-
- result = await agent.ainvoke(
- {"messages": input_messages},
- config={"recursion_limit": max_turns * 2},
- )
-
- # === Extract response and thinking (same patterns as execute_chat_agent) ===
- messages = result.get("messages", [])
- response_content = ""
- thinking_content = None
- iterations = 0
-
- # Count iterations (tool-call messages indicate agent loops)
- for msg in messages:
- if getattr(msg, "type", None) == "ai" and getattr(msg, "tool_calls", None):
- iterations += 1
-
- # Extract final AI response
- for msg in reversed(messages):
- if getattr(msg, "type", None) == "ai" and hasattr(msg, "content"):
- raw_content = msg.content
-
- # Handle list content (Gemini format: [{type: "text", text: "..."}])
- if isinstance(raw_content, list):
- text_parts = []
- for block in raw_content:
- if isinstance(block, dict) and block.get("type") == "text":
- text_parts.append(block.get("text", ""))
- elif isinstance(block, str):
- text_parts.append(block)
- response_content = "\n".join(text_parts)
- elif isinstance(raw_content, str):
- response_content = raw_content
- else:
- response_content = str(raw_content)
-
- # Extract thinking from last AI message
- from services.ai import extract_thinking_from_response
- _, thinking_content = extract_thinking_from_response(msg)
- break
-
- iterations = max(iterations, 1)
-
- # === Save memory if connected (same as execute_chat_agent) ===
- if memory_data and memory_data.get('node_id') and is_valid_message_content(prompt) and is_valid_message_content(response_content):
- await broadcast_status("saving_memory", {
- "message": "Saving to conversation memory...",
- "session_id": session_id,
- })
-
- updated_content = memory_content or '# Conversation History\n\n*No messages yet.*\n'
- updated_content = _append_to_memory_markdown(updated_content, 'human', prompt)
- updated_content = _append_to_memory_markdown(updated_content, 'ai', response_content)
-
- # Trim to window size, archive removed to vector DB
- window_size = memory_data.get('window_size', 10)
- updated_content, removed_texts = _trim_markdown_window(updated_content, window_size)
-
- if removed_texts and memory_data.get('long_term_enabled'):
- store = _get_memory_vector_store(session_id)
- if store:
- try:
- store.add_texts(removed_texts)
- except Exception as e:
- logger.warning("[DeepAgent Memory] Failed to archive: %s", e)
-
- # Persist to database
- memory_node_id = memory_data['node_id']
- if database:
- current_params = await database.get_node_parameters(memory_node_id) or {}
- current_params['memoryContent'] = updated_content
- await database.save_node_parameters(memory_node_id, current_params)
- logger.info("[DeepAgent Memory] Saved markdown to memory node '%s'", memory_node_id)
-
- log_execution_time(logger, "deep_agent", start_time, time.time())
- log_api_call(logger, provider, model, "deep_agent", True)
-
- # === Build result matching execute_chat_agent format ===
- agent_type = "deep_agent"
- if skill_data and tools:
- agent_type = "deep_agent_with_skills_and_tools"
- elif skill_data:
- agent_type = "deep_agent_with_skills"
- elif tools:
- agent_type = "deep_agent_with_tools"
-
- result_data = {
- "response": response_content,
- "thinking": thinking_content,
- "thinking_enabled": thinking_config.enabled if thinking_config else False,
- "model": model,
- "provider": provider,
- "agent_type": agent_type,
- "iterations": iterations,
- "messages_count": len(messages),
- "finish_reason": "stop",
- "timestamp": datetime.now().isoformat(),
- "input": {
- "prompt": prompt,
- "system_message": system_message,
- },
- }
-
- if session_id:
- result_data["memory"] = {
- "session_id": session_id,
- "history_loaded": history_count,
- }
-
- if skill_data:
- result_data["skills"] = {
- "connected": [s.get('skill_name', s.get('node_type', '')) for s in skill_data],
- "count": len(skill_data),
- }
-
- if tools:
- result_data["tools"] = {
- "connected": [t.name for t in tools],
- "count": len(tools),
- }
-
- return {
- "success": True,
- "node_id": node_id,
- "node_type": "deep_agent",
- "result": result_data,
- "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, model, "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/deep_agent.py b/server/services/handlers/deep_agent.py
index e180b63c..0d04352b 100644
--- a/server/services/handlers/deep_agent.py
+++ b/server/services/handlers/deep_agent.py
@@ -1,10 +1,9 @@
"""Deep Agent handler -- thin wrapper following handle_rlm_agent pattern.
-Collects connections, builds executable tools, delegates to DeepAgentService.
+Collects connections, delegates to DeepAgentService.
"""
-from typing import Any, Dict, TYPE_CHECKING
-from langchain_core.tools import StructuredTool
+from typing import Dict, Any, TYPE_CHECKING
from core.logging import get_logger
if TYPE_CHECKING:
@@ -14,60 +13,6 @@ if TYPE_CHECKING:
logger = get_logger(__name__)
-def _make_executable_tool(
- tool: StructuredTool,
- config: Dict[str, Any],
- workflow_id: str = None,
- broadcaster=None,
-) -> StructuredTool:
- """Wrap a schema-only tool with a real async executor.
-
- _build_tool_from_node() returns tools with placeholder_func (schema only).
- deepagents' ToolNode calls tool.ainvoke() directly, so each tool needs
- a real coroutine. This follows the deepagents pattern:
- StructuredTool.from_function(coroutine=async_fn, args_schema=...)
- """
- tool_name = tool.name
- tool_node_id = config.get('node_id')
-
- async def _execute(**kwargs) -> Any:
- from services.handlers.tools import execute_tool
-
- if tool_node_id and broadcaster:
- await broadcaster.update_node_status(
- tool_node_id, "executing",
- {"message": f"Executing {tool_name}"},
- workflow_id=workflow_id,
- )
-
- cfg = {**config, 'workflow_id': workflow_id}
- try:
- result = await execute_tool(tool_name, kwargs, cfg)
- if tool_node_id and broadcaster:
- await broadcaster.update_node_status(
- tool_node_id, "success",
- {"message": f"{tool_name} completed"},
- workflow_id=workflow_id,
- )
- return result
- except Exception as e:
- logger.error("[Deep Agent] Tool %s failed: %s", tool_name, e)
- if tool_node_id and broadcaster:
- await broadcaster.update_node_status(
- tool_node_id, "error",
- {"message": str(e)},
- workflow_id=workflow_id,
- )
- return {"error": str(e)}
-
- return StructuredTool.from_function(
- name=tool.name,
- description=tool.description,
- coroutine=_execute,
- args_schema=tool.get_input_schema(),
- )
-
-
async def handle_deep_agent(
node_id: str,
node_type: str,
@@ -82,15 +27,13 @@ async def handle_deep_agent(
1. _collect_agent_connections() [REUSE]
2. _format_task_context() [REUSE]
3. Auto-prompt fallback [REUSE]
- 4. Build executable tools [_build_tool_from_node + _make_executable_tool]
- 5. Collect teammates [_collect_teammate_connections]
- 6. Delegate to DeepAgentService.execute()
+ 4. _collect_teammate_connections() [REUSE]
+ 5. 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')
- broadcaster = get_status_broadcaster()
# 1. Collect connections
memory_data, skill_data, tool_data, input_data, task_data = await _collect_agent_connections(
@@ -117,30 +60,18 @@ async def handle_deep_agent(
)
parameters = {**parameters, 'prompt': prompt}
- # 4. Build executable tools from connected tool nodes
- executable_tools = []
- if tool_data:
- for tool_info in tool_data:
- try:
- tool, config = await ai_service._build_tool_from_node(tool_info)
- if tool and config:
- executable_tools.append(
- _make_executable_tool(tool, config, workflow_id, broadcaster)
- )
- 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
+ # 4. Collect teammates
teammates = await _collect_teammate_connections(node_id, context, database)
- # 6. Delegate to DeepAgentService
+ # 5. Delegate to DeepAgentService (raw tool_data, service builds via ToolAdapter)
+ broadcaster = get_status_broadcaster()
return await ai_service.deep_agent_service.execute(
node_id, parameters,
memory_data=memory_data if memory_data else None,
skill_data=skill_data if skill_data else None,
- tools=executable_tools if executable_tools else None,
+ tool_data=tool_data if tool_data else None,
teammates=teammates if teammates else None,
+ build_tool_fn=ai_service._build_tool_from_node,
broadcaster=broadcaster,
workflow_id=workflow_id,
database=database,