machinaos 0.0.10 → 0.0.13

package/server/services/handlers/ai.py

@@ -2,7 +2,7 @@
 
 from typing import Dict, Any, List, Optional, Tuple, TYPE_CHECKING
 from core.logging import get_logger
-from constants import ANDROID_SERVICE_NODE_TYPES
+from constants import ANDROID_SERVICE_NODE_TYPES, AI_AGENT_TYPES
 
 if TYPE_CHECKING:
     from services.ai import AIService
@@ -16,14 +16,15 @@ async def _collect_agent_connections(
     context: Dict[str, Any],
     database: "Database",
     log_prefix: str = "[Agent]"
-) -> Tuple[Optional[Dict[str, Any]], List[Dict[str, Any]], List[Dict[str, Any]], Optional[Dict[str, Any]]]:
-    """Shared logic for collecting memory, skill, tool, and input data from connected nodes.
+) -> Tuple[Optional[Dict[str, Any]], List[Dict[str, Any]], List[Dict[str, Any]], Optional[Dict[str, Any]], Optional[Dict[str, Any]]]:
+    """Shared logic for collecting memory, skill, tool, input, and task data from connected nodes.
 
     Scans edges targeting the given node and collects:
     - Memory data from input-memory handle (simpleMemory nodes)
     - Skill data from input-skill handle (skill nodes)
     - Tool data from input-tools handle (tool nodes, including androidTool Sub-Node pattern)
     - Input data from input-main or input-chat handle (for auto-prompting fallback)
+    - Task data from input-task handle (taskTrigger nodes for delegated task results)
 
     Args:
         node_id: The agent node ID to collect connections for
