machinaos 0.0.10 → 0.0.13

package/server/routers/websocket.py

@@ -244,6 +244,7 @@ async def handle_execute_node(data: Dict[str, Any], websocket: WebSocket) -> Dic
         nodes=data.get("nodes", []), edges=data.get("edges", []),
         session_id=data.get("session_id", "default"),
         workflow_id=workflow_id,
+        outputs=data.get("outputs", {}),  # Upstream node outputs for data flow
     )
 
     if result.get("success"):
@@ -628,20 +629,20 @@ async def handle_deploy_workflow(data: Dict[str, Any], websocket: WebSocket) ->
     session_id = data.get("session_id", "default")
 
     # DEBUG: Log received edges to trace tool connection issues
-    logger.info(f"[Deploy] Received {len(edges)} edges for workflow {workflow_id}")
+    logger.debug(f"[Deploy] Received {len(edges)} edges for workflow {workflow_id}")
     for e in edges:
         target_handle = e.get('targetHandle')
         if target_handle and target_handle.startswith('input-') and target_handle != 'input-main':
-            logger.info(f"[Deploy] Config edge: {e.get('source')} -> {e.get('target')} (handle={target_handle})")
+            logger.debug(f"[Deploy] Config edge: {e.get('source')} -> {e.get('target')} (handle={target_handle})")
 
     # Check for tool connections to AI Agent
     tool_edges = [e for e in edges if e.get('targetHandle') == 'input-tools']
     if tool_edges:
-        logger.info(f"[Deploy] Tool edges found: {len(tool_edges)}")
+        logger.debug(f"[Deploy] Tool edges found: {len(tool_edges)}")
         for te in tool_edges:
-            logger.info(f"[Deploy] Tool edge: source={te.get('source')} -> target={te.get('target')}")
+            logger.debug(f"[Deploy] Tool edge: source={te.get('source')} -> target={te.get('target')}")
     else:
-        logger.info(f"[Deploy] No input-tools edges found")
+        logger.debug(f"[Deploy] No input-tools edges found")
 
     if not nodes:
         return {"success": False, "error": "No nodes provided"}

package/server/services/ai.py

@@ -1402,6 +1402,20 @@ class AIService:
 
                 logger.debug(f"[LangGraph] Built {len(tools)} tools")
 
+                # Auto-inject check_delegated_tasks tool when delegation tools present
+                if any(name.startswith('delegate_to_') for name in tool_configs):
+                    check_info = {
+                        'node_type': '_builtin_check_delegated_tasks',
+                        'node_id': f'{node_id}_check_tasks',
+                        'parameters': {},
+                        'label': 'Check Delegated Tasks',
+                    }
+                    check_tool, check_config = await self._build_tool_from_node(check_info)
+                    if check_tool:
+                        tools.append(check_tool)
+                        tool_configs[check_tool.name] = check_config
+                        logger.debug(f"[LangGraph] Auto-injected check_delegated_tasks tool")
+
             # Create tool executor callback
             async def tool_executor(tool_name: str, tool_args: Dict) -> Any:
                 """Execute a tool by name."""
@@ -1438,6 +1452,7 @@ class AIService:
                 # These allow child agents to execute with their own tools
                 config['ai_service'] = self
                 config['database'] = self.database
+                config['parent_node_id'] = node_id  # For delegation result tracking
                 if context:
                     config['nodes'] = context.get('nodes', [])
                     config['edges'] = context.get('edges', [])
@@ -1709,6 +1724,20 @@ class AIService:
 
                 logger.debug(f"[ChatAgent] Built {len(all_tools)} tools from tool_data")
 
+                # Auto-inject check_delegated_tasks tool when delegation tools present
+                if any(name.startswith('delegate_to_') for name in tool_node_configs):
+                    check_info = {
+                        'node_type': '_builtin_check_delegated_tasks',
+                        'node_id': f'{node_id}_check_tasks',
+                        'parameters': {},
+                        'label': 'Check Delegated Tasks',
+                    }
+                    check_tool, check_config = await self._build_tool_from_node(check_info)
+                    if check_tool:
+                        all_tools.append(check_tool)
+                        tool_node_configs[check_tool.name] = check_config
+                        logger.debug(f"[ChatAgent] Auto-injected check_delegated_tasks tool")
+
             logger.debug(f"[ChatAgent] Total tools available: {len(all_tools)}")
             # Debug: log all tool schemas to verify they're correct
             for t in all_tools:
