machinaos 0.0.10 → 0.0.13

package/server/services/handlers/tools.py

@@ -9,7 +9,8 @@ import math
 import json
 import asyncio
 import uuid
-from typing import Dict, Any, Optional, TYPE_CHECKING
+import hashlib
+from typing import Dict, Any, Optional, List, Tuple, TYPE_CHECKING
 
 from core.logging import get_logger
 from constants import ANDROID_SERVICE_NODE_TYPES
@@ -23,6 +24,13 @@ logger = get_logger(__name__)
 # Track running delegated tasks for status checking
 _delegated_tasks: Dict[str, asyncio.Task] = {}
 
+# In-memory cache of delegation results (fast path, survives task cleanup)
+# Follows Celery AsyncResult / Ray ObjectRef pattern
+_delegation_results: Dict[str, Dict[str, Any]] = {}
+
+# Track active delegations to prevent duplicate calls: (parent_node_id, child_node_id, task_hash) -> task_id
+_active_delegations: Dict[Tuple[str, str, str], str] = {}
+
 
 async def execute_tool(tool_name: str, tool_args: Dict[str, Any],
                        config: Dict[str, Any]) -> Dict[str, Any]:
@@ -115,6 +123,15 @@ async def execute_tool(tool_name: str, tool_args: Dict[str, Any],
     if node_type == 'gmaps_nearby_places':
         return await _execute_nearby_places(tool_args, config.get('parameters', {}))
 
+    # Task Manager (dual-purpose: AI tool + workflow node)
+    if node_type == 'taskManager':
+        return await _execute_task_manager(tool_args, config)
+
+    # Built-in: Check delegated task results
+    # Auto-injected when parent has delegation tools
+    if node_type == '_builtin_check_delegated_tasks':
+        return await _execute_check_delegated_tasks(tool_args, config)
+
     # AI Agent delegation (fire-and-forget async delegation)
     # Includes specialized agents: android_agent, coding_agent, web_agent, task_agent, social_agent
     if node_type in ('aiAgent', 'chatAgent', 'android_agent', 'coding_agent', 'web_agent', 'task_agent', 'social_agent', 'travel_agent', 'tool_agent', 'productivity_agent', 'payments_agent', 'consumer_agent'):
@@ -1158,9 +1175,34 @@ async def _execute_delegated_agent(args: Dict[str, Any],
             "hint": "Ensure nodes/edges are passed to tool config"
         }
 
+    # Get parent node ID for duplicate tracking
+    parent_node_id = config.get('parent_node_id', '')
+
+    # Generate hash of task to detect duplicate delegation attempts
+    task_hash = hashlib.md5(f"{task_description}:{task_context}".encode()).hexdigest()[:16]
+    delegation_key = (parent_node_id, node_id, task_hash)
+
+    # Check for duplicate delegation (prevents LLM from calling same delegation twice)
+    existing_task_id = _active_delegations.get(delegation_key)
+    if existing_task_id:
+        logger.warning(f"[Delegated Agent] Duplicate delegation detected: task_hash={task_hash}, existing_task_id={existing_task_id}")
+        return {
+            "success": True,
+            "status": "ALREADY_DELEGATED",
+            "task_id": existing_task_id,
+            "agent_name": config.get('parameters', {}).get('label', node_type),
+            "result": (
+                f"This task was ALREADY delegated (task_id: {existing_task_id}). "
+                f"Do NOT call this tool again. Use 'check_delegated_tasks' to check status."
+            ),
+        }
+
     # Generate unique task ID
     task_id = f"delegated_{node_id}_{uuid.uuid4().hex[:8]}"
 
+    # Register this delegation to prevent duplicates
+    _active_delegations[delegation_key] = task_id
+
     # Get child agent parameters from database
     child_params = await database.get_node_parameters(node_id) or {}
 
@@ -1233,8 +1275,69 @@ async def _execute_delegated_agent(args: Dict[str, Any],
 
             logger.info(f"[Delegated Agent] Task {task_id} completed: success={result.get('success')}")
 
+            # Check if child agent actually succeeded
+            if not result.get('success'):
+                # Child agent returned failure - treat as error
+                error_msg = result.get('error', 'Child agent returned failure')
+                logger.warning(f"[Delegated Agent] Task {task_id} returned success=False: {error_msg}")
+
+                await broadcaster.update_node_status(
+                    node_id,
+                    "error",
+                    {
+                        "phase": "delegated_error",
+                        "task_id": task_id,
+                        "error": error_msg
+                    },
+                    workflow_id=workflow_id
+                )
+
+                # Cache error for parent retrieval
+                _delegation_results[task_id] = {
+                    "task_id": task_id,
+                    "status": "error",
+                    "agent_name": agent_label,
+                    "agent_node_id": node_id,
+                    "result": None,
+                    "error": error_msg,
+                }
+
+                # Persist error to DB
+                if database:
+                    await database.save_node_output(
+                        node_id=node_id,
+                        session_id=f"delegation_{task_id}",
+                        output_name="delegation_result",
+                        data={
+                            "task_id": task_id,
+                            "parent_node_id": config.get('parent_node_id', ''),
+                            "agent_name": agent_label,
+                            "status": "error",
+                            "error": error_msg,
+                        }
+                    )
+
+                # Dispatch error event for trigger nodes
+                await broadcaster.send_custom_event('task_completed', {
+                    'task_id': task_id,
+                    'status': 'error',
+                    'agent_name': agent_label,
+                    'agent_node_id': node_id,
+                    'parent_node_id': config.get('parent_node_id', ''),
+                    'error': error_msg,
+                    'workflow_id': workflow_id,
+                })
+
+                return result
+
+            # Success case - extract response properly
+            response_text = result.get('result', {}).get('response', '')
+            if not response_text:
+                # Fallback: try to stringify the result dict
+                response_text = str(result.get('result', '')) if result.get('result') else 'No response generated'
+
             # Broadcast completion
-            response_preview = str(result.get('result', {}).get('response', ''))[:200]
+            response_preview = response_text[:200] if response_text else ''
             await broadcaster.update_node_status(
                 node_id,
                 "success",
@@ -1246,6 +1349,42 @@ async def _execute_delegated_agent(args: Dict[str, Any],
                 workflow_id=workflow_id
             )
 
+            # Cache result for parent retrieval (Layer 2: in-memory)
+            _delegation_results[task_id] = {
+                "task_id": task_id,
+                "status": "completed",
+                "agent_name": agent_label,
+                "agent_node_id": node_id,
+                "result": response_text,
+                "error": None,
+            }
+
+            # Persist to DB (Layer 3: cross-restart via existing NodeOutput)
+            if database:
+                await database.save_node_output(
+                    node_id=node_id,
+                    session_id=f"delegation_{task_id}",
+                    output_name="delegation_result",
+                    data={
+                        "task_id": task_id,
+                        "parent_node_id": config.get('parent_node_id', ''),
+                        "agent_name": agent_label,
+                        "status": "completed",
+                        "result": response_text,
+                    }
+                )
+
+            # Dispatch task_completed event for trigger nodes
+            await broadcaster.send_custom_event('task_completed', {
+                'task_id': task_id,
+                'status': 'completed',
+                'agent_name': agent_label,
+                'agent_node_id': node_id,
+                'parent_node_id': config.get('parent_node_id', ''),
+                'result': response_text,
+                'workflow_id': workflow_id,
+            })
+
             return result
 
         except Exception as e:
@@ -1260,11 +1399,50 @@ async def _execute_delegated_agent(args: Dict[str, Any],
                 },
                 workflow_id=workflow_id
             )
+
+            # Cache error for parent retrieval (Layer 2: in-memory)
+            _delegation_results[task_id] = {
+                "task_id": task_id,
+                "status": "error",
+                "agent_name": agent_label,
+                "agent_node_id": node_id,
+                "result": None,
+                "error": str(e),
+            }
+
+            # Persist to DB (Layer 3: cross-restart)
+            if database:
+                await database.save_node_output(
+                    node_id=node_id,
+                    session_id=f"delegation_{task_id}",
+                    output_name="delegation_result",
+                    data={
+                        "task_id": task_id,
+                        "parent_node_id": config.get('parent_node_id', ''),
+                        "agent_name": agent_label,
+                        "status": "error",
+                        "error": str(e),
+                    }
+                )
+
+            # Dispatch task_completed event for trigger nodes (error case)
+            await broadcaster.send_custom_event('task_completed', {
+                'task_id': task_id,
+                'status': 'error',
+                'agent_name': agent_label,
+                'agent_node_id': node_id,
+                'parent_node_id': config.get('parent_node_id', ''),
+                'error': str(e),
+                'workflow_id': workflow_id,
+            })
+
             return {"success": False, "error": str(e)}
 
         finally:
             # Cleanup task reference
             _delegated_tasks.pop(task_id, None)
+            # Cleanup delegation tracking (allows re-delegation after completion)
+            _active_delegations.pop(delegation_key, None)
 
     # Spawn as background task (fire-and-forget)
     task = asyncio.create_task(run_child_agent())
@@ -1277,24 +1455,277 @@ async def _execute_delegated_agent(args: Dict[str, Any],
         "task_id": task_id,
         "agent_node_id": node_id,
         "agent_name": agent_label,
-        "message": f"Task delegated to '{agent_label}'. Agent is now working independently on: {task_description[:100]}..."
+        "message": (
+            f"SUCCESS: Task delegated to '{agent_label}' (task_id: {task_id}). "
+            f"Agent is now working INDEPENDENTLY in the background. "
+            f"IMPORTANT: Delegation is COMPLETE. Do NOT call this tool again for this task. "
+            f"To check results later, use 'check_delegated_tasks' with task_id='{task_id}'."
+        ),
     }
 
 
-def get_delegated_task_status(task_id: str) -> Dict[str, Any]:
-    """Check status of a delegated task (optional utility).
+async def get_delegated_task_status(task_ids: Optional[List[str]] = None,
+                                     database=None) -> Dict[str, Any]:
+    """Check status and retrieve results of delegated tasks.
+
+    3-layer lookup: live tasks -> memory cache -> DB (NodeOutput).
+    Follows Celery AsyncResult / Ray ObjectRef pattern.
 
     Args:
-        task_id: The task_id returned from delegation
+        task_ids: Optional list of specific task IDs to check. If None, returns all known tasks.
+        database: Database instance for Layer 3 (SQLite) lookup.
 
     Returns:
-        Status dict with task state
+        Dict with 'tasks' list containing status and results for each task.
     """
-    task = _delegated_tasks.get(task_id)
+    if not task_ids:
+        # Return all known from memory
+        task_ids = list(set(
+            list(_delegated_tasks.keys()) + list(_delegation_results.keys())
+        ))
+
+    tasks = []
+    db_lookup_ids = []
+
+    for tid in task_ids:
+        # Layer 1: Live asyncio.Task (still running or just finished)
+        live_task = _delegated_tasks.get(tid)
+        if live_task is not None:
+            if not live_task.done():
+                tasks.append({"task_id": tid, "status": "running"})
+            else:
+                # Task finished -- extract result via task.result()
+                try:
+                    result = live_task.result()
+                    response = result.get('result', {}).get('response', str(result.get('result', '')))
+                    tasks.append({"task_id": tid, "status": "completed", "result": response})
+                except Exception as e:
+                    tasks.append({"task_id": tid, "status": "error", "error": str(e)})
+            continue
+
+        # Layer 2: In-memory result cache
+        cached = _delegation_results.get(tid)
+        if cached:
+            tasks.append(cached)
+            continue
+
+        # Layer 3: Need DB lookup
+        db_lookup_ids.append(tid)
+
+    # DB fallback for results not in memory (cross-restart)
+    if db_lookup_ids and database:
+        for tid in list(db_lookup_ids):
+            db_result = await database.get_node_output_by_session(
+                session_id=f"delegation_{tid}",
+                output_name="delegation_result"
+            )
+            if db_result:
+                data = db_result.get('data', {})
+                result_data = data.get("result", {})
+                response_text = result_data.get("response", str(result_data)) if isinstance(result_data, dict) else str(result_data)
+                tasks.append({
+                    "task_id": tid,
+                    "status": data.get("status", "completed"),
+                    "agent_name": data.get("agent_name", ""),
+                    "result": response_text,
+                    "error": data.get("error"),
+                })
+                db_lookup_ids.remove(tid)
+
+    # Remaining IDs not found anywhere
+    for tid in db_lookup_ids:
+        tasks.append({"task_id": tid, "status": "not_found"})
+
+    return {"tasks": tasks}
+
+
+async def _execute_check_delegated_tasks(args: Dict[str, Any],
+                                          config: Dict[str, Any]) -> Dict[str, Any]:
+    """LLM-callable tool: check on delegated child agents.
+
+    Returns status and results for previously delegated tasks.
+    Follows Celery AsyncResult / Ray ObjectRef patterns.
+    """
+    task_ids = args.get('task_ids')
+    database = config.get('database')
+    result = await get_delegated_task_status(task_ids=task_ids, database=database)
+
+    formatted = []
+    for task in result.get("tasks", []):
+        entry = {
+            "task_id": task.get("task_id"),
+            "status": task.get("status"),
+            "agent_name": task.get("agent_name"),
+        }
+        if task.get("status") == "completed":
+            text = str(task.get("result", ""))
+            entry["result"] = text[:4000] + "... [truncated]" if len(text) > 4000 else text
+        elif task.get("status") == "error":
+            entry["error"] = task.get("error")
+        elif task.get("status") == "running":
+            entry["message"] = f"Agent '{task.get('agent_name', 'unknown')}' is still working"
+        formatted.append(entry)
 
-    if task is None:
-        return {"status": "not_found_or_completed", "task_id": task_id}
-    elif task.done():
-        return {"status": "completed", "task_id": task_id}
-    else:
-        return {"status": "running", "task_id": task_id}
+    return {
+        "total_tasks": len(formatted),
+        "completed": sum(1 for t in formatted if t.get("status") == "completed"),
+        "running": sum(1 for t in formatted if t.get("status") == "running"),
+        "errors": sum(1 for t in formatted if t.get("status") == "error"),
+        "tasks": formatted,
+    }
+
+
+async def _execute_task_manager(
+    tool_args: Dict[str, Any],
+    config: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Execute task manager operations.
+
+    Dual-purpose: works as AI tool (LLM fills args) or workflow node (uses params).
+
+    Operations:
+    - list_tasks: List all active and completed delegated tasks
+    - get_task: Get status details for a specific task
+    - mark_done: Remove a task from active tracking
+
+    Args:
+        tool_args: Arguments from LLM tool call (operation, task_id, status_filter)
+        config: Tool configuration with node parameters
+
+    Returns:
+        Dict with operation results
+    """
+    # Merge tool_args with node parameters (tool_args takes precedence)
+    params = config.get('parameters', {})
+    operation = tool_args.get('operation') or params.get('operation', 'list_tasks')
+    task_id = tool_args.get('task_id') or params.get('task_id')
+    status_filter = tool_args.get('status_filter') or params.get('status_filter')
+    database = config.get('database')
+
+    logger.debug(f"[TaskManager] Operation: {operation}, task_id: {task_id}, filter: {status_filter}")
+
+    if operation == 'list_tasks':
+        # Collect all tasks from _delegated_tasks and _delegation_results
+        tasks = []
+
+        # Active tasks from asyncio.Task tracking
+        for tid, task in _delegated_tasks.items():
+            if task.done():
+                try:
+                    if task.cancelled():
+                        status = 'cancelled'
+                    elif task.exception():
+                        status = 'error'
+                    else:
+                        status = 'completed'
+                except Exception:
+                    status = 'completed'
+            else:
+                status = 'running'
+
+            tasks.append({
+                'task_id': tid,
+                'status': status,
+                'active': True
+            })
+
+        # Completed tasks from in-memory cache
+        for tid, result in _delegation_results.items():
+            if tid not in [t['task_id'] for t in tasks]:
+                tasks.append({
+                    'task_id': tid,
+                    'status': result.get('status', 'completed'),
+                    'agent_name': result.get('agent_name'),
+                    'result_summary': str(result.get('result', ''))[:200],
+                    'active': False
+                })
+
+        # Apply status filter
+        if status_filter:
+            tasks = [t for t in tasks if t.get('status') == status_filter]
+
+        return {
+            'success': True,
+            'operation': 'list_tasks',
+            'tasks': tasks,
+            'count': len(tasks),
+            'running': sum(1 for t in tasks if t.get('status') == 'running'),
+            'completed': sum(1 for t in tasks if t.get('status') == 'completed'),
+            'errors': sum(1 for t in tasks if t.get('status') == 'error')
+        }
+
+    elif operation == 'get_task':
+        if not task_id:
+            return {'success': False, 'error': 'task_id is required for get_task operation'}
+
+        # Use existing get_delegated_task_status for detailed lookup
+        result = await get_delegated_task_status(task_ids=[task_id], database=database)
+        tasks = result.get('tasks', [])
+
+        if not tasks:
+            return {
+                'success': False,
+                'error': f'Task {task_id} not found',
+                'task_id': task_id
+            }
+
+        task_info = tasks[0]
+        return {
+            'success': True,
+            'operation': 'get_task',
+            'task_id': task_id,
+            'status': task_info.get('status'),
+            'agent_name': task_info.get('agent_name'),
+            'result': task_info.get('result'),
+            'error': task_info.get('error')
+        }
+
+    elif operation == 'mark_done':
+        if not task_id:
+            return {'success': False, 'error': 'task_id is required for mark_done operation'}
+
+        # Remove from active tracking
+        removed = False
+        if task_id in _delegated_tasks:
+            del _delegated_tasks[task_id]
+            removed = True
+        if task_id in _delegation_results:
+            del _delegation_results[task_id]
+            removed = True
+
+        return {
+            'success': True,
+            'operation': 'mark_done',
+            'task_id': task_id,
+            'removed': removed,
+            'message': f'Task {task_id} marked as done and removed from tracking' if removed else f'Task {task_id} was not in active tracking'
+        }
+
+    return {'success': False, 'error': f'Unknown operation: {operation}'}
+
+
+async def handle_task_manager(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Handle taskManager as workflow node.
+
+    Wrapper for _execute_task_manager that conforms to the standard
+    workflow node handler signature.
+
+    Args:
+        node_id: The node ID
+        node_type: Should be 'taskManager'
+        parameters: Node parameters (operation, task_id, status_filter)
+        context: Execution context
+
+    Returns:
+        Task manager operation results
+    """
+    config = {
+        'parameters': parameters,
+        'database': context.get('database')
+    }
+    return await _execute_task_manager({}, config)

package/server/services/node_executor.py

@@ -35,6 +35,7 @@ from services.handlers import (
     handle_social_receive, handle_social_send,
     handle_http_scraper, handle_file_downloader, handle_document_parser,
     handle_text_chunker, handle_embedding_generator, handle_vector_store,
+    handle_task_manager,
 )
 
 if TYPE_CHECKING:
@@ -145,6 +146,8 @@ class NodeExecutor:
             'textChunker': handle_text_chunker,
             'embeddingGenerator': handle_embedding_generator,
             'vectorStore': handle_vector_store,
+            # Task management
+            'taskManager': handle_task_manager,
             # Note: 'console' handled in _dispatch with connected_outputs
         }
 

package/server/services/temporal/activities.py

@@ -208,6 +208,9 @@ class NodeExecutionActivities:
             "edges": context.get("edges", []),
             "session_id": context.get("session_id", "default"),
             "workflow_id": context.get("workflow_id"),
+            # CRITICAL: Pass upstream node outputs for downstream nodes to access
+            # This enables taskTrigger -> chatAgent data flow via input-task handle
+            "outputs": context.get("inputs", {}),
         }
 
         print(f"[Activity] WebSocket execute for {node_id}")

package/server/services/workflow.py

@@ -142,6 +142,7 @@ class WorkflowService:
         session_id: str = "default",
         execution_id: str = None,
         workflow_id: str = None,
+        outputs: Dict[str, Any] = None,
     ) -> Dict[str, Any]:
         """Execute a single workflow node."""
         context = {
@@ -151,6 +152,7 @@ class WorkflowService:
             "execution_id": execution_id,
             "workflow_id": workflow_id,  # For per-workflow status scoping (n8n pattern)
             "get_output_fn": self.get_node_output,
+            "outputs": outputs or {},  # Upstream node outputs for data flow (e.g., taskTrigger -> chatAgent)
         }
         return await self._node_executor.execute(
             node_id=node_id,