machinaos 0.0.1 → 0.0.7

package/server/services/handlers/ai.py

@@ -1,355 +1,390 @@
-"""AI node handlers - AI Agent, Chat Agent, AI Chat Model, Simple Memory."""
-
-from typing import Dict, Any, List, Optional, TYPE_CHECKING
-from core.logging import get_logger
-from constants import ANDROID_SERVICE_NODE_TYPES
-
-if TYPE_CHECKING:
-    from services.ai import AIService
-    from core.database import Database
-
-logger = get_logger(__name__)
-
-
-async def handle_ai_agent(
-    node_id: str,
-    node_type: str,
-    parameters: Dict[str, Any],
-    context: Dict[str, Any],
-    ai_service: "AIService",
-    database: "Database"
-) -> Dict[str, Any]:
-    """Handle AI agent node execution with memory and tool support.
-
-    Args:
-        node_id: The node ID
-        node_type: The node type (aiAgent)
-        parameters: Resolved parameters
-        context: Execution context with nodes, edges, session_id, start_time, execution_id
-        ai_service: The AI service instance
-        database: The database instance
-
-    Returns:
-        Execution result dict
-    """
-    nodes = context.get('nodes')
-    edges = context.get('edges')
-    execution_id = context.get('execution_id', 'unknown')
-    workflow_id = context.get('workflow_id')  # Extract for status broadcasts
-    memory_data = None
-    tool_data: List[Dict[str, Any]] = []  # Collect connected tool nodes
-
-    logger.info(f"[AI Agent] Processing node {node_id}, edges={len(edges) if edges else 0}, nodes={len(nodes) if nodes else 0}, workflow_id={workflow_id}")
-
-    if edges and nodes:
-        # Log all edges targeting this AI Agent for debugging
-        incoming_edges = [e for e in edges if e.get('target') == node_id]
-        logger.info(f"[AI Agent] Incoming edges to {node_id}: {len(incoming_edges)}")
-        for e in incoming_edges:
-            logger.info(f"[AI Agent] Edge: source={e.get('source')}, targetHandle={e.get('targetHandle')}")
-
-        # Check for tool edges specifically
-        tool_incoming = [e for e in incoming_edges if e.get('targetHandle') == 'input-tools']
-        logger.info(f"[AI Agent] Tool edges (input-tools handle): {len(tool_incoming)}")
-
-        for edge in edges:
-            if edge.get('target') != node_id:
-                continue
-
-            target_handle = edge.get('targetHandle')
-            source_node_id = edge.get('source')
-            source_node = next((n for n in nodes if n.get('id') == source_node_id), None)
-
-            if not source_node:
-                continue
-
-            # Memory detection - load markdown content for editing
-            if target_handle == 'input-memory':
-                if source_node.get('type') == 'simpleMemory':
-                    memory_params = await database.get_node_parameters(source_node_id) or {}
-                    memory_session_id = memory_params.get('sessionId', 'default')
-                    window_size = int(memory_params.get('windowSize', 10))
-                    memory_content = memory_params.get('memoryContent', '# Conversation History\n\n*No messages yet.*\n')
-                    long_term_enabled = memory_params.get('longTermEnabled', False)
-                    retrieval_count = int(memory_params.get('retrievalCount', 3))
-
-                    memory_data = {
-                        'node_id': source_node_id,  # For saving updated content
-                        'session_id': memory_session_id,
-                        'window_size': window_size,
-                        'memory_content': memory_content,
-                        'long_term_enabled': long_term_enabled,
-                        'retrieval_count': retrieval_count
-                    }
-                    logger.debug("AI Agent connected memory node", memory_session=memory_session_id, content_length=len(memory_content))
-
-            # Tool detection (new) - any node connected to input-tools becomes a tool
-            elif target_handle == 'input-tools':
-                tool_type = source_node.get('type')
-                logger.info(f"[AI Agent] Found tool connected via input-tools: type={tool_type}, node_id={source_node_id}")
-                tool_params = await database.get_node_parameters(source_node_id) or {}
-
-                # Build base tool entry
-                tool_entry = {
-                    'node_id': source_node_id,
-                    'node_type': tool_type,
-                    'parameters': tool_params,
-                    'label': source_node.get('data', {}).get('label', tool_type)
-                }
-
-                # Special handling for androidTool - discover connected Android services
-                # Follows n8n Sub-Node pattern
-                if tool_type == 'androidTool':
-                    connected_services = []
-
-                    # Scan edges for Android nodes connected to this toolkit
-                    for service_edge in edges:
-                        # Skip if not targeting this androidTool node
-                        if service_edge.get('target') != source_node_id:
-                            continue
-
-                        target_handle = service_edge.get('targetHandle')
-                        # Accept input-main or no handle (ReactFlow may omit handle for single-input nodes)
-                        if target_handle is not None and target_handle != 'input-main':
-                            logger.debug(f"[Android Toolkit] Skipping edge with targetHandle: {target_handle}")
-                            continue
-
-                        android_node_id = service_edge.get('source')
-                        android_node = next((n for n in nodes if n.get('id') == android_node_id), None)
-
-                        if android_node and android_node.get('type') in ANDROID_SERVICE_NODE_TYPES:
-                            android_params = await database.get_node_parameters(android_node_id) or {}
-                            connected_services.append({
-                                'node_id': android_node_id,
-                                'node_type': android_node.get('type'),
-                                'service_id': android_params.get('service_id'),
-                                'action': android_params.get('action'),  # Default action
-                                'parameters': android_params,
-                                'label': android_node.get('data', {}).get('label', android_node.get('type'))
-                            })
-                            logger.debug(f"Android toolkit connected service: {android_params.get('service_id')}")
-
-                    tool_entry['connected_services'] = connected_services
-                    logger.debug(f"Android toolkit has {len(connected_services)} connected services")
-
-                tool_data.append(tool_entry)
-                logger.debug(f"AI Agent connected tool: {tool_type}")
-
-    # Log tool data collection results
-    logger.info(f"[AI Agent Handler] Collected tools: count={len(tool_data)}, workflow_id={workflow_id}")
-    for td in tool_data:
-        logger.info(f"[AI Agent Handler] Tool: type={td.get('node_type')}, node_id={td.get('node_id')}")
-
-    # Get broadcaster for real-time status updates
-    from services.status_broadcaster import get_status_broadcaster
-    broadcaster = get_status_broadcaster()
-
-    return await ai_service.execute_agent(
-        node_id,
-        parameters,
-        memory_data=memory_data,
-        tool_data=tool_data if tool_data else None,
-        broadcaster=broadcaster,
-        workflow_id=workflow_id
-    )
-
-
-async def handle_chat_agent(
-    node_id: str,
-    node_type: str,
-    parameters: Dict[str, Any],
-    context: Dict[str, Any],
-    ai_service: "AIService",
-    database: "Database"
-) -> Dict[str, Any]:
-    """Handle Chat Agent node execution with skill-based tool calling.
-
-    Chat Agent supports:
-    - Memory (input-memory): SimpleMemory node for conversation history
-    - Skills (input-skill): Provide context/instructions via SKILL.md
-    - Tools (input-tools): Tool nodes (httpRequest, etc.) for LangGraph tool calling
-
-    Args:
-        node_id: The node ID
-        node_type: The node type (chatAgent)
-        parameters: Resolved parameters
-        context: Execution context with nodes, edges, session_id, start_time, execution_id
-        ai_service: The AI service instance
-        database: The database instance
-
-    Returns:
-        Execution result dict
-    """
-    nodes = context.get('nodes')
-    edges = context.get('edges')
-    workflow_id = context.get('workflow_id')
-    memory_data = None
-    skill_data: List[Dict[str, Any]] = []
-    tool_data: List[Dict[str, Any]] = []  # Tools for LangGraph
-    input_data: Optional[Dict[str, Any]] = None
-
-    logger.info(f"[Chat Agent] Processing node {node_id}, workflow_id={workflow_id}")
-
-    if edges and nodes:
-        incoming_edges = [e for e in edges if e.get('target') == node_id]
-        logger.debug(f"[Chat Agent] Incoming edges: {len(incoming_edges)}")
-
-        for edge in edges:
-            if edge.get('target') != node_id:
-                continue
-
-            target_handle = edge.get('targetHandle')
-            source_node_id = edge.get('source')
-            source_node = next((n for n in nodes if n.get('id') == source_node_id), None)
-
-            if not source_node:
-                continue
-
-            # Memory detection - load markdown content (same as AI Agent)
-            if target_handle == 'input-memory':
-                if source_node.get('type') == 'simpleMemory':
-                    memory_params = await database.get_node_parameters(source_node_id) or {}
-                    memory_session_id = memory_params.get('sessionId', 'default')
-                    window_size = int(memory_params.get('windowSize', 10))
-                    memory_content = memory_params.get('memoryContent', '# Conversation History\n\n*No messages yet.*\n')
-                    long_term_enabled = memory_params.get('longTermEnabled', False)
-                    retrieval_count = int(memory_params.get('retrievalCount', 3))
-
-                    memory_data = {
-                        'node_id': source_node_id,
-                        'session_id': memory_session_id,
-                        'window_size': window_size,
-                        'memory_content': memory_content,
-                        'long_term_enabled': long_term_enabled,
-                        'retrieval_count': retrieval_count
-                    }
-                    logger.info(f"[Chat Agent] Connected memory node: session={memory_session_id}, content_length={len(memory_content)}")
-
-            # Skill detection - nodes connected to input-skill handle
-            elif target_handle == 'input-skill':
-                skill_type = source_node.get('type')
-                skill_params = await database.get_node_parameters(source_node_id) or {}
-                skill_entry = {
-                    'node_id': source_node_id,
-                    'node_type': skill_type,
-                    'skill_name': skill_params.get('skillName', skill_type),
-                    'parameters': skill_params,
-                    'label': source_node.get('data', {}).get('label', skill_type)
-                }
-                skill_data.append(skill_entry)
-                logger.debug(f"[Chat Agent] Connected skill: {skill_type}")
-
-            # Tool detection - nodes connected to input-tools handle (for LangGraph)
-            elif target_handle == 'input-tools':
-                tool_type = source_node.get('type')
-                tool_params = await database.get_node_parameters(source_node_id) or {}
-                tool_entry = {
-                    'node_id': source_node_id,
-                    'node_type': tool_type,
-                    'parameters': tool_params,
-                    'label': source_node.get('data', {}).get('label', tool_type)
-                }
-                tool_data.append(tool_entry)
-                logger.info(f"[Chat Agent] Connected tool: {tool_type} ({tool_entry['label']})")
-
-            # Input data detection - nodes connected to input-main
-            elif target_handle == 'input-main' or target_handle is None:
-                source_output = context.get('outputs', {}).get(source_node_id)
-                if source_output:
-                    input_data = source_output
-                    logger.debug(f"[Chat Agent] Input from {source_node.get('type')}: {list(source_output.keys())}")
-
-    # Log discovered connections
-    logger.info(f"[Chat Agent] Discovered: memory={'yes' if memory_data else 'no'}, {len(skill_data)} skills, {len(tool_data)} tools")
-    for td in tool_data:
-        logger.debug(f"[Chat Agent] Tool: type={td.get('node_type')}, label={td.get('label')}")
-
-    # Auto-use input data if prompt is empty (fallback for trigger nodes)
-    if not parameters.get('prompt') and input_data:
-        prompt = (
-            input_data.get('message') or
-            input_data.get('text') or
-            input_data.get('content') or
-            str(input_data)
-        )
-        parameters = {**parameters, 'prompt': prompt}
-        logger.info(f"[Chat Agent] Auto-using input as prompt: {prompt[:100] if len(str(prompt)) > 100 else prompt}...")
-
-    # Get broadcaster for real-time status updates
-    from services.status_broadcaster import get_status_broadcaster
-    broadcaster = get_status_broadcaster()
-
-    # Execute Chat Agent with memory, skills and tools
-    return await ai_service.execute_chat_agent(
-        node_id,
-        parameters,
-        memory_data=memory_data,
-        skill_data=skill_data if skill_data else None,
-        tool_data=tool_data if tool_data else None,
-        broadcaster=broadcaster,
-        workflow_id=workflow_id
-    )
-
-
-async def handle_ai_chat_model(
-    node_id: str,
-    node_type: str,
-    parameters: Dict[str, Any],
-    context: Dict[str, Any],
-    ai_service: "AIService"
-) -> Dict[str, Any]:
-    """Handle AI chat model node execution.
-
-    Args:
-        node_id: The node ID
-        node_type: The node type (openaiChatModel, anthropicChatModel, etc.)
-        parameters: Resolved parameters
-        context: Execution context
-        ai_service: The AI service instance
-
-    Returns:
-        Execution result dict
-    """
-    return await ai_service.execute_chat(node_id, node_type, parameters)
-
-
-async def handle_simple_memory(
-    node_id: str,
-    node_type: str,
-    parameters: Dict[str, Any],
-    context: Dict[str, Any]
-) -> Dict[str, Any]:
-    """Handle simple memory node execution.
-
-    Args:
-        node_id: The node ID
-        node_type: The node type (simpleMemory)
-        parameters: Resolved parameters
-        context: Execution context
-
-    Returns:
-        Execution result dict with session info and messages
-    """
-    from services.memory_store import get_messages, clear_session
-
-    session_id = parameters.get('sessionId', 'default')
-    memory_type = parameters.get('memoryType', 'buffer')
-    window_size = int(parameters.get('windowSize', 10)) if memory_type == 'window' else None
-    clear_on_run = parameters.get('clearOnRun', False)
-
-    if clear_on_run:
-        cleared = clear_session(session_id)
-        logger.info(f"[Memory] Cleared {cleared} messages from session '{session_id}'")
-
-    messages = get_messages(session_id, window_size)
-
-    return {
-        "success": True,
-        "result": {
-            "session_id": session_id,
-            "messages": messages,
-            "message_count": len(messages),
-            "memory_type": memory_type,
-            "window_size": window_size
-        }
-    }
+"""AI node handlers - AI Agent, Zeenie, AI Chat Model, Simple Memory."""
+
+from typing import Dict, Any, List, Optional, TYPE_CHECKING
+from core.logging import get_logger
+from constants import ANDROID_SERVICE_NODE_TYPES
+
+if TYPE_CHECKING:
+    from services.ai import AIService
+    from core.database import Database
+
+logger = get_logger(__name__)
+
+
+async def handle_ai_agent(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any],
+    ai_service: "AIService",
+    database: "Database"
+) -> Dict[str, Any]:
+    """Handle AI agent node execution with memory and tool support.
+
+    Args:
+        node_id: The node ID
+        node_type: The node type (aiAgent)
+        parameters: Resolved parameters
+        context: Execution context with nodes, edges, session_id, start_time, execution_id
+        ai_service: The AI service instance
+        database: The database instance
+
+    Returns:
+        Execution result dict
+    """
+    nodes = context.get('nodes')
+    edges = context.get('edges')
+    execution_id = context.get('execution_id', 'unknown')
+    workflow_id = context.get('workflow_id')  # Extract for status broadcasts
+    memory_data = None
+    tool_data: List[Dict[str, Any]] = []  # Collect connected tool nodes
+
+    logger.info(f"[AI Agent] Processing node {node_id}, edges={len(edges) if edges else 0}, nodes={len(nodes) if nodes else 0}, workflow_id={workflow_id}")
+
+    if edges and nodes:
+        # Log all edges targeting this AI Agent for debugging
+        incoming_edges = [e for e in edges if e.get('target') == node_id]
+        logger.info(f"[AI Agent] Incoming edges to {node_id}: {len(incoming_edges)}")
+        for e in incoming_edges:
+            logger.info(f"[AI Agent] Edge: source={e.get('source')}, targetHandle={e.get('targetHandle')}")
+
+        # Check for tool edges specifically
+        tool_incoming = [e for e in incoming_edges if e.get('targetHandle') == 'input-tools']
+        logger.info(f"[AI Agent] Tool edges (input-tools handle): {len(tool_incoming)}")
+
+        for edge in edges:
+            if edge.get('target') != node_id:
+                continue
+
+            target_handle = edge.get('targetHandle')
+            source_node_id = edge.get('source')
+            source_node = next((n for n in nodes if n.get('id') == source_node_id), None)
+
+            if not source_node:
+                continue
+
+            # Memory detection - load markdown content for editing
+            if target_handle == 'input-memory':
+                if source_node.get('type') == 'simpleMemory':
+                    memory_params = await database.get_node_parameters(source_node_id) or {}
+                    memory_session_id = memory_params.get('sessionId', 'default')
+                    window_size = int(memory_params.get('windowSize', 10))
+                    memory_content = memory_params.get('memoryContent', '# Conversation History\n\n*No messages yet.*\n')
+                    long_term_enabled = memory_params.get('longTermEnabled', False)
+                    retrieval_count = int(memory_params.get('retrievalCount', 3))
+
+                    memory_data = {
+                        'node_id': source_node_id,  # For saving updated content
+                        'session_id': memory_session_id,
+                        'window_size': window_size,
+                        'memory_content': memory_content,
+                        'long_term_enabled': long_term_enabled,
+                        'retrieval_count': retrieval_count
+                    }
+                    logger.debug("AI Agent connected memory node", memory_session=memory_session_id, content_length=len(memory_content))
+
+            # Tool detection (new) - any node connected to input-tools becomes a tool
+            elif target_handle == 'input-tools':
+                tool_type = source_node.get('type')
+                logger.info(f"[AI Agent] Found tool connected via input-tools: type={tool_type}, node_id={source_node_id}")
+                tool_params = await database.get_node_parameters(source_node_id) or {}
+
+                # Build base tool entry
+                tool_entry = {
+                    'node_id': source_node_id,
+                    'node_type': tool_type,
+                    'parameters': tool_params,
+                    'label': source_node.get('data', {}).get('label', tool_type)
+                }
+
+                # Special handling for androidTool - discover connected Android services
+                # Follows n8n Sub-Node pattern
+                if tool_type == 'androidTool':
+                    connected_services = []
+
+                    # Scan edges for Android nodes connected to this toolkit
+                    for service_edge in edges:
+                        # Skip if not targeting this androidTool node
+                        if service_edge.get('target') != source_node_id:
+                            continue
+
+                        target_handle = service_edge.get('targetHandle')
+                        # Accept input-main or no handle (ReactFlow may omit handle for single-input nodes)
+                        if target_handle is not None and target_handle != 'input-main':
+                            logger.debug(f"[Android Toolkit] Skipping edge with targetHandle: {target_handle}")
+                            continue
+
+                        android_node_id = service_edge.get('source')
+                        android_node = next((n for n in nodes if n.get('id') == android_node_id), None)
+
+                        if android_node and android_node.get('type') in ANDROID_SERVICE_NODE_TYPES:
+                            android_params = await database.get_node_parameters(android_node_id) or {}
+                            connected_services.append({
+                                'node_id': android_node_id,
+                                'node_type': android_node.get('type'),
+                                'service_id': android_params.get('service_id'),
+                                'action': android_params.get('action'),  # Default action
+                                'parameters': android_params,
+                                'label': android_node.get('data', {}).get('label', android_node.get('type'))
+                            })
+                            logger.debug(f"Android toolkit connected service: {android_params.get('service_id')}")
+
+                    tool_entry['connected_services'] = connected_services
+                    logger.debug(f"Android toolkit has {len(connected_services)} connected services")
+
+                tool_data.append(tool_entry)
+                logger.debug(f"AI Agent connected tool: {tool_type}")
+
+    # Log tool data collection results
+    logger.info(f"[AI Agent Handler] Collected tools: count={len(tool_data)}, workflow_id={workflow_id}")
+    for td in tool_data:
+        logger.info(f"[AI Agent Handler] Tool: type={td.get('node_type')}, node_id={td.get('node_id')}")
+
+    # Get broadcaster for real-time status updates
+    from services.status_broadcaster import get_status_broadcaster
+    broadcaster = get_status_broadcaster()
+
+    return await ai_service.execute_agent(
+        node_id,
+        parameters,
+        memory_data=memory_data,
+        tool_data=tool_data if tool_data else None,
+        broadcaster=broadcaster,
+        workflow_id=workflow_id
+    )
+
+
+async def handle_chat_agent(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any],
+    ai_service: "AIService",
+    database: "Database"
+) -> Dict[str, Any]:
+    """Handle Zeenie node execution with skill-based tool calling.
+
+    Zeenie supports:
+    - Memory (input-memory): SimpleMemory node for conversation history
+    - Skills (input-skill): Provide context/instructions via SKILL.md
+    - Tools (input-tools): Tool nodes (httpRequest, etc.) for LangGraph tool calling
+
+    Args:
+        node_id: The node ID
+        node_type: The node type (chatAgent)
+        parameters: Resolved parameters
+        context: Execution context with nodes, edges, session_id, start_time, execution_id
+        ai_service: The AI service instance
+        database: The database instance
+
+    Returns:
+        Execution result dict
+    """
+    nodes = context.get('nodes')
+    edges = context.get('edges')
+    workflow_id = context.get('workflow_id')
+    memory_data = None
+    skill_data: List[Dict[str, Any]] = []
+    tool_data: List[Dict[str, Any]] = []  # Tools for LangGraph
+    input_data: Optional[Dict[str, Any]] = None
+
+    logger.info(f"[Chat Agent] Processing node {node_id}, workflow_id={workflow_id}")
+
+    if edges and nodes:
+        incoming_edges = [e for e in edges if e.get('target') == node_id]
+        logger.debug(f"[Chat Agent] Incoming edges: {len(incoming_edges)}")
+
+        for edge in edges:
+            if edge.get('target') != node_id:
+                continue
+
+            target_handle = edge.get('targetHandle')
+            source_node_id = edge.get('source')
+            source_node = next((n for n in nodes if n.get('id') == source_node_id), None)
+
+            if not source_node:
+                continue
+
+            # Memory detection - load markdown content (same as AI Agent)
+            if target_handle == 'input-memory':
+                if source_node.get('type') == 'simpleMemory':
+                    memory_params = await database.get_node_parameters(source_node_id) or {}
+                    memory_session_id = memory_params.get('sessionId', 'default')
+                    window_size = int(memory_params.get('windowSize', 10))
+                    memory_content = memory_params.get('memoryContent', '# Conversation History\n\n*No messages yet.*\n')
+                    long_term_enabled = memory_params.get('longTermEnabled', False)
+                    retrieval_count = int(memory_params.get('retrievalCount', 3))
+
+                    memory_data = {
+                        'node_id': source_node_id,
+                        'session_id': memory_session_id,
+                        'window_size': window_size,
+                        'memory_content': memory_content,
+                        'long_term_enabled': long_term_enabled,
+                        'retrieval_count': retrieval_count
+                    }
+                    logger.info(f"[Chat Agent] Connected memory node: session={memory_session_id}, content_length={len(memory_content)}")
+
+            # Skill detection - nodes connected to input-skill handle
+            elif target_handle == 'input-skill':
+                skill_type = source_node.get('type')
+                skill_params = await database.get_node_parameters(source_node_id) or {}
+                skill_entry = {
+                    'node_id': source_node_id,
+                    'node_type': skill_type,
+                    'skill_name': skill_params.get('skillName', skill_type),
+                    'parameters': skill_params,
+                    'label': source_node.get('data', {}).get('label', skill_type)
+                }
+                skill_data.append(skill_entry)
+                logger.debug(f"[Chat Agent] Connected skill: {skill_type}")
+
+            # Tool detection - nodes connected to input-tools handle (for LangGraph)
+            elif target_handle == 'input-tools':
+                tool_type = source_node.get('type')
+                tool_params = await database.get_node_parameters(source_node_id) or {}
+                tool_entry = {
+                    'node_id': source_node_id,
+                    'node_type': tool_type,
+                    'parameters': tool_params,
+                    'label': source_node.get('data', {}).get('label', tool_type)
+                }
+
+                # Special handling for androidTool - discover connected Android services
+                # Follows n8n Sub-Node pattern (same as AI Agent)
+                if tool_type == 'androidTool':
+                    connected_services = []
+
+                    # Scan edges for Android nodes connected to this toolkit
+                    for service_edge in edges:
+                        # Skip if not targeting this androidTool node
+                        if service_edge.get('target') != source_node_id:
+                            continue
+
+                        service_target_handle = service_edge.get('targetHandle')
+                        # Accept input-main or no handle (ReactFlow may omit handle for single-input nodes)
+                        if service_target_handle is not None and service_target_handle != 'input-main':
+                            continue
+
+                        android_node_id = service_edge.get('source')
+                        android_node = next((n for n in nodes if n.get('id') == android_node_id), None)
+
+                        if android_node and android_node.get('type') in ANDROID_SERVICE_NODE_TYPES:
+                            android_params = await database.get_node_parameters(android_node_id) or {}
+                            connected_services.append({
+                                'node_id': android_node_id,
+                                'node_type': android_node.get('type'),
+                                'service_id': android_params.get('service_id'),
+                                'action': android_params.get('action'),
+                                'parameters': android_params,
+                                'label': android_node.get('data', {}).get('label', android_node.get('type'))
+                            })
+                            logger.debug(f"[Chat Agent] Android toolkit connected service: {android_params.get('service_id')}")
+
+                    tool_entry['connected_services'] = connected_services
+                    logger.info(f"[Chat Agent] Android toolkit has {len(connected_services)} connected services")
+
+                tool_data.append(tool_entry)
+                logger.info(f"[Chat Agent] Connected tool: {tool_type} ({tool_entry['label']})")
+
+            # Input data detection - nodes connected to input-main
+            elif target_handle == 'input-main' or target_handle is None:
+                source_output = context.get('outputs', {}).get(source_node_id)
+                if source_output:
+                    input_data = source_output
+                    logger.debug(f"[Chat Agent] Input from {source_node.get('type')}: {list(source_output.keys())}")
+
+    # Log discovered connections
+    logger.info(f"[Chat Agent] Discovered: memory={'yes' if memory_data else 'no'}, {len(skill_data)} skills, {len(tool_data)} tools")
+    for td in tool_data:
+        logger.debug(f"[Chat Agent] Tool: type={td.get('node_type')}, label={td.get('label')}")
+
+    # Auto-use input data if prompt is empty (fallback for trigger nodes)
+    if not parameters.get('prompt') and input_data:
+        prompt = (
+            input_data.get('message') or
+            input_data.get('text') or
+            input_data.get('content') or
+            str(input_data)
+        )
+        parameters = {**parameters, 'prompt': prompt}
+        logger.info(f"[Chat Agent] Auto-using input as prompt: {prompt[:100] if len(str(prompt)) > 100 else prompt}...")
+
+    # Get broadcaster for real-time status updates
+    from services.status_broadcaster import get_status_broadcaster
+    broadcaster = get_status_broadcaster()
+
+    # Execute Chat Agent with memory, skills and tools
+    return await ai_service.execute_chat_agent(
+        node_id,
+        parameters,
+        memory_data=memory_data,
+        skill_data=skill_data if skill_data else None,
+        tool_data=tool_data if tool_data else None,
+        broadcaster=broadcaster,
+        workflow_id=workflow_id
+    )
+
+
+async def handle_ai_chat_model(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any],
+    ai_service: "AIService"
+) -> Dict[str, Any]:
+    """Handle AI chat model node execution.
+
+    Args:
+        node_id: The node ID
+        node_type: The node type (openaiChatModel, anthropicChatModel, etc.)
+        parameters: Resolved parameters
+        context: Execution context
+        ai_service: The AI service instance
+
+    Returns:
+        Execution result dict
+    """
+    return await ai_service.execute_chat(node_id, node_type, parameters)
+
+
+async def handle_simple_memory(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Handle simple memory node execution.
+
+    Args:
+        node_id: The node ID
+        node_type: The node type (simpleMemory)
+        parameters: Resolved parameters
+        context: Execution context
+
+    Returns:
+        Execution result dict with session info and messages
+    """
+    from services.memory_store import get_messages, clear_session
+
+    session_id = parameters.get('sessionId', 'default')
+    memory_type = parameters.get('memoryType', 'buffer')
+    window_size = int(parameters.get('windowSize', 10)) if memory_type == 'window' else None
+    clear_on_run = parameters.get('clearOnRun', False)
+
+    if clear_on_run:
+        cleared = clear_session(session_id)
+        logger.info(f"[Memory] Cleared {cleared} messages from session '{session_id}'")
+
+    messages = get_messages(session_id, window_size)
+
+    return {
+        "success": True,
+        "result": {
+            "session_id": session_id,
+            "messages": messages,
+            "message_count": len(messages),
+            "memory_type": memory_type,
+            "window_size": window_size
+        }
+    }