@@ -1861,6 +1890,7 @@ class AIService:
                     # These allow child agents to execute with their own tools
                     config['ai_service'] = self
                     config['database'] = self.database
+                    config['parent_node_id'] = node_id  # For delegation result tracking
                     if context:
                         config['nodes'] = context.get('nodes', [])
                         config['edges'] = context.get('edges', [])
@@ -2062,8 +2092,12 @@ class AIService:
             'whatsappDb': 'whatsapp_db',
             'gmaps_locations': 'geocode',
             'gmaps_nearby_places': 'nearby_places',
+            'taskManager': 'task_manager',
             'timer': 'timer',
             'cronScheduler': 'cron_scheduler',
+            # Built-in check tool for delegation results
+            '_builtin_check_delegated_tasks': 'check_delegated_tasks',
+            # Agent delegation tools
             'aiAgent': 'delegate_to_ai_agent',
             'chatAgent': 'delegate_to_chat_agent',
             'android_agent': 'delegate_to_android_agent',
@@ -2105,20 +2139,24 @@ class AIService:
             'whatsappDb': 'Query WhatsApp database - list contacts, search groups, get contact/group info, retrieve chat history.',
             'gmaps_locations': 'Geocode addresses to coordinates or reverse geocode coordinates to addresses using Google Maps.',
             'gmaps_nearby_places': 'Search for nearby places (restaurants, hospitals, banks, etc.) using Google Maps Places API.',
+            'taskManager': 'Track delegated sub-agent tasks. Operations: list_tasks (see all tasks), get_task (check specific task status/result), mark_done (cleanup completed tasks).',
             'timer': 'Wait/sleep for a specified duration. Specify duration (1-3600) and unit (seconds, minutes, or hours). Returns timestamp and elapsed time after waiting.',
             'cronScheduler': 'Schedule a delayed or recurring execution. Supports seconds, minutes, hours, daily, weekly, monthly frequencies with timezone. Use frequency to set schedule type, then set the relevant interval/time parameters.',
-            'aiAgent': 'Delegate a task to another AI Agent. The agent works independently without blocking.',
-            'chatAgent': 'Delegate a task to a Chat Agent. The agent works independently without blocking.',
-            'android_agent': 'Delegate a task to an Android Control Agent for device automation. Works independently.',
-            'coding_agent': 'Delegate a task to a Coding Agent for code execution. Works independently.',
-            'web_agent': 'Delegate a task to a Web Control Agent for web automation. Works independently.',
-            'task_agent': 'Delegate a task to a Task Management Agent for task automation. Works independently.',
-            'social_agent': 'Delegate a task to a Social Media Agent for social messaging. Works independently.',
-            'travel_agent': 'Delegate a task to a Travel Agent for travel planning and itinerary building. Works independently.',
-            'tool_agent': 'Delegate a task to a Tool Agent for multi-tool orchestration and complex task execution. Works independently.',
-            'productivity_agent': 'Delegate a task to a Productivity Agent for scheduling, reminders, and workflow automation. Works independently.',
-            'payments_agent': 'Delegate a task to a Payments Agent for payment processing, invoice generation, and financial operations. Works independently.',
-            'consumer_agent': 'Delegate a task to a Consumer Agent for customer support, product recommendations, and order management. Works independently.',
+            # Built-in check tool for delegation results
+            '_builtin_check_delegated_tasks': 'Check status and retrieve results of previously delegated tasks.',
+            # Agent delegation tools - ONE-SHOT fire-and-forget pattern
+            'aiAgent': 'ONE-SHOT delegation to AI Agent. Call ONCE per task, returns task_id immediately. Agent works in background - do NOT re-call.',
+            'chatAgent': 'ONE-SHOT delegation to Chat Agent. Call ONCE per task, returns task_id immediately. Agent works in background - do NOT re-call.',
+            'android_agent': 'ONE-SHOT delegation to Android Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
+            'coding_agent': 'ONE-SHOT delegation to Coding Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
+            'web_agent': 'ONE-SHOT delegation to Web Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
+            'task_agent': 'ONE-SHOT delegation to Task Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
+            'social_agent': 'ONE-SHOT delegation to Social Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
+            'travel_agent': 'ONE-SHOT delegation to Travel Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
+            'tool_agent': 'ONE-SHOT delegation to Tool Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
+            'productivity_agent': 'ONE-SHOT delegation to Productivity Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
+            'payments_agent': 'ONE-SHOT delegation to Payments Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
+            'consumer_agent': 'ONE-SHOT delegation to Consumer Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
             # Android service nodes (direct tool usage)
             'batteryMonitor': 'Monitor Android battery status, level, charging state, temperature, and health.',
             'networkMonitor': 'Monitor Android network connectivity, type, and internet availability.',
