Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
refactor: modularize deep agent into services/agents/ package
trohitgc9499f3e4fb7
diff --git a/CLAUDE.md b/CLAUDE.mdindex 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.mdindex 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_data2. _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|vdeepagents.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__.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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 = 25diff --git a/server/services/agents/service.py b/server/services/agents/service.pynew file mode 100644index 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.pyindex 76904a28..eabc168f 100644--- a/server/services/ai.py+++ b/server/services/ai.py@@ -905,8 +905,8 @@ class AIService:from services.rlm import RLMServiceself.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.pydeleted file mode 100644index 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.pyindex 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_CHECKINGfrom core.logging import get_loggerif 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_contextfrom services.status_broadcaster import get_status_broadcasterworkflow_id = context.get('workflow_id')- broadcaster = get_status_broadcaster()# 1. Collect connectionsmemory_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 teammatesteammates = 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,