@@ -32,7 +33,7 @@ async def _collect_agent_connections(
         log_prefix: Prefix for log messages (e.g., "[AI Agent]" or "[Chat Agent]")
 
     Returns:
-        Tuple of (memory_data, skill_data, tool_data, input_data)
+        Tuple of (memory_data, skill_data, tool_data, input_data, task_data)
     """
     nodes = context.get('nodes')
     edges = context.get('edges')
@@ -42,11 +43,12 @@ async def _collect_agent_connections(
     skill_data: List[Dict[str, Any]] = []
     tool_data: List[Dict[str, Any]] = []
     input_data: Optional[Dict[str, Any]] = None
+    task_data: Optional[Dict[str, Any]] = None
 
     logger.info(f"{log_prefix} Processing node {node_id}, edges={len(edges) if edges else 0}, nodes={len(nodes) if nodes else 0}, workflow_id={workflow_id}")
 
     if not edges or not nodes:
-        return memory_data, skill_data, tool_data, input_data
+        return memory_data, skill_data, tool_data, input_data, task_data
 
     # Log incoming edges for debugging
     incoming_edges = [e for e in edges if e.get('target') == node_id]
@@ -201,6 +203,45 @@ async def _collect_agent_connections(
                 tool_entry['connected_services'] = connected_services
                 logger.debug(f"{log_prefix} Android toolkit has {len(connected_services)} connected services")
 
+            # Special handling for AI Agent nodes - discover their connected tools
+            # This allows parent agent to know child agent's capabilities
+            if tool_type in AI_AGENT_TYPES:
+                child_tools = []
+
+                # Count edges targeting this child agent
+                child_incoming_edges = [e for e in edges if e.get('target') == source_node_id]
+                child_tool_edges = [e for e in child_incoming_edges if e.get('targetHandle') == 'input-tools']
+                logger.debug(f"{log_prefix} Child agent {source_node_id}: {len(child_incoming_edges)} incoming edges, {len(child_tool_edges)} input-tools edges")
+
+                # Log all incoming edge handles for debugging
+                if child_incoming_edges:
+                    handles = [e.get('targetHandle', 'None') for e in child_incoming_edges]
+                    logger.debug(f"{log_prefix} Child agent {source_node_id} incoming handles: {handles}")
+
+                # Scan edges for tools connected to this child agent's input-tools handle
+                for child_edge in edges:
+                    if child_edge.get('target') != source_node_id:
+                        continue
+                    if child_edge.get('targetHandle') != 'input-tools':
+                        continue
+
+                    child_tool_id = child_edge.get('source')
+                    child_tool_node = next((n for n in nodes if n.get('id') == child_tool_id), None)
+
+                    logger.debug(f"{log_prefix} Child agent {source_node_id}: tool edge from {child_tool_id}, node found: {child_tool_node is not None}")
+
+                    if child_tool_node:
+                        child_tool_type = child_tool_node.get('type', '')
+                        child_tool_label = child_tool_node.get('data', {}).get('label', child_tool_type)
+                        child_tools.append({
+                            'node_type': child_tool_type,
+                            'label': child_tool_label
+                        })
+
+                if child_tools:
+                    tool_entry['child_tools'] = child_tools
+                    logger.debug(f"{log_prefix} Child agent {source_node_id} has tools: {[t['label'] for t in child_tools]}")
+
             tool_data.append(tool_entry)
             logger.debug(f"{log_prefix} Connected tool: {tool_type}")
 
@@ -212,14 +253,90 @@ async def _collect_agent_connections(
                 input_data = source_output
                 logger.debug(f"{log_prefix} Input from {source_node.get('type')}: {list(source_output.keys()) if isinstance(source_output, dict) else type(source_output)}")
 
+        # Task data detection - taskTrigger nodes connected to input-task handle
+        # Used to receive results from delegated child agents
+        elif target_handle == 'input-task':
+            logger.info(f"{log_prefix} Found input-task edge from {source_node_id} (type={source_node.get('type')})")
+
+            # Try context.outputs first (parallel executor), then database via get_output_fn
+            source_output = context.get('outputs', {}).get(source_node_id)
+            logger.info(f"{log_prefix} Context outputs check for {source_node_id}: {source_output is not None}")
+
+            if not source_output:
+                # Database is source of truth - use get_output_fn to retrieve stored output
+                get_output_fn = context.get('get_output_fn')
+                session_id = context.get('session_id', 'default')
+                if get_output_fn:
+                    try:
+                        source_output = await get_output_fn(session_id, source_node_id, 'output_0')
+                        logger.info(f"{log_prefix} DB lookup for {source_node_id}: {source_output is not None}")
+                    except Exception as e:
+                        logger.warning(f"{log_prefix} Failed to get output from DB: {e}")
+                else:
+                    logger.warning(f"{log_prefix} No get_output_fn in context, cannot retrieve task output")
+
+            logger.info(f"{log_prefix} Source output for {source_node_id}: {source_output is not None}, type={type(source_output).__name__ if source_output else 'None'}")
+            if source_output:
+                # Handle nested result structure - taskTrigger may return {"result": {...}} or flat dict
+                if isinstance(source_output, dict) and 'result' in source_output and isinstance(source_output.get('result'), dict):
+                    # Nested structure - extract inner result
+                    task_data = source_output.get('result')
+                    logger.info(f"{log_prefix} Extracted nested task_data from result key")
+                else:
+                    task_data = source_output
+                logger.info(f"{log_prefix} Task completion data: task_id={task_data.get('task_id')}, status={task_data.get('status')}, agent_name={task_data.get('agent_name')}")
+
     # Log collection results
-    logger.info(f"{log_prefix} Collected: {len(skill_data)} skills, {len(tool_data)} tools, memory={'yes' if memory_data else 'no'}, input={'yes' if input_data else 'no'}")
+    logger.info(f"{log_prefix} Collected: {len(skill_data)} skills, {len(tool_data)} tools, memory={'yes' if memory_data else 'no'}, input={'yes' if input_data else 'no'}, task={'yes' if task_data else 'no'}")
     for sd in skill_data:
         logger.debug(f"{log_prefix} Skill: type={sd.get('node_type')}, label={sd.get('label')}")
     for td in tool_data:
         logger.info(f"{log_prefix} Tool: type={td.get('node_type')}, node_id={td.get('node_id')}")
 
-    return memory_data, skill_data, tool_data, input_data
+    return memory_data, skill_data, tool_data, input_data, task_data
+
+
+def _format_task_context(task_data: Dict[str, Any]) -> str:
+    """Format task completion data as context for the agent.
+
+    Args:
+        task_data: Task completion data from taskTrigger node
+
+    Returns:
+        Formatted string to prepend to agent prompt
+    """
+    status = task_data.get('status', 'unknown')
+    agent_name = task_data.get('agent_name', 'Unknown Agent')
+    task_id = task_data.get('task_id', '')
+
+    if status == 'completed':
+        result = task_data.get('result', 'No result provided')
+        return f"""A delegated task has completed:
+- Agent: {agent_name}
+- Task ID: {task_id}
+- Status: Completed Successfully
+- Result: {result}
+
+IMPORTANT: This task is COMPLETE. Do NOT delegate or call any agent tools.
+Simply report this result to the user in a natural, conversational way."""
+
+    elif status == 'error':
+        error = task_data.get('error', 'Unknown error')
+        return f"""A delegated task has failed:
+- Agent: {agent_name}
+- Task ID: {task_id}
+- Status: Error
+- Error: {error}
+
+IMPORTANT: This task has FAILED. Do NOT retry or delegate again.
+Report this error to the user and suggest next steps if appropriate."""
+
+    else:
+        return f"""Task update received:
+- Agent: {agent_name}
+- Task ID: {task_id}
+- Status: {status}
+- Data: {task_data}"""
 
 
 async def handle_ai_agent(
@@ -245,11 +362,29 @@ async def handle_ai_agent(
     """
     workflow_id = context.get('workflow_id')
 
-    # Collect connected memory, skill, tool, and input nodes using shared base function
-    memory_data, skill_data, tool_data, input_data = await _collect_agent_connections(
+    # Collect connected memory, skill, tool, input, and task nodes using shared base function
+    memory_data, skill_data, tool_data, input_data, task_data = await _collect_agent_connections(
         node_id, context, database, log_prefix="[AI Agent]"
     )
 
+    # If task data is present, format it as context for the agent
+    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}"}
+        logger.info(f"[AI Agent] Task context injected for task_id={task_data.get('task_id')}")
+
+        # CRITICAL FIX: Strip ALL tools when handling task completion
+        # When reporting a delegated task result, the agent should NOT use any tools.
+        # Binding tools while instructing "do not use tools" confuses Gemini (returns empty []).
+        # The agent's only job is to report the result naturally.
+        task_status = task_data.get('status', '')
+        if task_status in ('completed', 'error') and tool_data:
+            original_tool_count = len(tool_data)
+            # Strip ALL tools - agent is just reporting result, not executing anything
+            tool_data = []
+            logger.info(f"[AI Agent] Stripped ALL {original_tool_count} tools for task completion handling")
+
     # Auto-use input data if prompt is empty (fallback for trigger nodes)
     if not parameters.get('prompt') and input_data:
         prompt = (
@@ -306,11 +441,29 @@ async def handle_chat_agent(
     """
     workflow_id = context.get('workflow_id')
 
-    # Collect connected memory, skill, tool, and input nodes using shared base function
-    memory_data, skill_data, tool_data, input_data = await _collect_agent_connections(
+    # Collect connected memory, skill, tool, input, and task nodes using shared base function
+    memory_data, skill_data, tool_data, input_data, task_data = await _collect_agent_connections(
         node_id, context, database, log_prefix="[Chat Agent]"
     )
 
+    # If task data is present, format it as context for the agent
+    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}"}
+        logger.info(f"[Chat Agent] Task context injected for task_id={task_data.get('task_id')}")
+
+        # CRITICAL FIX: Strip ALL tools when handling task completion
+        # When reporting a delegated task result, the agent should NOT use any tools.
+        # Binding tools while instructing "do not use tools" confuses Gemini (returns empty []).
+        # The agent's only job is to report the result naturally.
+        task_status = task_data.get('status', '')
+        if task_status in ('completed', 'error') and tool_data:
+            original_tool_count = len(tool_data)
+            # Strip ALL tools - agent is just reporting result, not executing anything
+            tool_data = []
+            logger.info(f"[Chat Agent] Stripped ALL {original_tool_count} tools for task completion handling")
+
     # Auto-use input data if prompt is empty (fallback for trigger nodes)
     if not parameters.get('prompt') and input_data:
         prompt = (

package/server/services/handlers/document.py

@@ -370,7 +370,10 @@ async def handle_embedding_generator(
         logger.info("[embeddingGenerator] Starting", node_id=node_id, texts=len(texts), provider=provider)
 
         if provider == 'huggingface':
-            from langchain_huggingface import HuggingFaceEmbeddings
+            try:
+                from langchain_huggingface import HuggingFaceEmbeddings
+            except ImportError:
+                raise ImportError("HuggingFace embeddings not available. Install with: pip install langchain-huggingface sentence-transformers")
             embedder = HuggingFaceEmbeddings(model_name=model)
         elif provider == 'openai':
             from langchain_openai import OpenAIEmbeddings
@@ -448,7 +451,10 @@ async def handle_vector_store(
 
 async def _chroma_op(operation: str, params: Dict, collection: str) -> Dict:
     """ChromaDB operations."""
-    import chromadb
+    try:
+        import chromadb
+    except ImportError:
+        raise ImportError("ChromaDB not available. Install with: pip install chromadb")
     import uuid
 
     persist_dir = params.get('persistDir', './data/vectors')
@@ -500,8 +506,11 @@ async def _chroma_op(operation: str, params: Dict, collection: str) -> Dict:
 
 async def _qdrant_op(operation: str, params: Dict, collection: str) -> Dict:
     """Qdrant operations."""
-    from qdrant_client import QdrantClient
-    from qdrant_client.models import VectorParams, Distance, PointStruct
+    try:
+        from qdrant_client import QdrantClient
+        from qdrant_client.models import VectorParams, Distance, PointStruct
+    except ImportError:
+        raise ImportError("Qdrant client not available. Install with: pip install qdrant-client")
     import uuid
 
     url = params.get('qdrantUrl', 'http://localhost:6333')