@@ -2174,6 +2212,29 @@ class AIService:
                 service_names = [s.get('label') or s.get('service_id', 'unknown') for s in connected_services]
                 tool_description = f"{tool_description} Connected: {', '.join(service_names)}"
 
+            # For AI Agent nodes, enhance description with child agent's tool capabilities
+            # This allows parent agent to know what the child agent can do
+            from constants import AI_AGENT_TYPES
+            if node_type in AI_AGENT_TYPES:
+                child_tools = tool_info.get('child_tools', [])
+                if child_tools:
+                    # Build capability description from child's connected tools
+                    capability_descriptions = []
+                    for child_tool in child_tools:
+                        child_type = child_tool.get('node_type', '')
+                        child_label = child_tool.get('label', child_type)
+                        # Get the tool description from DEFAULT_TOOL_DESCRIPTIONS
+                        child_desc = DEFAULT_TOOL_DESCRIPTIONS.get(child_type, f"Use {child_label}")
+                        capability_descriptions.append(f"- {child_label}: {child_desc}")
+
+                    capabilities_text = "\n".join(capability_descriptions)
+                    tool_description = (
+                        f"Delegate tasks to '{node_label}' agent. "
+                        f"This agent has the following capabilities:\n{capabilities_text}\n"
+                        f"Call ONCE per task, returns task_id. Agent works in background."
+                    )
+                    logger.info(f"[LangGraph] Enhanced tool description for {node_type} with {len(child_tools)} child tools")
+
             # Clean tool name (LangChain requires alphanumeric + underscores)
             import re
             tool_name = re.sub(r'[^a-zA-Z0-9_]', '_', tool_name)
@@ -2615,6 +2676,45 @@ class AIService:
 
             return NearbyPlacesSchema
 
+        # Task Manager schema (dual-purpose: AI tool + workflow node)
+        if node_type == 'taskManager':
+            class TaskManagerSchema(BaseModel):
+                """Manage delegated tasks - list, check status, mark done.
+
+                Use this to track sub-agent tasks you've delegated.
+                - list_tasks: See all active and completed tasks
+                - get_task: Get details on a specific task
+                - mark_done: Clean up a completed task from tracking
+                """
+                operation: str = Field(
+                    description="Operation: 'list_tasks', 'get_task', or 'mark_done'"
+                )
+                task_id: Optional[str] = Field(
+                    default=None,
+                    description="Task ID (required for get_task/mark_done)"
+                )
+                status_filter: Optional[str] = Field(
+                    default=None,
+                    description="Filter by status: 'running', 'completed', or 'error' (for list_tasks)"
+                )
+
+            return TaskManagerSchema
+
+        # Check delegated tasks schema (built-in tool for result retrieval)
+        if node_type == '_builtin_check_delegated_tasks':
+            class CheckDelegatedTasksSchema(BaseModel):
+                """Check on previously delegated tasks and retrieve their results.
+
+                Call this to see if delegated agents have completed their work.
+                Returns status and results for each task.
+                """
+                task_ids: Optional[List[str]] = Field(
+                    default=None,
+                    description="Specific task IDs to check. Omit to get ALL delegated tasks."
+                )
+
+            return CheckDelegatedTasksSchema
+
         # AI Agent delegation schema (fire-and-forget async delegation)
         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'):
             agent_label = params.get('label', node_type)
