machinaos 0.0.1

package/server/services/ai.py

@@ -0,0 +1,2415 @@
+"""AI service for managing language models with LangGraph state machine support."""
+
+import re
+import time
+import httpx
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Dict, Any, List, Optional, Callable, Type, TypedDict, Annotated, Sequence
+import operator
+
+from langchain_openai import ChatOpenAI
+from langchain_anthropic import ChatAnthropic
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_groq import ChatGroq
+from langchain_core.messages import HumanMessage, SystemMessage, AIMessage, BaseMessage, ToolMessage
+
+# Conditional import for Cerebras (requires Python <3.13)
+try:
+    from langchain_cerebras import ChatCerebras
+    CEREBRAS_AVAILABLE = True
+except ImportError:
+    ChatCerebras = None
+    CEREBRAS_AVAILABLE = False
+from langchain_core.tools import StructuredTool
+from langgraph.graph import StateGraph, END
+from pydantic import BaseModel, Field, create_model
+import json
+
+from core.config import Settings
+from core.logging import get_logger, log_execution_time, log_api_call
+from services.auth import AuthService
+
+logger = get_logger(__name__)
+
+
+# =============================================================================
+# MARKDOWN MEMORY HELPERS - Parse/append/trim conversation markdown
+# =============================================================================
+
+def _parse_memory_markdown(content: str) -> List[BaseMessage]:
+    """Parse markdown memory content into LangChain messages.
+
+    Markdown format:
+    ### **Human** (timestamp)
+    message content
+
+    ### **Assistant** (timestamp)
+    response content
+    """
+    messages = []
+    pattern = r'### \*\*(Human|Assistant)\*\*[^\n]*\n(.*?)(?=\n### \*\*|$)'
+    for role, text in re.findall(pattern, content, re.DOTALL):
+        text = text.strip()
+        if text:
+            msg_class = HumanMessage if role == 'Human' else AIMessage
+            messages.append(msg_class(content=text))
+    return messages
+
+
+def _append_to_memory_markdown(content: str, role: str, message: str) -> str:
+    """Append a message to markdown memory content."""
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    label = "Human" if role == "human" else "Assistant"
+    entry = f"\n### **{label}** ({ts})\n{message}\n"
+    # Remove empty state message if present
+    return content.replace("*No messages yet.*\n", "") + entry
+
+
+def _trim_markdown_window(content: str, window_size: int) -> tuple:
+    """Keep last N message pairs, return (trimmed_content, removed_texts).
+
+    Args:
+        content: Full markdown content
+        window_size: Number of message PAIRS to keep (human+assistant)
+
+    Returns:
+        Tuple of (trimmed markdown, list of removed message texts for archival)
+    """
+    pattern = r'(### \*\*(Human|Assistant)\*\*[^\n]*\n.*?)(?=\n### \*\*|$)'
+    blocks = [m[0] for m in re.findall(pattern, content, re.DOTALL)]
+
+    if len(blocks) <= window_size * 2:
+        return content, []
+
+    keep = blocks[-(window_size * 2):]
+    removed = blocks[:-(window_size * 2)]
+
+    # Extract text from removed blocks for vector storage
+    removed_texts = []
+    for block in removed:
+        match = re.search(r'\n(.*)$', block, re.DOTALL)
+        if match:
+            removed_texts.append(match.group(1).strip())
+
+    return "# Conversation History\n" + "\n".join(keep), removed_texts
+
+
+# Global cache for vector stores per session (InMemoryVectorStore)
+_memory_vector_stores: Dict[str, Any] = {}
+
+
+def _get_memory_vector_store(session_id: str):
+    """Get or create InMemoryVectorStore for a session."""
+    if session_id not in _memory_vector_stores:
+        try:
+            from langchain_core.vectorstores import InMemoryVectorStore
+            from langchain_huggingface import HuggingFaceEmbeddings
+
+            embeddings = HuggingFaceEmbeddings(model_name="BAAI/bge-small-en-v1.5")
+            _memory_vector_stores[session_id] = InMemoryVectorStore(embeddings)
+            logger.debug(f"[Memory] Created vector store for session '{session_id}'")
+        except ImportError as e:
+            logger.warning(f"[Memory] Vector store not available: {e}")
+            return None
+    return _memory_vector_stores[session_id]
+
+
+# =============================================================================
+# AI PROVIDER REGISTRY - Single source of truth for provider configurations
+# =============================================================================
+
+@dataclass
+class ProviderConfig:
+    """Configuration for an AI provider."""
+    name: str
+    model_class: Type
+    api_key_param: str  # Parameter name for API key in model constructor
+    max_tokens_param: str  # Parameter name for max tokens
+    detection_patterns: tuple  # Patterns to detect this provider from model name
+    default_model: str  # Default model when none specified
+    models_endpoint: str  # API endpoint to fetch models
+    models_header_fn: Callable[[str], dict]  # Function to create headers
+
+
+@dataclass
+class ThinkingConfig:
+    """Unified thinking/reasoning configuration across AI providers.
+
+    LangChain parameters per provider (Jan 2026):
+    - Claude: thinking={"type": "enabled", "budget_tokens": budget}, temp must be 1
+    - OpenAI o-series: reasoning_effort ('minimal', 'low', 'medium', 'high')
+    - Gemini 3+: thinking_level ('low', 'medium', 'high')
+    - Gemini 2.5: thinking_budget (int tokens)
+    - Groq: reasoning_format ('parsed', 'hidden')
+    """
+    enabled: bool = False
+    budget: int = 2048      # Token budget (Claude, Gemini 2.5)
+    effort: str = 'medium'  # Effort level: 'minimal', 'low', 'medium', 'high' (OpenAI o-series)
+    level: str = 'medium'   # Thinking level: 'low', 'medium', 'high' (Gemini 3+)
+    format: str = 'parsed'  # Output format: 'parsed', 'hidden' (Groq)
+
+
+def _openai_headers(api_key: str) -> dict:
+    return {'Authorization': f'Bearer {api_key}'}
+
+
+def _anthropic_headers(api_key: str) -> dict:
+    return {'x-api-key': api_key, 'anthropic-version': '2023-06-01'}
+
+
+def _gemini_headers(api_key: str) -> dict:
+    return {}  # API key in URL for Gemini
+
+
+def _openrouter_headers(api_key: str) -> dict:
+    return {
+        'Authorization': f'Bearer {api_key}',
+        'HTTP-Referer': 'http://localhost:3000',
+        'X-Title': 'MachinaOS'
+    }
+
+
+def _groq_headers(api_key: str) -> dict:
+    return {'Authorization': f'Bearer {api_key}'}
+
+
+def _cerebras_headers(api_key: str) -> dict:
+    return {'Authorization': f'Bearer {api_key}'}
+
+
+# Provider configurations
+PROVIDER_CONFIGS: Dict[str, ProviderConfig] = {
+    'openai': ProviderConfig(
+        name='openai',
+        model_class=ChatOpenAI,
+        api_key_param='openai_api_key',
+        max_tokens_param='max_tokens',
+        detection_patterns=('gpt', 'openai', 'o1'),
+        default_model='gpt-4o-mini',
+        models_endpoint='https://api.openai.com/v1/models',
+        models_header_fn=_openai_headers
+    ),
+    'anthropic': ProviderConfig(
+        name='anthropic',
+        model_class=ChatAnthropic,
+        api_key_param='anthropic_api_key',
+        max_tokens_param='max_tokens',
+        detection_patterns=('claude', 'anthropic'),
+        default_model='claude-3-5-sonnet-20241022',
+        models_endpoint='https://api.anthropic.com/v1/models',
+        models_header_fn=_anthropic_headers
+    ),
+    'gemini': ProviderConfig(
+        name='gemini',
+        model_class=ChatGoogleGenerativeAI,
+        api_key_param='google_api_key',
+        max_tokens_param='max_output_tokens',
+        detection_patterns=('gemini', 'google'),
+        default_model='gemini-1.5-pro',
+        models_endpoint='https://generativelanguage.googleapis.com/v1beta/models',
+        models_header_fn=_gemini_headers
+    ),
+    'openrouter': ProviderConfig(
+        name='openrouter',
+        model_class=ChatOpenAI,  # OpenRouter is OpenAI API compatible
+        api_key_param='api_key',  # ChatOpenAI accepts 'api_key' as alias
+        max_tokens_param='max_tokens',
+        detection_patterns=('openrouter',),
+        default_model='openai/gpt-4o-mini',
+        models_endpoint='https://openrouter.ai/api/v1/models',
+        models_header_fn=_openrouter_headers
+    ),
+    'groq': ProviderConfig(
+        name='groq',
+        model_class=ChatGroq,
+        api_key_param='api_key',
+        max_tokens_param='max_tokens',
+        detection_patterns=('groq',),
+        default_model='llama-3.3-70b-versatile',
+        models_endpoint='https://api.groq.com/openai/v1/models',
+        models_header_fn=_groq_headers
+    ),
+}
+
+# Add Cerebras only if available (requires Python <3.13)
+if CEREBRAS_AVAILABLE:
+    PROVIDER_CONFIGS['cerebras'] = ProviderConfig(
+        name='cerebras',
+        model_class=ChatCerebras,
+        api_key_param='api_key',
+        max_tokens_param='max_tokens',
+        detection_patterns=('cerebras',),
+        default_model='llama-3.3-70b',
+        models_endpoint='https://api.cerebras.ai/v1/models',
+        models_header_fn=_cerebras_headers
+    )
+
+
+def detect_provider_from_model(model: str) -> str:
+    """Detect AI provider from model name using registry patterns."""
+    model_lower = model.lower()
+    for provider_name, config in PROVIDER_CONFIGS.items():
+        if any(pattern in model_lower for pattern in config.detection_patterns):
+            return provider_name
+    return 'openai'  # default
+
+
+def is_model_valid_for_provider(model: str, provider: str) -> bool:
+    """Check if model name matches the provider's patterns."""
+    config = PROVIDER_CONFIGS.get(provider)
+    if not config:
+        return True
+    model_lower = model.lower()
+    return any(pattern in model_lower for pattern in config.detection_patterns)
+
+
+def get_default_model(provider: str) -> str:
+    """Get default model for a provider."""
+    config = PROVIDER_CONFIGS.get(provider)
+    return config.default_model if config else 'gpt-4o-mini'
+
+
+# =============================================================================
+# MESSAGE FILTERING UTILITIES - Standardized for all providers
+# =============================================================================
+
+def is_valid_message_content(content: Any) -> bool:
+    """Check if message content is valid (non-empty) for API calls.
+
+    This is a standardized utility for validating message content before:
+    - Saving to conversation memory
+    - Including in API requests
+    - Building message history
+
+    Args:
+        content: The message content to validate (str, list, or other)
+
+    Returns:
+        True if content is valid and non-empty, False otherwise
+    """
+    if content is None:
+        return False
+
+    # Handle list content format (Gemini returns [{"type": "text", "text": "..."}])
+    if isinstance(content, list):
+        return any(
+            (isinstance(block, dict) and block.get('text', '').strip()) or
+            (isinstance(block, str) and block.strip())
+            for block in content
+        )
+
+    # Handle string content (most common)
+    if isinstance(content, str):
+        return bool(content.strip())
+
+    # Other truthy content types
+    return bool(content)
+
+
+def filter_empty_messages(messages: Sequence[BaseMessage]) -> List[BaseMessage]:
+    """Filter out messages with empty content to prevent API errors.
+
+    This is a standardized utility that handles empty message filtering for all
+    AI providers (OpenAI, Anthropic/Claude, Google Gemini, and future providers).
+
+    Different providers have different sensitivities:
+    - Gemini: Emits "HumanMessage with empty content was removed" warning
+    - Claude/Anthropic: Throws errors for empty HumanMessage content
+    - OpenAI: Generally tolerant but empty messages waste tokens
+
+    This filter preserves:
+    - ToolMessage: Always kept (contains tool execution results)
+    - AIMessage with tool_calls: Kept even if content empty (tool calls are content)
+    - SystemMessage: Kept only if has non-empty content
+    - HumanMessage/others: Filtered if content is empty
+
+    Args:
+        messages: Sequence of LangChain BaseMessage objects
+
+    Returns:
+        Filtered list of messages with empty content removed
+    """
+    filtered = []
+
+    for m in messages:
+        # ToolMessage - always keep (contains tool execution results from LangGraph)
+        if isinstance(m, ToolMessage):
+            filtered.append(m)
+            continue
+
+        # AIMessage with tool_calls - keep even if content is empty
+        # (the tool calls themselves are the meaningful content)
+        if isinstance(m, AIMessage) and hasattr(m, 'tool_calls') and m.tool_calls:
+            filtered.append(m)
+            continue
+
+        # SystemMessage - keep only if has non-empty content
+        if isinstance(m, SystemMessage):
+            if hasattr(m, 'content') and m.content and str(m.content).strip():
+                filtered.append(m)
+            continue
+
+        # HumanMessage and other message types - filter out empty content
+        if hasattr(m, 'content'):
+            content = m.content
+
+            # Handle list content format (Gemini returns [{"type": "text", "text": "..."}])
+            if isinstance(content, list):
+                has_content = any(
+                    (isinstance(block, dict) and block.get('text', '').strip()) or
+                    (isinstance(block, str) and block.strip())
+                    for block in content
+                )
+                if has_content:
+                    filtered.append(m)
+
+            # Handle string content (most common)
+            elif isinstance(content, str) and content.strip():
+                filtered.append(m)
+
+            # Handle other non-empty content types (keep if truthy)
+            elif content:
+                filtered.append(m)
+        else:
+            # Message without content attr - keep it (might be special message type)
+            filtered.append(m)
+
+    return filtered
+
+
+# =============================================================================
+# LANGGRAPH STATE MACHINE DEFINITIONS
+# =============================================================================
+
+class AgentState(TypedDict):
+    """State for the LangGraph agent workflow.
+
+    Uses Annotated with operator.add to accumulate messages over steps.
+    This is the core pattern from LangGraph for stateful conversations.
+    """
+    messages: Annotated[Sequence[BaseMessage], operator.add]
+    # Tool outputs storage
+    tool_outputs: Dict[str, Any]
+    # Tool calling support
+    pending_tool_calls: List[Dict[str, Any]]  # Tool calls from LLM to execute
+    # Agent metadata
+    iteration: int
+    max_iterations: int
+    should_continue: bool
+    # Thinking/reasoning content accumulated across iterations
+    thinking_content: Optional[str]
+
+
+def extract_thinking_from_response(response) -> tuple:
+    """Extract text and thinking content from LLM response.
+
+    Handles multiple formats:
+    - LangChain content_blocks API (Claude, Gemini)
+    - OpenAI responses/v1 format (content list with reasoning blocks containing summary)
+    - Groq additional_kwargs.reasoning_content
+    - Raw string content
+
+    Returns:
+        Tuple of (text_content: str, thinking_content: Optional[str])
+    """
+    text_parts = []
+    thinking_parts = []
+
+    logger.debug(f"[extract_thinking] Starting extraction, response type: {type(response).__name__}")
+    logger.debug(f"[extract_thinking] has content_blocks: {hasattr(response, 'content_blocks')}, value: {getattr(response, 'content_blocks', None)}")
+    logger.debug(f"[extract_thinking] has content: {hasattr(response, 'content')}, type: {type(getattr(response, 'content', None))}")
+    logger.debug(f"[extract_thinking] has additional_kwargs: {hasattr(response, 'additional_kwargs')}, value: {getattr(response, 'additional_kwargs', None)}")
+    logger.debug(f"[extract_thinking] has response_metadata: {hasattr(response, 'response_metadata')}, keys: {list(getattr(response, 'response_metadata', {}).keys()) if hasattr(response, 'response_metadata') else None}")
+
+    # Use content_blocks API (LangChain 1.0+) for Claude/Gemini
+    if hasattr(response, 'content_blocks') and response.content_blocks:
+        for block in response.content_blocks:
+            if isinstance(block, dict):
+                block_type = block.get("type", "")
+                if block_type == "reasoning":
+                    thinking_parts.append(block.get("reasoning", ""))
+                elif block_type == "thinking":
+                    thinking_parts.append(block.get("thinking", ""))
+                elif block_type == "text":
+                    text_parts.append(block.get("text", ""))
+
+    # Check additional_kwargs for reasoning_content (Groq, older OpenAI responses)
+    if not thinking_parts and hasattr(response, 'additional_kwargs'):
+        reasoning = response.additional_kwargs.get('reasoning_content')
+        if reasoning:
+            thinking_parts.append(reasoning)
+
+    # Check response_metadata for OpenAI o-series reasoning (responses/v1 format)
+    # The output array contains reasoning items with summaries
+    if not thinking_parts and hasattr(response, 'response_metadata'):
+        metadata = response.response_metadata
+        output = metadata.get('output', [])
+        if isinstance(output, list):
+            for item in output:
+                if isinstance(item, dict) and item.get('type') == 'reasoning':
+                    summary = item.get('summary', [])
+                    if isinstance(summary, list):
+                        for s in summary:
+                            if isinstance(s, dict):
+                                # Handle both summary_text and text types
+                                text = s.get('text', '')
+                                if text:
+                                    thinking_parts.append(text)
+                            elif isinstance(s, str):
+                                thinking_parts.append(s)
+
+    # Check raw content for OpenAI responses/v1 format and other list formats
+    if hasattr(response, 'content'):
+        content = response.content
+        if isinstance(content, str):
+            if not text_parts:
+                text_parts.append(content)
+        elif isinstance(content, list):
+            for block in content:
+                if isinstance(block, dict):
+                    block_type = block.get('type', '')
+                    if block_type == 'text' or block_type == 'output_text':
+                        # Handle both 'text' and 'output_text' (responses/v1 format)
+                        if not text_parts:  # Only add if not already extracted
+                            text_parts.append(block.get('text', ''))
+                    elif block_type == 'reasoning':
+                        # OpenAI responses/v1 format: reasoning block with summary array
+                        # Format: {"type": "reasoning", "summary": [{"type": "text", "text": "..."}, {"type": "summary_text", "text": "..."}]}
+                        summary = block.get('summary', [])
+                        if isinstance(summary, list):
+                            for s in summary:
+                                if isinstance(s, dict):
+                                    s_type = s.get('type', '')
+                                    if s_type in ('text', 'summary_text'):
+                                        thinking_parts.append(s.get('text', ''))
+                                elif isinstance(s, str):
+                                    thinking_parts.append(s)
+                        elif isinstance(summary, str):
+                            thinking_parts.append(summary)
+                        # Also check direct reasoning field
+                        if block.get('reasoning'):
+                            thinking_parts.append(block.get('reasoning', ''))
+                    elif block_type == 'thinking':
+                        thinking_parts.append(block.get('thinking', ''))
+                elif isinstance(block, str) and not text_parts:
+                    text_parts.append(block)
+
+    text = '\n'.join(filter(None, text_parts))
+    thinking = '\n'.join(filter(None, thinking_parts)) if thinking_parts else None
+
+    logger.debug(f"[extract_thinking] Final text_parts: {text_parts}")
+    logger.debug(f"[extract_thinking] Final thinking_parts: {thinking_parts}")
+    logger.debug(f"[extract_thinking] Returning text={repr(text[:100] if text else None)}, thinking={repr(thinking[:100] if thinking else None)}")
+
+    return text, thinking
+
+
+def create_agent_node(chat_model):
+    """Create the agent node function for LangGraph.
+
+    The agent node:
+    1. Receives current state with messages
+    2. Invokes the LLM
+    3. Extracts thinking content if present
+    4. Checks for tool calls in response
+    5. Returns updated state with new AI message, thinking, and pending tool calls
+    """
+    def agent_node(state: AgentState) -> Dict[str, Any]:
+        """Process messages through the LLM and return response."""
+        messages = state["messages"]
+        iteration = state.get("iteration", 0)
+        max_iterations = state.get("max_iterations", 10)
+        existing_thinking = state.get("thinking_content") or ""
+
+        logger.debug(f"[LangGraph] Agent node invoked, iteration={iteration}, messages={len(messages)}")
+
+        # Filter out messages with empty content using standardized utility
+        # Prevents API errors/warnings from Gemini, Claude, and other providers
+        filtered_messages = filter_empty_messages(messages)
+
+        if len(filtered_messages) != len(messages):
+            logger.debug(f"[LangGraph] Filtered out {len(messages) - len(filtered_messages)} empty messages")
+
+        # Invoke the model
+        response = chat_model.invoke(filtered_messages)
+
+        logger.debug(f"[LangGraph] LLM response type: {type(response).__name__}")
+
+        # Extract thinking content from response
+        _, new_thinking = extract_thinking_from_response(response)
+
+        # Accumulate thinking across iterations (for multi-step tool usage)
+        accumulated_thinking = existing_thinking
+        if new_thinking:
+            if accumulated_thinking:
+                accumulated_thinking = f"{accumulated_thinking}\n\n--- Iteration {iteration + 1} ---\n{new_thinking}"
+            else:
+                accumulated_thinking = new_thinking
+            logger.debug(f"[LangGraph] Extracted thinking content ({len(new_thinking)} chars)")
+
+        # Check for Gemini-specific response attributes (safety ratings, block reason)
+        if hasattr(response, 'response_metadata'):
+            meta = response.response_metadata
+            if meta.get('finish_reason') == 'SAFETY':
+                logger.warning("[LangGraph] Gemini response blocked by safety filters")
+            if meta.get('block_reason'):
+                logger.warning(f"[LangGraph] Gemini block reason: {meta.get('block_reason')}")
+
+        # Check for tool calls in the response
+        pending_tool_calls = []
+        should_continue = False
+
+        if hasattr(response, 'tool_calls') and response.tool_calls:
+            # Model wants to use tools
+            pending_tool_calls = response.tool_calls
+            should_continue = True
+            logger.debug(f"[LangGraph] Agent requesting {len(pending_tool_calls)} tool call(s)")
+
+        return {
+            "messages": [response],  # Will be appended via operator.add
+            "tool_outputs": {},
+            "pending_tool_calls": pending_tool_calls,
+            "iteration": iteration + 1,
+            "max_iterations": max_iterations,
+            "should_continue": should_continue,
+            "thinking_content": accumulated_thinking or None
+        }
+
+    return agent_node
+
+
+def create_tool_node(tool_executor: Callable):
+    """Create an async tool execution node for LangGraph.
+
+    The tool node:
+    1. Receives pending tool calls from agent
+    2. Executes each tool via the async tool_executor callback
+    3. Returns ToolMessages with results for the agent
+
+    Note: This returns an async function for use with ainvoke().
+    LangGraph supports async node functions natively.
+    """
+    async def tool_node(state: AgentState) -> Dict[str, Any]:
+        """Execute pending tool calls and return results as ToolMessages."""
+        tool_messages = []
+
+        for tool_call in state.get("pending_tool_calls", []):
+            tool_name = tool_call.get("name", "unknown")
+            tool_args = tool_call.get("args", {})
+            tool_id = tool_call.get("id", "")
+
+            logger.info(f"[LangGraph] Executing tool: {tool_name} (args={tool_args})")
+
+            try:
+                # Directly await the async tool executor (proper async pattern)
+                result = await tool_executor(tool_name, tool_args)
+                logger.info(f"[LangGraph] Tool {tool_name} returned: {str(result)[:100]}")
+            except Exception as e:
+                logger.error(f"[LangGraph] Tool execution failed: {tool_name}", error=str(e))
+                result = {"error": str(e)}
+
+            # Create ToolMessage with result
+            tool_messages.append(ToolMessage(
+                content=json.dumps(result, default=str),
+                tool_call_id=tool_id,
+                name=tool_name
+            ))
+
+            logger.info(f"[LangGraph] Tool {tool_name} completed, result added to messages")
+
+        return {
+            "messages": tool_messages,
+            "pending_tool_calls": [],  # Clear pending after execution
+        }
+
+    return tool_node
+
+
+def should_continue(state: AgentState) -> str:
+    """Determine if the agent should continue or end.
+
+    This is the conditional edge function for LangGraph.
+    Returns "tools" to execute pending tool calls, or "end" to finish.
+    """
+    if state.get("should_continue", False):
+        if state.get("iteration", 0) < state.get("max_iterations", 10):
+            return "tools"
+    return "end"
+
+
+def build_agent_graph(chat_model, tools: List = None, tool_executor: Callable = None):
+    """Build the LangGraph agent workflow with optional tool support.
+
+    Architecture (with tools):
+        START -> agent -> (conditional) -> tools -> agent -> ... -> END
+                             |
+                             +-> END (no tool calls)
+
+    Architecture (without tools):
+        START -> agent -> END
+
+    Args:
+        chat_model: The LangChain chat model
+        tools: Optional list of LangChain tools to bind to the model
+        tool_executor: Optional async callback to execute tools
+    """
+    # Create the graph with our state schema
+    graph = StateGraph(AgentState)
+
+    # Bind tools to model if provided
+    model_with_tools = chat_model
+    if tools:
+        model_with_tools = chat_model.bind_tools(tools)
+        logger.debug(f"[LangGraph] Bound {len(tools)} tools to model")
+
+    # Add the agent node
+    agent_fn = create_agent_node(model_with_tools)
+    graph.add_node("agent", agent_fn)
+
+    # Set entry point
+    graph.set_entry_point("agent")
+
+    if tools and tool_executor:
+        # Add tool execution node
+        tool_fn = create_tool_node(tool_executor)
+        graph.add_node("tools", tool_fn)
+
+        # Conditional routing: agent -> tools or end
+        graph.add_conditional_edges(
+            "agent",
+            should_continue,
+            {
+                "tools": "tools",
+                "end": END
+            }
+        )
+
+        # Tools always route back to agent
+        graph.add_edge("tools", "agent")
+
+        logger.debug("[LangGraph] Built graph with tool execution loop")
+    else:
+        # Simple graph without tools
+        graph.add_conditional_edges(
+            "agent",
+            should_continue,
+            {
+                "tools": "agent",  # Fallback loop (shouldn't happen without tools)
+                "end": END
+            }
+        )
+
+    # Compile the graph
+    return graph.compile()
+
+
+class AIService:
+    """AI model service for LangChain operations."""
+
+    def __init__(self, auth_service: AuthService, database, cache, settings: Settings):
+        self.auth = auth_service
+        self.database = database
+        self.cache = cache
+        self.settings = settings
+
+    def detect_provider(self, model: str) -> str:
+        """Detect AI provider from model name."""
+        return detect_provider_from_model(model)
+
+    def _extract_text_content(self, content, ai_response=None) -> str:
+        """Extract text content from various response formats.
+
+        Handles:
+        - String content (OpenAI, Anthropic)
+        - List of content blocks (Gemini 3+ models)
+        - Empty/None content with error details from metadata
+
+        Args:
+            content: The raw content from response (str, list, or None)
+            ai_response: The full AIMessage for metadata inspection
+
+        Returns:
+            Extracted text string
+
+        Raises:
+            ValueError: If content is empty with details about why
+        """
+        # Handle list content (Gemini format: [{"type": "text", "text": "..."}])
+        if isinstance(content, list):
+            text_parts = []
+            for block in content:
+                if isinstance(block, dict):
+                    if block.get('type') == 'text' and block.get('text'):
+                        text_parts.append(block['text'])
+                    elif 'text' in block:
+                        text_parts.append(str(block['text']))
+                elif isinstance(block, str):
+                    text_parts.append(block)
+            extracted = '\n'.join(text_parts)
+            if extracted.strip():
+                return extracted
+            # List was present but no text extracted
+            logger.warning(f"[LangGraph] Content was list but no text extracted: {content}")
+
+        # Handle string content
+        if isinstance(content, str) and content.strip():
+            return content
+
+        # Content is empty - try to get error details from metadata
+        error_details = []
+        if ai_response and hasattr(ai_response, 'response_metadata'):
+            meta = ai_response.response_metadata
+            finish_reason = meta.get('finish_reason', '')
+
+            if finish_reason == 'SAFETY':
+                error_details.append("Content blocked by safety filters")
+                # Try to get specific blocked categories
+                safety_ratings = meta.get('safety_ratings', [])
+                blocked = [r.get('category') for r in safety_ratings if r.get('blocked')]
+                if blocked:
+                    error_details.append(f"Blocked categories: {', '.join(blocked)}")
+
+            elif finish_reason == 'MAX_TOKENS':
+                # Check if reasoning consumed all tokens
+                token_details = meta.get('output_token_details', {})
+                reasoning_tokens = token_details.get('reasoning', 0)
+                output_tokens = meta.get('usage_metadata', {}).get('candidates_token_count', 0)
+                if reasoning_tokens > 0 and output_tokens == 0:
+                    error_details.append(f"Model used all tokens for reasoning ({reasoning_tokens} tokens). Try increasing max_tokens or simplifying the prompt.")
+                else:
+                    error_details.append("Response truncated due to max_tokens limit")
+
+            elif finish_reason == 'MALFORMED_FUNCTION_CALL':
+                error_details.append("Model returned malformed function call. Tool schema may be incompatible.")
+
+            if meta.get('block_reason'):
+                error_details.append(f"Block reason: {meta.get('block_reason')}")
+
+        if error_details:
+            raise ValueError(f"AI returned empty response. {'; '.join(error_details)}")
+
+        # Generic empty response
+        logger.warning(f"[LangGraph] Empty response with no error details. Content type: {type(content)}, value: {content}")
+        raise ValueError("AI generated empty response. Try rephrasing your prompt or using a different model.")
+
+    def _is_reasoning_model(self, model: str) -> bool:
+        """Check if model supports reasoning (OpenAI o-series).
+
+        O-series models: o1, o1-mini, o1-preview, o3, o3-mini, o4-mini, etc.
+        NOT gpt-4o (which contains 'o' but is not a reasoning model).
+        """
+        model_lower = model.lower()
+        # Check for o-series pattern: starts with 'o' followed by digit
+        # e.g., o1, o1-mini, o3, o3-mini, o4-mini
+        return bool(re.match(r'^o[134](-|$)', model_lower))
+
+    def create_model(self, provider: str, api_key: str, model: str,
+                    temperature: float, max_tokens: int,
+                    thinking: Optional[ThinkingConfig] = None):
+        """Create LangChain model instance using provider registry.
+
+        Args:
+            provider: AI provider name (openai, anthropic, gemini, groq, openrouter)
+            api_key: Provider API key
+            model: Model name/ID
+            temperature: Sampling temperature
+            max_tokens: Maximum response tokens
+            thinking: Optional thinking/reasoning configuration
+
+        Returns:
+            Configured LangChain chat model instance
+        """
+        config = PROVIDER_CONFIGS.get(provider)
+        if not config:
+            raise ValueError(f"Unsupported provider: {provider}")
+
+        # Build kwargs dynamically from registry config
+        kwargs = {
+            config.api_key_param: api_key,
+            'model': model,
+            'temperature': temperature,
+            config.max_tokens_param: max_tokens
+        }
+
+        # OpenRouter uses OpenAI-compatible API with custom base_url
+        if provider == 'openrouter':
+            kwargs['base_url'] = 'https://openrouter.ai/api/v1'
+            kwargs['default_headers'] = {
+                'HTTP-Referer': 'http://localhost:3000',
+                'X-Title': 'MachinaOS'
+            }
+
+        # OpenAI o-series reasoning models ALWAYS require temperature=1
+        # This applies regardless of whether thinking mode is enabled
+        if provider == 'openai' and self._is_reasoning_model(model):
+            if kwargs.get('temperature', 1) != 1:
+                logger.info(f"[AI] OpenAI o-series model '{model}': forcing temperature to 1 (was {kwargs.get('temperature')})")
+                kwargs['temperature'] = 1
+
+        # Apply thinking/reasoning configuration per provider (per LangChain docs Jan 2026)
+        if thinking and thinking.enabled:
+            if provider == 'anthropic':
+                # Claude extended thinking: thinking={"type": "enabled", "budget_tokens": N}
+                # Requires temperature=1, budget min 1024 tokens
+                # IMPORTANT: max_tokens must be greater than budget_tokens
+                budget = max(1024, thinking.budget)
+                # Ensure max_tokens > budget_tokens (add buffer for response)
+                if max_tokens <= budget:
+                    # Set max_tokens to budget + reasonable response space (at least 1024 more)
+                    kwargs[config.max_tokens_param] = budget + max(1024, max_tokens)
+                    logger.info(f"[AI] Claude thinking: adjusted max_tokens from {max_tokens} to {kwargs[config.max_tokens_param]} (budget={budget})")
+                kwargs['thinking'] = {"type": "enabled", "budget_tokens": budget}
+                kwargs['temperature'] = 1  # Required for Claude thinking mode
+            elif provider == 'openai' and self._is_reasoning_model(model):
+                # OpenAI o-series: Use reasoning_effort parameter
+                # Note: reasoning.summary requires organization verification on OpenAI
+                # So we just use reasoning_effort for now
+                kwargs['reasoning_effort'] = thinking.effort
+                # O-series models only support temperature=1
+                kwargs['temperature'] = 1
+                logger.info(f"[AI] OpenAI o-series: reasoning_effort={thinking.effort}, temperature=1")
+            elif provider == 'gemini':
+                # Gemini thinking support varies by model:
+                # - Gemini 2.5 Flash/Pro: Use thinking_budget (int tokens, 0=off, -1=dynamic)
+                # - Gemini 2.0 Flash Thinking: Built-in thinking, use thinking_budget
+                # - Gemini 3 models: Limited/experimental thinking support
+                model_lower = model.lower()
+
+                # Gemini 2.5 models support thinking_budget
+                if 'gemini-2.5' in model_lower or '2.5' in model_lower:
+                    kwargs['thinking_budget'] = thinking.budget
+                    kwargs['include_thoughts'] = True
+                    logger.info(f"[AI] Gemini 2.5 thinking: budget={thinking.budget}")
+                # Gemini 2.0 Flash Thinking model
+                elif 'gemini-2.0-flash-thinking' in model_lower or 'flash-thinking' in model_lower:
+                    kwargs['thinking_budget'] = thinking.budget
+                    kwargs['include_thoughts'] = True
+                    logger.info(f"[AI] Gemini Flash Thinking: budget={thinking.budget}")
+                # Gemini 3 preview models - thinking support is experimental/limited
+                # Only 'low' and 'high' levels may be supported, not 'medium'
+                elif 'gemini-3' in model_lower:
+                    # For Gemini 3, try thinking_budget instead of thinking_level
+                    # as level support is inconsistent across preview models
+                    kwargs['thinking_budget'] = thinking.budget
+                    kwargs['include_thoughts'] = True
+                    logger.info(f"[AI] Gemini 3 thinking: using budget={thinking.budget} (level support varies)")
+                # Other Gemini 2.x models - try thinking_budget
+                elif 'gemini-2' in model_lower:
+                    kwargs['thinking_budget'] = thinking.budget
+                    kwargs['include_thoughts'] = True
+                    logger.info(f"[AI] Gemini 2.x thinking: budget={thinking.budget}")
+                else:
+                    # For other/older Gemini models, thinking may not be supported
+                    logger.warning(f"[AI] Gemini model '{model}' may not support thinking mode")
+            elif provider == 'groq':
+                # Groq: reasoning_format ('parsed' or 'hidden')
+                # 'parsed' includes reasoning in additional_kwargs, 'hidden' suppresses it
+                format_val = thinking.format if thinking.format in ('parsed', 'hidden') else 'parsed'
+                kwargs['reasoning_format'] = format_val
+            elif provider == 'cerebras':
+                # Cerebras: No official LangChain thinking support yet
+                # Passing through as model_kwargs if supported
+                kwargs['thinking_budget'] = thinking.budget
+
+        return config.model_class(**kwargs)
+
+    async def fetch_models(self, provider: str, api_key: str) -> List[str]:
+        """Fetch available models from provider API."""
+        async with httpx.AsyncClient(timeout=self.settings.ai_timeout) as client:
+            if provider == 'openai':
+                response = await client.get(
+                    'https://api.openai.com/v1/models',
+                    headers={'Authorization': f'Bearer {api_key}'}
+                )
+                response.raise_for_status()
+                data = response.json()
+
+                # Filter for chat models including o-series reasoning models
+                models = []
+                for model in data.get('data', []):
+                    model_id = model['id'].lower()
+                    # Include GPT models and o-series reasoning models (o1, o3, o4)
+                    is_gpt = 'gpt' in model_id
+                    is_o_series = any(f'o{n}' in model_id for n in ['1', '3', '4'])
+                    is_excluded = 'instruct' in model_id or 'embedding' in model_id or 'realtime' in model_id
+                    if (is_gpt or is_o_series) and not is_excluded:
+                        models.append(model['id'])
+
+                # Sort by priority - o-series reasoning models at top
+                def get_priority(model_name: str) -> int:
+                    m = model_name.lower()
+                    # O-series reasoning models first
+                    if 'o4-mini' in m: return 1
+                    if 'o4' in m: return 2
+                    if 'o3-mini' in m: return 3
+                    if 'o3' in m: return 4
+                    if 'o1-mini' in m: return 5
+                    if 'o1' in m: return 6
+                    # Then GPT models
+                    if 'gpt-4o-mini' in m: return 10
+                    if 'gpt-4o' in m: return 11
+                    if 'gpt-4-turbo' in m: return 12
+                    if 'gpt-4' in m: return 13
+                    if 'gpt-3.5' in m: return 20
+                    return 99
+
+                return sorted(models, key=get_priority)
+
+            elif provider == 'anthropic':
+                response = await client.get(
+                    'https://api.anthropic.com/v1/models',
+                    headers={
+                        'x-api-key': api_key,
+                        'anthropic-version': '2023-06-01'
+                    }
+                )
+                response.raise_for_status()
+                data = response.json()
+                return [model['id'] for model in data.get('data', [])
+                       if model.get('type') == 'model']
+
+            elif provider == 'gemini':
+                response = await client.get(
+                    f'https://generativelanguage.googleapis.com/v1beta/models?key={api_key}'
+                )
+                response.raise_for_status()
+                data = response.json()
+
+                models = []
+                for model in data.get('models', []):
+                    name = model.get('name', '')
+                    if ('gemini' in name and
+                        'generateContent' in model.get('supportedGenerationMethods', [])):
+                        models.append(name.replace('models/', ''))
+
+                return sorted(models)
+
+            elif provider == 'openrouter':
+                response = await client.get(
+                    'https://openrouter.ai/api/v1/models',
+                    headers={'Authorization': f'Bearer {api_key}'}
+                )
+                response.raise_for_status()
+                data = response.json()
+
+                free_models = []
+                paid_models = []
+                for model in data.get('data', []):
+                    model_id = model.get('id', '')
+                    arch = model.get('architecture', {})
+                    modality = arch.get('modality', '')
+                    if 'text' in modality and model_id:
+                        pricing = model.get('pricing', {})
+                        prompt_price = float(pricing.get('prompt', '0') or '0')
+                        completion_price = float(pricing.get('completion', '0') or '0')
+                        is_free = prompt_price == 0 and completion_price == 0
+                        # Add [FREE] tag to free models
+                        display_name = f"[FREE] {model_id}" if is_free else model_id
+                        if is_free:
+                            free_models.append(display_name)
+                        else:
+                            paid_models.append(display_name)
+
+                # Return free models first, then paid models (both sorted)
+                return sorted(free_models) + sorted(paid_models)
+
+            elif provider == 'groq':
+                response = await client.get(
+                    'https://api.groq.com/openai/v1/models',
+                    headers={'Authorization': f'Bearer {api_key}'}
+                )
+                response.raise_for_status()
+                data = response.json()
+
+                models = []
+                for model in data.get('data', []):
+                    model_id = model.get('id', '')
+                    # Include all models from Groq API
+                    if model_id:
+                        models.append(model_id)
+
+                return sorted(models)
+
+            elif provider == 'cerebras':
+                response = await client.get(
+                    'https://api.cerebras.ai/v1/models',
+                    headers={'Authorization': f'Bearer {api_key}'}
+                )
+                response.raise_for_status()
+                data = response.json()
+
+                models = []
+                for model in data.get('data', []):
+                    model_id = model.get('id', '')
+                    # Include all models from Cerebras API
+                    if model_id:
+                        models.append(model_id)
+
+                return sorted(models)
+
+            else:
+                raise ValueError(f"Unsupported provider: {provider}")
+
+    async def execute_chat(self, node_id: str, node_type: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute AI chat model."""
+        start_time = time.time()
+
+        try:
+            # Flatten options collection from frontend
+            options = parameters.get('options', {})
+            flattened = {**parameters, **options}
+
+            # Extract parameters with camelCase/snake_case support for LangChain
+            api_key = flattened.get('api_key') or flattened.get('apiKey')
+            model = flattened.get('model', 'gpt-3.5-turbo')
+            # Strip [FREE] prefix if present (added by OpenRouter model list for display)
+            if model.startswith('[FREE] '):
+                model = model[7:]
+            prompt = flattened.get('prompt', 'Hello')
+
+            # System prompt/message - support multiple naming conventions
+            system_prompt = (flattened.get('system_prompt') or
+                           flattened.get('systemMessage') or
+                           flattened.get('systemPrompt') or '')
+
+            # Max tokens - support camelCase from frontend
+            max_tokens = int(flattened.get('max_tokens') or
+                           flattened.get('maxTokens') or 1000)
+
+            temperature = float(flattened.get('temperature', 0.7))
+
+            if not api_key:
+                raise ValueError("API key is required")
+
+            # Validate prompt is not empty (prevents wasted API calls for all providers)
+            if not is_valid_message_content(prompt):
+                raise ValueError("Prompt cannot be empty")
+
+            # Determine provider from node_type (more reliable than model name detection)
+            # OpenRouter models have format like "openai/gpt-4o" which would incorrectly detect as openai
+            if node_type == 'openrouterChatModel':
+                provider = 'openrouter'
+            elif node_type == 'groqChatModel':
+                provider = 'groq'
+            elif node_type == 'cerebrasChatModel':
+                provider = 'cerebras'
+            else:
+                provider = self.detect_provider(model)
+
+            # Build thinking config from parameters
+            thinking_config = None
+            if flattened.get('thinkingEnabled'):
+                thinking_config = ThinkingConfig(
+                    enabled=True,
+                    budget=int(flattened.get('thinkingBudget', 2048)),
+                    effort=flattened.get('reasoningEffort', 'medium'),
+                    level=flattened.get('thinkingLevel', 'medium'),
+                    format=flattened.get('reasoningFormat', 'parsed'),
+                )
+
+            chat_model = self.create_model(provider, api_key, model, temperature, max_tokens, thinking_config)
+
+            # Prepare messages
+            messages = []
+            if system_prompt and is_valid_message_content(system_prompt):
+                messages.append(SystemMessage(content=system_prompt))
+            messages.append(HumanMessage(content=prompt))
+
+            # Filter messages using standardized utility (handles all providers consistently)
+            filtered_messages = filter_empty_messages(messages)
+
+            # Execute
+            response = chat_model.invoke(filtered_messages)
+
+            # Debug: Log response structure for o-series reasoning models
+            if thinking_config and thinking_config.enabled:
+                logger.info(f"[AI Debug] Response type: {type(response).__name__}")
+                logger.info(f"[AI Debug] Response content type: {type(response.content)}")
+                logger.info(f"[AI Debug] Response content: {response.content[:500] if isinstance(response.content, str) else response.content}")
+                if hasattr(response, 'content_blocks'):
+                    logger.info(f"[AI Debug] content_blocks: {response.content_blocks}")
+                if hasattr(response, 'additional_kwargs'):
+                    logger.info(f"[AI Debug] additional_kwargs: {response.additional_kwargs}")
+                if hasattr(response, 'response_metadata'):
+                    logger.info(f"[AI Debug] response_metadata: {response.response_metadata}")
+
+            # Extract text and thinking content from response
+            text_content, thinking_content = extract_thinking_from_response(response)
+
+            # Debug: Log extraction results
+            logger.info(f"[AI Debug] Extracted text_content: {repr(text_content[:200] if text_content else None)}")
+            logger.info(f"[AI Debug] Extracted thinking_content: {repr(thinking_content[:200] if thinking_content else None)}")
+
+            # Use extracted text if available, fall back to raw content
+            response_text = text_content if text_content else response.content
+
+            logger.info(f"[AI Debug] Final response_text: {repr(response_text[:200] if response_text else None)}")
+
+            result = {
+                "response": response_text,
+                "thinking": thinking_content,
+                "thinking_enabled": thinking_config.enabled if thinking_config else False,
+                "model": model,
+                "provider": provider,
+                "finish_reason": "stop",
+                "timestamp": datetime.now().isoformat(),
+                "input": {
+                    "prompt": prompt,
+                    "system_prompt": system_prompt,
+                }
+            }
+
+            log_execution_time(logger, "ai_chat", start_time, time.time())
+            log_api_call(logger, provider, model, "chat", True)
+
+            final_result = {
+                "success": True,
+                "node_id": node_id,
+                "node_type": node_type,
+                "result": result,
+                "execution_time": time.time() - start_time
+            }
+            logger.info(f"[AI Debug] Returning final_result: success={final_result['success']}, result.response={repr(result.get('response', 'MISSING')[:100] if result.get('response') else 'None')}")
+            return final_result
+
+        except Exception as e:
+            logger.error("AI execution failed", node_id=node_id, error=str(e))
+            log_api_call(logger, provider if 'provider' in locals() else 'unknown',
+                        model if 'model' in locals() else 'unknown', "chat", False, error=str(e))
+
+            return {
+                "success": False,
+                "node_id": node_id,
+                "node_type": node_type,
+                "error": str(e),
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+    async def execute_agent(self, node_id: str, parameters: Dict[str, Any],
+                            memory_data: Optional[Dict[str, Any]] = None,
+                            tool_data: Optional[List[Dict[str, Any]]] = None,
+                            broadcaster = None,
+                            workflow_id: Optional[str] = None) -> Dict[str, Any]:
+        """Execute AI Agent using LangGraph state machine.
+
+        This method uses LangGraph for structured agent execution with:
+        - State management via TypedDict
+        - Tool calling via bind_tools and tool execution node
+        - Message accumulation via operator.add pattern
+        - Real-time status broadcasts for UI animations
+
+        Args:
+            node_id: The node identifier
+            parameters: Node parameters including prompt, model, etc.
+            memory_data: Optional memory data from connected simpleMemory node
+                        containing session_id, window_size for conversation history
+            tool_data: Optional list of tool configurations from connected tool nodes
+            broadcaster: Optional StatusBroadcaster for real-time UI updates
+            workflow_id: Optional workflow ID for scoped status broadcasts
+        """
+        start_time = time.time()
+        provider = 'unknown'
+        model = 'unknown'
+
+        # EARLY LOG: Entry point for debugging
+        logger.info(f"[AIAgent] execute_agent called: node_id={node_id}, workflow_id={workflow_id}, tool_data_count={len(tool_data) if tool_data else 0}")
+        if tool_data:
+            for i, td in enumerate(tool_data):
+                logger.info(f"[AIAgent] Tool {i}: type={td.get('node_type')}, node_id={td.get('node_id')}")
+
+        # Helper to broadcast status updates with workflow_id for proper scoping
+        async def broadcast_status(phase: str, details: Dict[str, Any] = None):
+            if broadcaster:
+                await broadcaster.update_node_status(node_id, "executing", {
+                    "phase": phase,
+                    "agent_type": "langgraph",
+                    **(details or {})
+                }, workflow_id=workflow_id)
+
+        try:
+            # Extract top-level parameters (always visible in UI)
+            prompt = parameters.get('prompt', 'Hello')
+            system_message = parameters.get('systemMessage', 'You are a helpful assistant')
+
+            # Flatten options collection from frontend
+            options = parameters.get('options', {})
+            flattened = {**parameters, **options}
+
+            # Extract parameters with camelCase/snake_case support
+            api_key = flattened.get('api_key') or flattened.get('apiKey')
+            provider = parameters.get('provider', 'openai')
+            model = parameters.get('model', '')
+            temperature = float(flattened.get('temperature', 0.7))
+            max_tokens = int(flattened.get('max_tokens') or flattened.get('maxTokens') or 1000)
+
+            logger.info(f"[LangGraph] Agent: {provider}/{model}, tools={len(tool_data) if tool_data else 0}")
+
+            # If no model specified or model doesn't match provider, use default from registry
+            if not model or not is_model_valid_for_provider(model, provider):
+                old_model = model
+                model = get_default_model(provider)
+                if old_model:
+                    logger.warning(f"Model '{old_model}' invalid for provider '{provider}', using default: {model}")
+                else:
+                    logger.info(f"No model specified, using default: {model}")
+
+            if not api_key:
+                raise ValueError("API key is required for AI Agent")
+
+            # Build thinking config from parameters
+            thinking_config = None
+            if flattened.get('thinkingEnabled'):
+                thinking_config = ThinkingConfig(
+                    enabled=True,
+                    budget=int(flattened.get('thinkingBudget', 2048)),
+                    effort=flattened.get('reasoningEffort', 'medium'),
+                    level=flattened.get('thinkingLevel', 'medium'),
+                    format=flattened.get('reasoningFormat', 'parsed'),
+                )
+                logger.info(f"[LangGraph] Thinking enabled: budget={thinking_config.budget}, effort={thinking_config.effort}")
+
+            # Broadcast: Initializing model
+            await broadcast_status("initializing", {
+                "message": f"Initializing {provider} model...",
+                "provider": provider,
+                "model": model
+            })
+
+            # Create LLM using the provider from node configuration
+            logger.debug(f"[LangGraph] Creating {provider} model: {model}")
+            chat_model = self.create_model(provider, api_key, model, temperature, max_tokens, thinking_config)
+
+            # Build initial messages for state
+            initial_messages: List[BaseMessage] = []
+            if system_message:
+                initial_messages.append(SystemMessage(content=system_message))
+
+            # Add memory history from connected simpleMemory node (markdown-based)
+            session_id = None
+            history_count = 0
+            if memory_data and memory_data.get('session_id'):
+                session_id = memory_data['session_id']
+                memory_content = memory_data.get('memory_content', '')
+
+                # Broadcast: Loading memory
+                await broadcast_status("loading_memory", {
+                    "message": f"Loading conversation history...",
+                    "session_id": session_id,
+                    "has_memory": True
+                })
+
+                # Parse short-term memory from markdown
+                history_messages = _parse_memory_markdown(memory_content)
+                history_count = len(history_messages)
+
+                # If long-term memory enabled, retrieve relevant context
+                if memory_data.get('long_term_enabled'):
+                    store = _get_memory_vector_store(session_id)
+                    if store:
+                        try:
+                            k = memory_data.get('retrieval_count', 3)
+                            docs = store.similarity_search(prompt, k=k)
+                            if docs:
+                                context = "\n---\n".join(d.page_content for d in docs)
+                                initial_messages.append(SystemMessage(content=f"Relevant past context:\n{context}"))
+                                logger.info(f"[LangGraph Memory] Retrieved {len(docs)} relevant memories from long-term store")
+                        except Exception as e:
+                            logger.debug(f"[LangGraph Memory] Long-term retrieval skipped: {e}")
+
+                # Add parsed history messages
+                initial_messages.extend(history_messages)
+
+                logger.info(f"[LangGraph Memory] Loaded {history_count} messages from markdown")
+
+                # Broadcast: Memory loaded
+                await broadcast_status("memory_loaded", {
+                    "message": f"Loaded {history_count} messages from memory",
+                    "session_id": session_id,
+                    "history_count": history_count
+                })
+
+            # Add current user prompt
+            initial_messages.append(HumanMessage(content=prompt))
+
+            # Build tools if provided
+            tools = []
+            tool_configs = {}
+
+            if tool_data:
+                await broadcast_status("building_tools", {
+                    "message": f"Building {len(tool_data)} tool(s)...",
+                    "tool_count": len(tool_data)
+                })
+
+                for tool_info in tool_data:
+                    tool, config = await self._build_tool_from_node(tool_info)
+                    if tool:
+                        tools.append(tool)
+                        tool_configs[tool.name] = config
+                        logger.info(f"[LangGraph] Registered tool: name={tool.name}, node_id={config.get('node_id')}")
+
+                logger.debug(f"[LangGraph] Built {len(tools)} tools")
+
+            # Create tool executor callback
+            async def tool_executor(tool_name: str, tool_args: Dict) -> Any:
+                """Execute a tool by name."""
+                from services.handlers.tools import execute_tool
+
+                config = tool_configs.get(tool_name, {})
+                tool_node_id = config.get('node_id')
+
+                logger.info(f"[LangGraph] tool_executor called: tool_name={tool_name}, node_id={tool_node_id}, workflow_id={workflow_id}")
+
+                # Broadcast executing status to the AI Agent node
+                await broadcast_status("executing_tool", {
+                    "message": f"Executing tool: {tool_name}",
+                    "tool_name": tool_name,
+                    "tool_args": tool_args
+                })
+
+                # Also broadcast executing status directly to the tool node so it glows
+                if tool_node_id and broadcaster:
+                    await broadcaster.update_node_status(
+                        tool_node_id,
+                        "executing",
+                        {"message": f"Executing {tool_name}"},
+                        workflow_id=workflow_id
+                    )
+
+                # Include workflow_id in config so tool handlers can broadcast with proper scoping
+                config['workflow_id'] = workflow_id
+
+                try:
+                    result = await execute_tool(tool_name, tool_args, config)
+
+                    # Broadcast completion to AI Agent node
+                    await broadcast_status("tool_completed", {
+                        "message": f"Tool completed: {tool_name}",
+                        "tool_name": tool_name,
+                        "result_preview": str(result)[:100]
+                    })
+
+                    # Broadcast success status to the tool node
+                    if tool_node_id and broadcaster:
+                        logger.info(f"[LangGraph] Broadcasting success to tool node: node_id={tool_node_id}, workflow_id={workflow_id}")
+                        await broadcaster.update_node_status(
+                            tool_node_id,
+                            "success",
+                            {"message": f"{tool_name} completed", "result": result},
+                            workflow_id=workflow_id
+                        )
+                    else:
+                        logger.warning(f"[LangGraph] Cannot broadcast success: tool_node_id={tool_node_id}, broadcaster={broadcaster is not None}")
+
+                    return result
+
+                except Exception as e:
+                    error_msg = str(e)
+                    logger.error(f"[LangGraph] Tool execution failed: {tool_name}", error=error_msg)
+
+                    # Broadcast error status to the tool node so UI shows failure
+                    if tool_node_id and broadcaster:
+                        await broadcaster.update_node_status(
+                            tool_node_id,
+                            "error",
+                            {"message": f"{tool_name} failed", "error": error_msg},
+                            workflow_id=workflow_id
+                        )
+
+                    # Re-raise to let LangGraph handle the error
+                    raise
+
+            # Broadcast: Building graph
+            await broadcast_status("building_graph", {
+                "message": "Building LangGraph agent...",
+                "message_count": len(initial_messages),
+                "has_memory": bool(session_id),
+                "history_count": history_count,
+                "tool_count": len(tools)
+            })
+
+            # Build and execute LangGraph agent
+            logger.debug(f"[LangGraph] Building agent graph with {len(initial_messages)} messages")
+            agent_graph = build_agent_graph(
+                chat_model,
+                tools=tools if tools else None,
+                tool_executor=tool_executor if tools else None
+            )
+
+            # Create initial state with thinking_content for reasoning models
+            initial_state: AgentState = {
+                "messages": initial_messages,
+                "tool_outputs": {},
+                "pending_tool_calls": [],
+                "iteration": 0,
+                "max_iterations": 10,
+                "should_continue": False,
+                "thinking_content": None
+            }
+
+            # Broadcast: Executing graph
+            await broadcast_status("invoking_llm", {
+                "message": f"Invoking {provider} LLM...",
+                "provider": provider,
+                "model": model,
+                "iteration": 1,
+                "has_memory": bool(session_id),
+                "history_count": history_count
+            })
+
+            # Execute the graph using ainvoke for proper async support
+            # This allows async tool nodes and WebSocket broadcasts to work correctly
+            final_state = await agent_graph.ainvoke(initial_state)
+
+            # Extract the AI response (last message in the accumulated messages)
+            all_messages = final_state["messages"]
+            ai_response = all_messages[-1] if all_messages else None
+
+            if not ai_response or not hasattr(ai_response, 'content'):
+                raise ValueError("No response generated from agent")
+
+            # Handle different content formats (Gemini can return list of content blocks)
+            raw_content = ai_response.content
+            response_content = self._extract_text_content(raw_content, ai_response)
+            iterations = final_state.get("iteration", 1)
+
+            # Get accumulated thinking content from state
+            thinking_content = final_state.get("thinking_content")
+
+            logger.info(f"[LangGraph] Agent completed in {iterations} iteration(s), thinking={'yes' if thinking_content else 'no'}")
+
+            # Save to memory if connected (markdown-based with optional vector DB)
+            # Only save non-empty messages using standardized validation
+            if memory_data and memory_data.get('node_id') and is_valid_message_content(prompt) and is_valid_message_content(response_content):
+                # Broadcast: Saving to memory
+                await broadcast_status("saving_memory", {
+                    "message": "Saving to conversation memory...",
+                    "session_id": session_id,
+                    "has_memory": True,
+                    "history_count": history_count
+                })
+
+                # Update markdown content
+                updated_content = memory_data.get('memory_content', '# Conversation History\n\n*No messages yet.*\n')
+                updated_content = _append_to_memory_markdown(updated_content, 'human', prompt)
+                updated_content = _append_to_memory_markdown(updated_content, 'ai', response_content)
+
+                # Trim to window size, archive removed to vector DB
+                window_size = memory_data.get('window_size', 10)
+                updated_content, removed_texts = _trim_markdown_window(updated_content, window_size)
+
+                # Store removed messages in long-term vector DB
+                if removed_texts and memory_data.get('long_term_enabled'):
+                    store = _get_memory_vector_store(session_id)
+                    if store:
+                        try:
+                            store.add_texts(removed_texts)
+                            logger.info(f"[LangGraph Memory] Archived {len(removed_texts)} messages to long-term store")
+                        except Exception as e:
+                            logger.warning(f"[LangGraph Memory] Failed to archive to vector store: {e}")
+
+                # Save updated markdown to node parameters
+                memory_node_id = memory_data['node_id']
+                current_params = await self.database.get_node_parameters(memory_node_id) or {}
+                current_params['memoryContent'] = updated_content
+                await self.database.save_node_parameters(memory_node_id, current_params)
+                logger.info(f"[LangGraph Memory] Saved markdown to memory node '{memory_node_id}'")
+
+            result = {
+                "response": response_content,
+                "thinking": thinking_content,
+                "thinking_enabled": thinking_config.enabled if thinking_config else False,
+                "model": model,
+                "provider": provider,
+                "agent_type": "langgraph",
+                "iterations": iterations,
+                "finish_reason": "stop",
+                "timestamp": datetime.now().isoformat(),
+                "input": {
+                    "prompt": prompt,
+                    "system_message": system_message,
+                }
+            }
+
+            # Add memory info if used
+            if session_id:
+                result["memory"] = {
+                    "session_id": session_id,
+                    "history_loaded": history_count
+                }
+
+            log_execution_time(logger, "ai_agent_langgraph", start_time, time.time())
+            log_api_call(logger, provider, model, "agent", True)
+
+            return {
+                "success": True,
+                "node_id": node_id,
+                "node_type": "aiAgent",
+                "result": result,
+                "execution_time": time.time() - start_time
+            }
+
+        except Exception as e:
+            logger.error("[LangGraph] AI agent execution failed", node_id=node_id, error=str(e))
+            log_api_call(logger, provider, model, "agent", False, error=str(e))
+
+            return {
+                "success": False,
+                "node_id": node_id,
+                "node_type": "aiAgent",
+                "error": str(e),
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+    async def execute_chat_agent(self, node_id: str, parameters: Dict[str, Any],
+                                  memory_data: Optional[Dict[str, Any]] = None,
+                                  skill_data: Optional[List[Dict[str, Any]]] = None,
+                                  tool_data: Optional[List[Dict[str, Any]]] = None,
+                                  broadcaster=None,
+                                  workflow_id: Optional[str] = None) -> Dict[str, Any]:
+        """Execute Chat Agent - conversational AI with memory, skills, and tool calling.
+
+        Chat Agent supports:
+        - Memory (input-memory): Markdown-based conversation history (same as AI Agent)
+        - 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 identifier
+            parameters: Node parameters including prompt, model, etc.
+            memory_data: Optional memory data from connected SimpleMemory node (markdown-based)
+            skill_data: Optional skill configurations from connected skill nodes
+            tool_data: Optional tool configurations from connected tool nodes (httpRequest, etc.)
+            broadcaster: Optional StatusBroadcaster for real-time UI updates
+            workflow_id: Optional workflow ID for scoped status broadcasts
+        """
+        start_time = time.time()
+        provider = 'unknown'
+        model = 'unknown'
+
+        logger.info(f"[ChatAgent] execute_chat_agent called: node_id={node_id}, workflow_id={workflow_id}, skill_count={len(skill_data) if skill_data else 0}, tool_count={len(tool_data) if tool_data else 0}")
+
+        async def broadcast_status(phase: str, details: Dict[str, Any] = None):
+            if broadcaster:
+                await broadcaster.update_node_status(node_id, "executing", {
+                    "phase": phase,
+                    "agent_type": "chat_with_skills" if skill_data else "chat",
+                    **(details or {})
+                }, workflow_id=workflow_id)
+
+        try:
+            # Extract parameters
+            prompt = parameters.get('prompt', 'Hello')
+            system_message = parameters.get('systemMessage', 'You are a helpful assistant')
+
+            # Load skills and enhance system message with SKILL.md context
+            # Skills only provide instructions/context - actual tools come from direct tool nodes
+            if skill_data:
+                from services.skill_loader import get_skill_loader
+
+                skill_loader = get_skill_loader()
+                skill_loader.scan_skills()
+
+                # Extract skill names from connected skill nodes
+                skill_names = []
+                for skill_info in skill_data:
+                    skill_name = skill_info.get('skill_name') or skill_info.get('node_type', '').replace('Skill', '-skill').lower()
+                    # Convert node type to skill name (e.g., 'whatsappSkill' -> 'whatsapp-skill')
+                    if skill_name.endswith('skill') and not '-' in skill_name:
+                        skill_name = skill_name[:-5] + '-skill'  # whatsappskill -> whatsapp-skill
+                    skill_names.append(skill_name)
+                    logger.debug(f"[ChatAgent] Skill detected: {skill_name}")
+
+                # Add skill SKILL.md content to system message
+                skill_prompt = skill_loader.get_registry_prompt(skill_names)
+                if skill_prompt:
+                    system_message = f"{system_message}\n\n{skill_prompt}"
+                    logger.info(f"[ChatAgent] Enhanced system message with {len(skill_names)} skill contexts")
+
+            # Build tools from tool_data using same method as AI Agent
+            # This supports ALL tool types: calculatorTool, currentTimeTool, webSearchTool, androidTool, httpRequest
+            all_tools = []
+            tool_node_configs = {}  # Map tool name to node config (same as AI Agent's tool_configs)
+            if tool_data:
+                await broadcast_status("building_tools", {
+                    "message": f"Building {len(tool_data)} tool(s)...",
+                    "tool_count": len(tool_data)
+                })
+
+                for tool_info in tool_data:
+                    # Use AI Agent's _build_tool_from_node for all tool types
+                    tool, config = await self._build_tool_from_node(tool_info)
+                    if tool:
+                        all_tools.append(tool)
+                        tool_node_configs[tool.name] = config
+                        logger.info(f"[ChatAgent] Built tool: {tool.name} (type={config.get('node_type')}, node_id={config.get('node_id')})")
+
+                logger.info(f"[ChatAgent] Built {len(all_tools)} tools from tool_data")
+
+            logger.info(f"[ChatAgent] Total tools available: {len(all_tools)}")
+
+            # Flatten options collection from frontend
+            options = parameters.get('options', {})
+            flattened = {**parameters, **options}
+
+            api_key = flattened.get('api_key') or flattened.get('apiKey')
+            provider = parameters.get('provider', 'openai')
+            model = parameters.get('model', '')
+            temperature = float(flattened.get('temperature', 0.7))
+            max_tokens = int(flattened.get('max_tokens') or flattened.get('maxTokens') or 1000)
+
+            logger.info(f"[ChatAgent] Provider: {provider}, Model: {model}")
+
+            # Validate model for provider
+            if not model or not is_model_valid_for_provider(model, provider):
+                old_model = model
+                model = get_default_model(provider)
+                if old_model:
+                    logger.warning(f"Model '{old_model}' invalid for provider '{provider}', using default: {model}")
+                else:
+                    logger.info(f"No model specified, using default: {model}")
+
+            if not api_key:
+                raise ValueError("API key is required for Chat Agent")
+
+            # Build thinking config from parameters
+            thinking_config = None
+            if flattened.get('thinkingEnabled'):
+                thinking_config = ThinkingConfig(
+                    enabled=True,
+                    budget=int(flattened.get('thinkingBudget', 2048)),
+                    effort=flattened.get('reasoningEffort', 'medium'),
+                    level=flattened.get('thinkingLevel', 'medium'),
+                    format=flattened.get('reasoningFormat', 'parsed'),
+                )
+
+            # Broadcast: Initializing
+            await broadcast_status("initializing", {
+                "message": f"Initializing {provider} model...",
+                "provider": provider,
+                "model": model
+            })
+
+            # Create chat model
+            chat_model = self.create_model(provider, api_key, model, temperature, max_tokens, thinking_config)
+
+            # Build messages
+            messages: List[BaseMessage] = []
+            if system_message:
+                messages.append(SystemMessage(content=system_message))
+
+            # Load memory history if connected (markdown-based like AI Agent)
+            session_id = None
+            history_count = 0
+            memory_content = None
+            if memory_data and memory_data.get('node_id'):
+                session_id = memory_data.get('session_id', 'default')
+                memory_content = memory_data.get('memory_content', '# Conversation History\n\n*No messages yet.*\n')
+
+                await broadcast_status("loading_memory", {
+                    "message": "Loading conversation history...",
+                    "session_id": session_id,
+                    "has_memory": True
+                })
+
+                # Parse short-term memory from markdown
+                history_messages = _parse_memory_markdown(memory_content)
+                history_count = len(history_messages)
+
+                # If long-term memory enabled, retrieve relevant context
+                if memory_data.get('long_term_enabled'):
+                    store = _get_memory_vector_store(session_id)
+                    if store:
+                        try:
+                            k = memory_data.get('retrieval_count', 3)
+                            docs = store.similarity_search(prompt, k=k)
+                            if docs:
+                                context = "\n---\n".join(d.page_content for d in docs)
+                                messages.append(SystemMessage(content=f"Relevant past context:\n{context}"))
+                                logger.info(f"[ChatAgent Memory] Retrieved {len(docs)} relevant memories from long-term store")
+                        except Exception as e:
+                            logger.debug(f"[ChatAgent Memory] Long-term retrieval skipped: {e}")
+
+                # Add parsed history messages
+                messages.extend(history_messages)
+
+                logger.info(f"[ChatAgent Memory] Loaded {history_count} messages from markdown")
+
+                await broadcast_status("memory_loaded", {
+                    "message": f"Loaded {history_count} messages from memory",
+                    "session_id": session_id,
+                    "history_count": history_count
+                })
+
+            # Add current prompt
+            messages.append(HumanMessage(content=prompt))
+
+            # Broadcast: Invoking LLM
+            await broadcast_status("invoking_llm", {
+                "message": "Generating response...",
+                "has_memory": session_id is not None,
+                "history_count": history_count,
+                "skill_count": len(skill_data) if skill_data else 0
+            })
+
+            # Execute with or without tools
+            thinking_content = None
+            iterations = 1
+
+            if all_tools:
+                # Use LangGraph for tool execution (like AI Agent)
+                logger.info(f"[ChatAgent] Using LangGraph with {len(all_tools)} tools")
+
+                # Create tool executor callback - same pattern as AI Agent
+                # Uses handlers/tools.py execute_tool() for actual execution
+                async def chat_tool_executor(tool_name: str, tool_args: Dict) -> Any:
+                    """Execute a tool by name using handlers/tools.py (same as AI Agent)."""
+                    from services.handlers.tools import execute_tool
+
+                    logger.info(f"[ChatAgent] Executing tool: {tool_name}, args={tool_args}")
+
+                    # Get tool node config (contains node_id, node_type, parameters)
+                    config = tool_node_configs.get(tool_name, {})
+                    tool_node_id = config.get('node_id')
+
+                    # Broadcast executing status to tool node for glow effect
+                    if tool_node_id and broadcaster:
+                        await broadcaster.update_node_status(
+                            tool_node_id,
+                            "executing",
+                            {"message": f"Executing {tool_name}"},
+                            workflow_id=workflow_id
+                        )
+
+                    try:
+                        # Execute via handlers/tools.py - same pattern as AI Agent
+                        result = await execute_tool(tool_name, tool_args, config)
+                        logger.info(f"[ChatAgent] Tool executed successfully: {tool_name}")
+
+                        # Broadcast success to tool node
+                        if tool_node_id and broadcaster:
+                            await broadcaster.update_node_status(
+                                tool_node_id,
+                                "success",
+                                {"message": f"{tool_name} completed", "result": result},
+                                workflow_id=workflow_id
+                            )
+                        return result
+
+                    except Exception as e:
+                        logger.error(f"[ChatAgent] Tool execution failed: {tool_name}", error=str(e))
+                        # Broadcast error to tool node
+                        if tool_node_id and broadcaster:
+                            await broadcaster.update_node_status(
+                                tool_node_id,
+                                "error",
+                                {"message": f"{tool_name} failed", "error": str(e)},
+                                workflow_id=workflow_id
+                            )
+                        return {"error": str(e)}
+
+                # Build LangGraph agent with all tools
+                agent_graph = build_agent_graph(
+                    chat_model,
+                    tools=all_tools,
+                    tool_executor=chat_tool_executor
+                )
+
+                # Create initial state
+                initial_state: AgentState = {
+                    "messages": messages,
+                    "tool_outputs": {},
+                    "pending_tool_calls": [],
+                    "iteration": 0,
+                    "max_iterations": 10,
+                    "should_continue": False,
+                    "thinking_content": None
+                }
+
+                # Execute the graph
+                final_state = await agent_graph.ainvoke(initial_state)
+
+                # Extract response
+                all_messages = final_state["messages"]
+                ai_response = all_messages[-1] if all_messages else None
+
+                if not ai_response or not hasattr(ai_response, 'content'):
+                    raise ValueError("No response generated from agent")
+
+                raw_content = ai_response.content
+                response_content = self._extract_text_content(raw_content, ai_response)
+                iterations = final_state.get("iteration", 1)
+                thinking_content = final_state.get("thinking_content")
+            else:
+                # Simple invoke without tools
+                response = await chat_model.ainvoke(messages)
+
+                # Extract response content
+                raw_content = response.content
+                response_content = self._extract_text_content(raw_content, response)
+
+                # Extract thinking content if available
+                _, thinking_content = extract_thinking_from_response(response)
+
+            logger.info(f"[ChatAgent] Response generated, thinking={'yes' if thinking_content else 'no'}, iterations={iterations}")
+
+            # Save to memory if connected (markdown-based like AI Agent)
+            if memory_data and memory_data.get('node_id') and is_valid_message_content(prompt) and is_valid_message_content(response_content):
+                await broadcast_status("saving_memory", {
+                    "message": "Saving to conversation memory...",
+                    "session_id": session_id,
+                    "has_memory": True
+                })
+
+                # Update markdown content
+                updated_content = memory_content or '# Conversation History\n\n*No messages yet.*\n'
+                updated_content = _append_to_memory_markdown(updated_content, 'human', prompt)
+                updated_content = _append_to_memory_markdown(updated_content, 'ai', response_content)
+
+                # Trim to window size, archive removed to vector DB
+                window_size = memory_data.get('window_size', 10)
+                updated_content, removed_texts = _trim_markdown_window(updated_content, window_size)
+
+                # Store removed messages in long-term vector DB
+                if removed_texts and memory_data.get('long_term_enabled'):
+                    store = _get_memory_vector_store(session_id)
+                    if store:
+                        try:
+                            store.add_texts(removed_texts)
+                            logger.info(f"[ChatAgent Memory] Archived {len(removed_texts)} messages to long-term store")
+                        except Exception as e:
+                            logger.warning(f"[ChatAgent Memory] Failed to archive to vector store: {e}")
+
+                # Save updated markdown to node parameters
+                memory_node_id = memory_data['node_id']
+                current_params = await self.database.get_node_parameters(memory_node_id) or {}
+                current_params['memoryContent'] = updated_content
+                await self.database.save_node_parameters(memory_node_id, current_params)
+                logger.info(f"[ChatAgent Memory] Saved markdown to memory node '{memory_node_id}'")
+
+            # Determine agent type based on configuration
+            agent_type = "chat"
+            if skill_data and all_tools:
+                agent_type = "chat_with_skills_and_tools"
+            elif skill_data:
+                agent_type = "chat_with_skills"
+            elif all_tools:
+                agent_type = "chat_with_tools"
+
+            result = {
+                "response": response_content,
+                "thinking": thinking_content,
+                "thinking_enabled": thinking_config.enabled if thinking_config else False,
+                "model": model,
+                "provider": provider,
+                "agent_type": agent_type,
+                "iterations": iterations,
+                "finish_reason": "stop",
+                "timestamp": datetime.now().isoformat(),
+                "input": {
+                    "prompt": prompt,
+                    "system_message": system_message,
+                }
+            }
+
+            if session_id:
+                result["memory"] = {
+                    "session_id": session_id,
+                    "history_loaded": history_count
+                }
+
+            if skill_data:
+                result["skills"] = {
+                    "connected": [s.get('skill_name', s.get('node_type', '')) for s in skill_data],
+                    "count": len(skill_data)
+                }
+
+            if all_tools:
+                result["tools"] = {
+                    "connected": [t.name for t in all_tools],
+                    "count": len(all_tools)
+                }
+
+            log_execution_time(logger, "chat_agent", start_time, time.time())
+            log_api_call(logger, provider, model, "chat_agent", True)
+
+            # Save assistant response to chat messages database for console panel persistence
+            try:
+                await self.database.add_chat_message("default", "assistant", response_content)
+            except Exception as e:
+                logger.warning(f"[ChatAgent] Failed to save chat response to database: {e}")
+
+            return {
+                "success": True,
+                "node_id": node_id,
+                "node_type": "chatAgent",
+                "result": result,
+                "execution_time": time.time() - start_time
+            }
+
+        except Exception as e:
+            logger.error("[ChatAgent] Execution failed", node_id=node_id, error=str(e))
+            log_api_call(logger, provider, model, "chat_agent", False, error=str(e))
+
+            return {
+                "success": False,
+                "node_id": node_id,
+                "node_type": "chatAgent",
+                "error": str(e),
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+    async def _build_tool_from_node(self, tool_info: Dict[str, Any]) -> tuple:
+        """Convert a node configuration into a LangChain StructuredTool.
+
+        Uses database-stored schema as source of truth if available, otherwise
+        falls back to dynamic schema generation.
+
+        Args:
+            tool_info: Dict containing node_id, node_type, parameters, label, connected_services (for androidTool)
+
+        Returns:
+            Tuple of (StructuredTool, config_dict) or (None, None) on failure
+        """
+        # Default tool names matching frontend toolNodes.ts definitions
+        DEFAULT_TOOL_NAMES = {
+            'calculatorTool': 'calculator',
+            'currentTimeTool': 'get_current_time',
+            'webSearchTool': 'web_search',
+            'androidTool': 'android_device',
+            'whatsappSend': 'whatsapp_send',
+            'whatsappDb': 'whatsapp_db',
+            'addLocations': 'geocode',
+            'showNearbyPlaces': 'nearby_places',
+        }
+        DEFAULT_TOOL_DESCRIPTIONS = {
+            'calculatorTool': 'Perform mathematical calculations. Operations: add, subtract, multiply, divide, power, sqrt, mod, abs',
+            'currentTimeTool': 'Get the current date and time. Optionally specify timezone.',
+            'webSearchTool': 'Search the web for information. Returns relevant search results.',
+            'androidTool': 'Control Android device. Available services are determined by connected nodes.',
+            'whatsappSend': 'Send WhatsApp messages to contacts or groups. Supports text, media, location, and contact messages.',
+            'whatsappDb': 'Query WhatsApp database - list contacts, search groups, get contact/group info, retrieve chat history.',
+            'addLocations': 'Geocode addresses to coordinates or reverse geocode coordinates to addresses using Google Maps.',
+            'showNearbyPlaces': 'Search for nearby places (restaurants, hospitals, banks, etc.) using Google Maps Places API.',
+        }
+
+        try:
+            node_type = tool_info.get('node_type', '')
+            node_params = tool_info.get('parameters', {})
+            node_label = tool_info.get('label', node_type)
+            node_id = tool_info.get('node_id', '')
+            connected_services = tool_info.get('connected_services', [])
+
+            # Check database for stored schema (source of truth)
+            db_schema = await self.database.get_tool_schema(node_id) if node_id else None
+
+            if db_schema:
+                # Use database schema as source of truth
+                logger.debug(f"[LangGraph] Using DB schema for tool node {node_id}")
+                tool_name = db_schema.get('tool_name', DEFAULT_TOOL_NAMES.get(node_type, f"tool_{node_label}"))
+                tool_description = db_schema.get('tool_description', DEFAULT_TOOL_DESCRIPTIONS.get(node_type, f"Execute {node_label}"))
+                # Use stored connected_services if available (for toolkit nodes)
+                if db_schema.get('connected_services'):
+                    connected_services = db_schema['connected_services']
+            else:
+                # Fall back to dynamic generation from node params
+                tool_name = (
+                    node_params.get('toolName') or
+                    DEFAULT_TOOL_NAMES.get(node_type) or
+                    f"tool_{node_label}".replace(' ', '_').replace('-', '_').lower()
+                )
+                tool_description = (
+                    node_params.get('toolDescription') or
+                    DEFAULT_TOOL_DESCRIPTIONS.get(node_type) or
+                    f"Execute {node_label} node"
+                )
+
+            # For androidTool, enhance description with connected services
+            if node_type == 'androidTool' and connected_services:
+                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)}"
+
+            # Clean tool name (LangChain requires alphanumeric + underscores)
+            import re
+            tool_name = re.sub(r'[^a-zA-Z0-9_]', '_', tool_name)
+
+            # Build schema based on node type - pass connected_services for androidTool
+            # If DB has schema_config, use it to build custom schema, otherwise use dynamic
+            schema_params = dict(node_params)
+            if connected_services:
+                schema_params['connected_services'] = connected_services
+            if db_schema and db_schema.get('schema_config'):
+                schema_params['db_schema_config'] = db_schema['schema_config']
+            schema = self._get_tool_schema(node_type, schema_params)
+
+            # Create StructuredTool - the func is a placeholder, actual execution via tool_executor
+            def placeholder_func(**kwargs):
+                return kwargs
+
+            tool = StructuredTool.from_function(
+                name=tool_name,
+                description=tool_description,
+                func=placeholder_func,
+                args_schema=schema
+            )
+
+            # Build config dict - include connected_services for toolkit nodes
+            config = {
+                'node_type': node_type,
+                'node_id': node_id,
+                'parameters': node_params,
+                'label': node_label,
+                'connected_services': connected_services  # Pass through for execution
+            }
+
+            logger.debug(f"[LangGraph] Built tool '{tool_name}' with node_id={node_id}")
+            return tool, config
+
+        except Exception as e:
+            logger.error(f"[LangGraph] Failed to build tool from node: {e}")
+            return None, None
+
+    def _get_tool_schema(self, node_type: str, params: Dict[str, Any]) -> Type[BaseModel]:
+        """Get Pydantic schema for tool based on node type.
+
+        Uses db_schema_config from database if available (source of truth),
+        otherwise falls back to built-in schema definitions.
+
+        Args:
+            node_type: The node type (e.g., 'calculatorTool', 'httpRequest')
+            params: Node parameters, may include db_schema_config from database
+
+        Returns:
+            Pydantic BaseModel class for the tool's arguments
+        """
+        # Check if we have a database-stored schema config (source of truth)
+        db_schema_config = params.get('db_schema_config')
+        if db_schema_config:
+            return self._build_schema_from_config(db_schema_config)
+
+        # Calculator tool schema
+        if node_type == 'calculatorTool':
+            class CalculatorSchema(BaseModel):
+                """Schema for calculator tool arguments."""
+                operation: str = Field(
+                    description="Math operation: add, subtract, multiply, divide, power, sqrt, mod, abs"
+                )
+                a: float = Field(description="First number")
+                b: float = Field(default=0, description="Second number (not needed for sqrt, abs)")
+
+            return CalculatorSchema
+
+        # HTTP Request tool schema
+        if node_type in ('httpRequest', 'httpRequestTool'):
+            class HttpRequestSchema(BaseModel):
+                """Schema for HTTP request tool arguments."""
+                url: str = Field(description="URL path or full URL to request")
+                method: str = Field(default="GET", description="HTTP method: GET, POST, PUT, DELETE")
+                body: Optional[Dict[str, Any]] = Field(default=None, description="Request body as JSON object")
+
+            return HttpRequestSchema
+
+        # Python executor tool schema
+        if node_type == 'pythonExecutor':
+            class PythonCodeSchema(BaseModel):
+                """Schema for Python code execution."""
+                code: str = Field(description="Python code to execute")
+
+            return PythonCodeSchema
+
+        # Current time tool schema
+        if node_type == 'currentTimeTool':
+            class CurrentTimeSchema(BaseModel):
+                """Schema for current time tool arguments."""
+                timezone: str = Field(
+                    default="UTC",
+                    description="Timezone (e.g., UTC, America/New_York, Europe/London)"
+                )
+
+            return CurrentTimeSchema
+
+        # Web search tool schema
+        if node_type == 'webSearchTool':
+            class WebSearchSchema(BaseModel):
+                """Schema for web search tool arguments."""
+                query: str = Field(description="Search query to look up on the web")
+
+            return WebSearchSchema
+
+        # WhatsApp send schema (existing node used as tool)
+        if node_type == 'whatsappSend':
+            class WhatsAppSendSchema(BaseModel):
+                """Send WhatsApp messages to contacts or groups."""
+                recipient_type: str = Field(
+                    default="phone",
+                    description="Send to: 'phone' for individual or 'group' for group chat"
+                )
+                phone: Optional[str] = Field(
+                    default=None,
+                    description="Phone number without + prefix (e.g., 1234567890). Required for recipient_type='phone'"
+                )
+                group_id: Optional[str] = Field(
+                    default=None,
+                    description="Group JID (e.g., 123456789@g.us). Required for recipient_type='group'"
+                )
+                message_type: str = Field(
+                    default="text",
+                    description="Message type: 'text', 'image', 'video', 'audio', 'document', 'sticker', 'location', 'contact'"
+                )
+                message: Optional[str] = Field(
+                    default=None,
+                    description="Text message content. Required for message_type='text'"
+                )
+                media_url: Optional[str] = Field(
+                    default=None,
+                    description="URL for media (image/video/audio/document/sticker)"
+                )
+                caption: Optional[str] = Field(
+                    default=None,
+                    description="Caption for media messages (image, video, document)"
+                )
+                latitude: Optional[float] = Field(default=None, description="Latitude for location message")
+                longitude: Optional[float] = Field(default=None, description="Longitude for location message")
+                location_name: Optional[str] = Field(default=None, description="Display name for location")
+                address: Optional[str] = Field(default=None, description="Address text for location")
+                contact_name: Optional[str] = Field(default=None, description="Contact card display name")
+                vcard: Optional[str] = Field(default=None, description="vCard 3.0 format string for contact")
+
+            return WhatsAppSendSchema
+
+        # WhatsApp DB schema (existing node used as tool) - query contacts, groups, messages
+        if node_type == 'whatsappDb':
+            class WhatsAppDbSchema(BaseModel):
+                """Query WhatsApp database - contacts, groups, messages.
+
+                Operations:
+                - chat_history: Get messages from a chat (requires phone or group_id)
+                - search_groups: Search groups by name (optional query)
+                - get_group_info: Get group details with participant names (requires group_id)
+                - get_contact_info: Get full contact info for sending/replying (requires phone)
+                - list_contacts: List contacts with saved names (optional query filter)
+                - check_contacts: Check WhatsApp registration (requires phones comma-separated)
+                """
+                operation: str = Field(
+                    default="chat_history",
+                    description="Operation: 'chat_history', 'search_groups', 'get_group_info', 'get_contact_info', 'list_contacts', 'check_contacts'"
+                )
+                # For chat_history
+                chat_type: Optional[str] = Field(
+                    default=None,
+                    description="For chat_history: 'individual' or 'group'"
+                )
+                phone: Optional[str] = Field(
+                    default=None,
+                    description="Phone number without + prefix. For chat_history (individual), get_contact_info"
+                )
+                group_id: Optional[str] = Field(
+                    default=None,
+                    description="Group JID. For chat_history (group), get_group_info"
+                )
+                message_filter: Optional[str] = Field(
+                    default=None,
+                    description="For chat_history: 'all' or 'text_only'"
+                )
+                group_filter: Optional[str] = Field(
+                    default=None,
+                    description="For chat_history (group): 'all' or 'contact' to filter by sender"
+                )
+                sender_phone: Optional[str] = Field(
+                    default=None,
+                    description="For chat_history (group with group_filter='contact'): filter messages from this phone"
+                )
+                limit: Optional[int] = Field(
+                    default=None,
+                    description="Max results to return. chat_history: 1-500 (default 50), search_groups: 1-50 (default 20), list_contacts: 1-100 (default 50). Use smaller limits to avoid context overflow."
+                )
+                offset: Optional[int] = Field(default=None, description="For chat_history: pagination offset")
+                # For search_groups, list_contacts
+                query: Optional[str] = Field(
+                    default=None,
+                    description="Search query for search_groups or list_contacts. Use specific queries to narrow results."
+                )
+                # For check_contacts
+                phones: Optional[str] = Field(
+                    default=None,
+                    description="For check_contacts: comma-separated phone numbers"
+                )
+                # For get_group_info
+                participant_limit: Optional[int] = Field(
+                    default=None,
+                    description="For get_group_info: max participants to return (1-100, default 50). Large groups may have hundreds of members."
+                )
+
+            return WhatsAppDbSchema
+
+        # Android toolkit schema - dynamic based on connected services
+        # Follows LangChain dynamic tool binding pattern
+        if node_type == 'androidTool':
+            connected_services = params.get('connected_services', [])
+
+            if not connected_services:
+                # No services connected - minimal schema with helpful error
+                class EmptyAndroidSchema(BaseModel):
+                    """Android toolkit with no connected services."""
+                    query: str = Field(
+                        default="status",
+                        description="No Android services connected. Connect Android nodes to the toolkit."
+                    )
+                return EmptyAndroidSchema
+
+            # Build dynamic service list for schema description
+            from services.android_service import SERVICE_ACTIONS
+
+            service_info = []
+            for svc in connected_services:
+                svc_id = svc.get('service_id') or svc.get('node_type', 'unknown')
+                actions = SERVICE_ACTIONS.get(svc_id, [])
+                action_list = [a['value'] for a in actions] if actions else ['status']
+                service_info.append(f"{svc_id}: {'/'.join(action_list)}")
+
+            services_description = "; ".join(service_info)
+
+            class AndroidToolSchema(BaseModel):
+                """Schema for Android device control via connected services."""
+                service_id: str = Field(
+                    description=f"Service to use. Connected: {services_description}"
+                )
+                action: str = Field(
+                    description="Action to perform (see service list for available actions)"
+                )
+                parameters: Optional[Dict[str, Any]] = Field(
+                    default=None,
+                    description="Action parameters. Examples: {package_name: 'com.app'} for app_launcher, {volume: 50} for audio"
+                )
+
+            return AndroidToolSchema
+
+        # Google Maps Geocoding schema (addLocations node as tool)
+        # camelCase to match JSON/frontend convention
+        if node_type == 'addLocations':
+            class GeocodingSchema(BaseModel):
+                """Geocode addresses to coordinates or reverse geocode coordinates to addresses."""
+                service_type: str = Field(
+                    default="geocode",
+                    description="Operation: 'geocode' (address to coordinates) or 'reverse_geocode' (coordinates to address)"
+                )
+                address: Optional[str] = Field(
+                    default=None,
+                    description="Address to geocode (e.g., '1600 Amphitheatre Parkway, Mountain View, CA'). Required for service_type='geocode'"
+                )
+                lat: Optional[float] = Field(
+                    default=None,
+                    description="Latitude for reverse geocoding. Required for service_type='reverse_geocode'"
+                )
+                lng: Optional[float] = Field(
+                    default=None,
+                    description="Longitude for reverse geocoding. Required for service_type='reverse_geocode'"
+                )
+
+            return GeocodingSchema
+
+        # Google Maps Nearby Places schema (showNearbyPlaces node as tool)
+        # snake_case to match Python convention
+        if node_type == 'showNearbyPlaces':
+            class NearbyPlacesSchema(BaseModel):
+                """Search for nearby places using Google Maps Places API."""
+                lat: float = Field(
+                    description="Center latitude for search (e.g., 40.7484)"
+                )
+                lng: float = Field(
+                    description="Center longitude for search (e.g., -73.9857)"
+                )
+                radius: int = Field(
+                    default=500,
+                    description="Search radius in meters (max 50000)"
+                )
+                type: str = Field(
+                    default="restaurant",
+                    description="Place type: restaurant, cafe, bar, hospital, pharmacy, bank, atm, gas_station, supermarket, park, gym, etc."
+                )
+                keyword: Optional[str] = Field(
+                    default=None,
+                    description="Optional keyword to filter results (e.g., 'pizza', 'italian', '24 hour')"
+                )
+
+            return NearbyPlacesSchema
+
+        # Generic schema for other nodes
+        class GenericToolSchema(BaseModel):
+            """Generic schema for tool arguments."""
+            input: str = Field(description="Input data for the tool")
+
+        return GenericToolSchema
+
+    def _build_schema_from_config(self, schema_config: Dict[str, Any]) -> Type[BaseModel]:
+        """Build a Pydantic schema from database-stored configuration.
+
+        Schema config format:
+        {
+            "description": "Schema description",
+            "fields": {
+                "field_name": {
+                    "type": "string" | "number" | "boolean" | "object" | "array",
+                    "description": "Field description",
+                    "required": True | False,
+                    "default": <optional default value>,
+                    "enum": [<optional enum values>]
+                }
+            }
+        }
+        """
+        fields_config = schema_config.get('fields', {})
+        schema_description = schema_config.get('description', 'Tool arguments schema')
+
+        # Build field annotations and defaults
+        annotations = {}
+        field_defaults = {}
+
+        TYPE_MAP = {
+            'string': str,
+            'number': float,
+            'integer': int,
+            'boolean': bool,
+            'object': Dict[str, Any],
+            'array': list,
+        }
+
+        for field_name, field_config in fields_config.items():
+            field_type_str = field_config.get('type', 'string')
+            field_type = TYPE_MAP.get(field_type_str, str)
+            field_description = field_config.get('description', '')
+            is_required = field_config.get('required', True)
+            default_value = field_config.get('default')
+            enum_values = field_config.get('enum')
+
+            # Handle optional fields
+            if not is_required:
+                field_type = Optional[field_type]
+
+            annotations[field_name] = field_type
+
+            # Build Field with description and enum if provided
+            field_kwargs = {'description': field_description}
+            if enum_values:
+                # For enums, include in description since Pydantic Field doesn't support enum directly
+                field_kwargs['description'] = f"{field_description} Options: {', '.join(str(v) for v in enum_values)}"
+
+            if default_value is not None:
+                field_defaults[field_name] = Field(default=default_value, **field_kwargs)
+            elif not is_required:
+                field_defaults[field_name] = Field(default=None, **field_kwargs)
+            else:
+                field_defaults[field_name] = Field(**field_kwargs)
+
+        # Create dynamic Pydantic model
+        DynamicSchema = create_model(
+            'DynamicToolSchema',
+            __doc__=schema_description,
+            **{name: (annotations[name], field_defaults[name]) for name in annotations}
+        )
+
+        return DynamicSchema