@@ -2622,8 +2722,9 @@ class AIService:
             class DelegateToAgentSchema(BaseModel):
                 """Delegate a task to another AI Agent (non-blocking).
 
-                The child agent will work independently without blocking the parent.
-                Use this to assign subtasks to specialized agents.
+                The child agent works independently in the background.
+                Returns a task_id immediately. Use 'check_delegated_tasks'
+                tool to check status and retrieve results when ready.
                 """
                 task: str = Field(
                     description=f"The task/instruction to delegate to '{agent_label}'. Be specific about what you want done."

package/server/services/auth.py

@@ -86,7 +86,12 @@ class AuthService:
             api_key_record = await self.database.get_api_key_by_provider(provider, session_id)
             if api_key_record and api_key_record.is_valid:
                 # Check if not expired (30 days)
-                if datetime.now(timezone.utc) - api_key_record.last_validated < timedelta(days=30):
+                # Ensure both datetimes are timezone-aware for comparison
+                # SQLite may return offset-naive datetimes
+                last_validated = api_key_record.last_validated
+                if last_validated.tzinfo is None:
+                    last_validated = last_validated.replace(tzinfo=timezone.utc)
+                if datetime.now(timezone.utc) - last_validated < timedelta(days=30):
                     return self.decrypt_api_key(api_key_record.key_encrypted)
 
             return None

package/server/services/deployment/manager.py

@@ -629,6 +629,20 @@ class DeploymentManager:
                 downstream_ids.add(source)
                 logger.debug(f"[Deployment] Including sub-node {source} connected to toolkit {target}")
 
+        # Include tool nodes connected to AI Agent nodes (for capability discovery)
+        # When a child agent is included, we need its connected tools so the parent
+        # can discover what capabilities the child has
+        from constants import AI_AGENT_TYPES
+        agent_node_ids = {n['id'] for n in nodes if n.get('type') in AI_AGENT_TYPES and n['id'] in downstream_ids}
+        for edge in edges:
+            target = edge.get('target')
+            source = edge.get('source')
+            target_handle = edge.get('targetHandle', '')
+            # Include tool nodes connected to agent's input-tools handle
+            if target in agent_node_ids and target_handle == 'input-tools' and source not in downstream_ids:
+                downstream_ids.add(source)
+                logger.debug(f"[Deployment] Including tool node {source} connected to agent {target}")
+
         return [n for n in nodes if n['id'] in downstream_ids]
 
     # =========================================================================

package/server/services/event_waiter.py

@@ -105,6 +105,11 @@ TRIGGER_REGISTRY: Dict[str, TriggerConfig] = {
         event_type='chat_message_received',
         display_name='Chat Message'
     ),
+    'taskTrigger': TriggerConfig(
+        node_type='taskTrigger',
+        event_type='task_completed',
+        display_name='Task Completed'
+    ),
     # Future triggers - just add to registry:
     # 'emailTrigger': TriggerConfig('emailTrigger', 'email_received', 'Email'),
     # 'mqttTrigger': TriggerConfig('mqttTrigger', 'mqtt_message', 'MQTT Message'),
@@ -282,11 +287,61 @@ def build_chat_filter(params: Dict) -> Callable[[Dict], bool]:
     return matches
 
 
+def build_task_completed_filter(params: Dict) -> Callable[[Dict], bool]:
+    """Build filter function for task completed events.
+
+    Filters by:
+    - task_id: Specific task ID to watch (optional)
+    - agent_name: Filter by child agent name (optional)
+    - status_filter: 'all', 'completed', 'error' (default: 'all')
+    - parent_node_id: Filter by parent node (optional, for scoping)
+
+    Args:
+        params: Node parameters
+
+    Returns:
+        Filter function that checks if event matches criteria
+    """
+    task_id_filter = params.get('task_id', '')
+    agent_name_filter = params.get('agent_name', '')
+    status_filter = params.get('status_filter', 'all')  # all, completed, error
+    parent_node_id = params.get('parent_node_id', '')
+
+    def matches(data: Dict) -> bool:
+        # Task ID filter (exact match if specified)
+        if task_id_filter:
+            if data.get('task_id') != task_id_filter:
+                return False
+
+        # Agent name filter (contains match)
+        if agent_name_filter:
+            event_agent = data.get('agent_name', '')
+            if agent_name_filter.lower() not in event_agent.lower():
+                return False
+
+        # Status filter
+        event_status = data.get('status', '')
+        if status_filter == 'completed' and event_status != 'completed':
+            return False
+        if status_filter == 'error' and event_status != 'error':
+            return False
+
+        # Parent node filter (for scoping to specific parent agent)
+        if parent_node_id:
+            if data.get('parent_node_id') != parent_node_id:
+                return False
+
+        return True
+
+    return matches
+
+
 # Registry of filter builders per trigger type
 FILTER_BUILDERS: Dict[str, Callable[[Dict], Callable[[Dict], bool]]] = {
     'whatsappReceive': build_whatsapp_filter,
     'webhookTrigger': build_webhook_filter,
     'chatTrigger': build_chat_filter,
+    'taskTrigger': build_task_completed_filter,
 }
 
 

package/server/services/example_loader.py

@@ -0,0 +1,60 @@
+"""Example workflow loader - reuses existing database.save_workflow()"""
+import json
+import logging
+from pathlib import Path
+from typing import List, Dict, Any
+
+logger = logging.getLogger(__name__)
+
+# Workflows folder at project root (parent of server/)
+EXAMPLES_DIR = Path(__file__).parent.parent.parent / "workflows"
+
+
+def get_example_workflows() -> List[Dict[str, Any]]:
+    """Load all example workflow JSON files from disk."""
+    examples = []
+    if not EXAMPLES_DIR.exists():
+        logger.warning(f"Examples directory not found: {EXAMPLES_DIR}")
+        return examples
+
+    for file in sorted(EXAMPLES_DIR.glob("*.json")):
+        try:
+            with open(file, encoding="utf-8") as f:
+                workflow = json.load(f)
+                workflow["_filename"] = file.name  # Track source
+                examples.append(workflow)
+                logger.debug(f"Loaded example: {file.name}")
+        except (json.JSONDecodeError, IOError) as e:
+            logger.error(f"Failed to load {file}: {e}")
+
+    return examples
+
+
+async def import_examples_for_user(database) -> int:
+    """Import all examples using existing database.save_workflow().
+
+    Returns count of workflows imported.
+    """
+    examples = get_example_workflows()
+    imported = 0
+
+    for example in examples:
+        # Use ID from JSON, prefixed with 'example_' for clarity
+        workflow_id = f"example_{example.get('id', 'unknown')}"
+
+        # Reuse existing save_workflow method
+        success = await database.save_workflow(
+            workflow_id=workflow_id,
+            name=example.get("name", "Example Workflow"),
+            description=example.get("description"),
+            data={
+                "nodes": example.get("nodes", []),
+                "edges": example.get("edges", [])
+            }
+        )
+
+        if success:
+            imported += 1
+            logger.info(f"Imported example: {example.get('name')}")
+
+    return imported

package/server/services/execution/executor.py

@@ -804,6 +804,7 @@ class WorkflowExecutor:
 
         # Build execution context for node handler
         # workflow_id is included for per-workflow status scoping (n8n pattern)
+        logger.info(f"[Executor] Building context for {node.node_id}, ctx.outputs keys: {list(ctx.outputs.keys())}")
         exec_context = {
             "nodes": ctx.nodes,
             "edges": ctx.edges,
@@ -813,6 +814,7 @@ class WorkflowExecutor:
             "start_time": node.started_at,
             "outputs": ctx.outputs,  # Previous node outputs
         }
+        logger.info(f"[Executor] exec_context['outputs'] keys: {list(exec_context['outputs'].keys())}")
 
         # Call the actual node executor
         result = await self.node_executor(

package/server/services/execution/models.py

@@ -13,6 +13,10 @@ from datetime import datetime
 from enum import Enum
 from typing import Dict, Any, List, Optional
 
+from core.logging import get_logger
+
+logger = get_logger(__name__)
+
 
 class TaskStatus(str, Enum):
     """Task execution states (Conductor-style lifecycle).
@@ -361,6 +365,8 @@ class ExecutionContext:
             if node.get("_pre_executed"):
                 # Mark as COMPLETED with trigger output
                 trigger_output = node.get("_trigger_output", {})
+                logger.info(f"[ExecutionContext] Pre-executed node found: {node_id} (type={node_type})")
+                logger.info(f"[ExecutionContext] Trigger output keys: {list(trigger_output.keys()) if trigger_output else 'empty'}")
                 node_exec = NodeExecution(
                     node_id=node_id,
                     node_type=node_type,
@@ -369,6 +375,7 @@ class ExecutionContext:
                     completed_at=time.time(),
                 )
                 ctx.outputs[node_id] = trigger_output
+                logger.info(f"[ExecutionContext] Set ctx.outputs[{node_id}] = trigger_output")
                 ctx.checkpoints.append(node_id)
             else:
                 node_exec = NodeExecution(
@@ -378,6 +385,7 @@ class ExecutionContext:
 
             ctx.node_executions[node_id] = node_exec
 
+        logger.info(f"[ExecutionContext] Created context with outputs: {list(ctx.outputs.keys())}")
         return ctx
 
     def get_node_status(self, node_id: str) -> Optional[TaskStatus]:

package/server/services/handlers/__init__.py

@@ -84,6 +84,7 @@ from .document import (
 # Tool execution handlers (for AI Agent tool calling)
 from .tools import (
     execute_tool,
+    handle_task_manager,
 )
 
 __all__ = [
@@ -129,4 +130,5 @@ __all__ = [
     'handle_vector_store',
     # Tools
     'execute_tool',
+    'handle_task_manager',
 ]