@messenger-box/tailwind-ui-inbox 10.0.3-alpha.100

package/lib/machines/aiAgentMachine.js

@@ -0,0 +1,1083 @@
+import {createMachine,assign,fromPromise}from'xstate';import {config}from'../config/env-config.js';const {
+  CLIENT_URL,
+  NEWS_API_KEY
+} = config;
+const env = {
+  NEWS_API_KEY: NEWS_API_KEY
+};
+// API configuration - using environment variables from dev.env
+// Read persisted model configuration saved by usePersistentModelConfig
+function getUserModelConfig() {
+  try {
+    if (typeof window === 'undefined') return {};
+    const raw = window.localStorage.getItem('mbx:model-config');
+    if (!raw) return {};
+    const parsed = JSON.parse(raw);
+    return {
+      provider: parsed?.provider,
+      model: parsed?.model,
+      apiKey: parsed?.apiKey
+    };
+  } catch {
+    return {};
+  }
+}
+const USER_MODEL_CONFIG = getUserModelConfig();
+const API_CONFIG = {
+  // Only non-AI keys from env (public APIs allowed)
+  NEWS_API_KEY: env?.NEWS_API_KEY,
+  // Configurable proxy endpoints
+  ANTHROPIC_ENDPOINT: '/api/anthropic/messages',
+  OPENAI_ENDPOINT: '/api/openai',
+  // Direct MCP search APIs (these are public and don't have CORS issues)
+  NEWS_API_ENDPOINT: 'https://newsapi.org/v2/everything',
+  REDDIT_SEARCH_ENDPOINT: 'https://www.reddit.com/search.json',
+  REDDIT_TRENDING_ENDPOINT: 'https://www.reddit.com/r/news/hot.json',
+  DUCKDUCKGO_ENDPOINT: 'https://api.duckduckgo.com/',
+  // Model configuration
+  DEFAULT_MODEL: 'claude-3-5-haiku-20241022',
+  OPENAI_MODEL: 'gpt-4o-mini',
+  // User-provided model configuration (from localStorage)
+  get userProvider() {
+    return USER_MODEL_CONFIG?.provider;
+  },
+  get userModel() {
+    return USER_MODEL_CONFIG?.model;
+  },
+  get userApiKey() {
+    return USER_MODEL_CONFIG?.apiKey;
+  },
+  // Check which AI provider is available (ONLY from user config)
+  get availableProvider() {
+    if (this.userApiKey && this.userProvider) {
+      if (this.userProvider === 'anthropic') return 'anthropic';
+      if (this.userProvider === 'openai') return 'openai';
+    }
+    return null;
+  },
+  // Get the appropriate endpoint based on available provider
+  get primaryEndpoint() {
+    if (this.availableProvider === 'anthropic') return this.ANTHROPIC_ENDPOINT;
+    if (this.availableProvider === 'openai') return this.OPENAI_ENDPOINT;
+    return '';
+  },
+  // Get the appropriate model based on available provider
+  get primaryModel() {
+    if (this.userModel) return this.userModel;
+    if (this.availableProvider === 'anthropic') return this.DEFAULT_MODEL;
+    if (this.availableProvider === 'openai') return this.OPENAI_MODEL;
+    return this.DEFAULT_MODEL;
+  }
+};
+// Log configuration on startup
+console.log('🤖 AI Agent Machine Configuration:');
+console.log(`   Available Provider (user): ${API_CONFIG.availableProvider || 'None'}`);
+console.log(`   Primary Endpoint: ${API_CONFIG.primaryEndpoint}`);
+console.log(`   Primary Model: ${API_CONFIG.primaryModel}`);
+console.log(`   Using Proxy for AI APIs: ✅ (avoids CORS issues)`);
+console.log(`   Using Direct APIs for MCP Search: ✅ (public APIs)`);
+console.log(`   User API Key: ${API_CONFIG.userApiKey ? '✅ Configured' : '❌ Not configured'}`);
+console.log(`   News API Key: ${API_CONFIG.NEWS_API_KEY ? '✅ Configured' : '❌ Not configured'}`);
+// Test API configuration
+if (!API_CONFIG.availableProvider) {
+  console.error('🚨 CRITICAL: No AI API provider configured!');
+  console.error('🚨 Please add your API key in Model Settings.');
+} else {
+  console.log(`✅ AI API provider configured: ${API_CONFIG.availableProvider}`);
+}
+// Helper function to get the base URL for proxy calls
+function getProxyBaseUrl() {
+  // Use Vite dev server proxy to avoid CORS issues
+  return CLIENT_URL || 'http://localhost:3011'; // Vite dev server
+}
+// Log the current proxy configuration
+console.log(`🌐 Proxy Configuration: ${getProxyBaseUrl()}`);
+// Helper function to make API calls through proxy (avoids CORS)
+async function makeApiCall(endpoint, options) {
+  try {
+    const baseUrl = getProxyBaseUrl();
+    const url = endpoint ? `${baseUrl}${endpoint}` : '';
+    console.log(`🌐 Making API call through proxy to: ${url}`);
+    console.log(`📤 Request options:`, {
+      method: options.method,
+      headers: options.headers,
+      body: options.body ? JSON.parse(options.body) : undefined
+    });
+    // Do not call if no endpoint (no provider configured)
+    if (!endpoint) {
+      throw new Error('AI provider is not configured. Please add your API key in Model Settings.');
+    }
+    // Inject API key headers from user config if available
+    const headers = new Headers(options.headers || {});
+    if (API_CONFIG.userApiKey) {
+      if (API_CONFIG.availableProvider === 'anthropic') {
+        headers.set('x-api-key', API_CONFIG.userApiKey);
+        headers.set('anthropic-version', '2023-06-01');
+        headers.set('anthropic-dangerous-direct-browser-access', 'true');
+      } else if (API_CONFIG.availableProvider === 'openai') {
+        headers.set('Authorization', `Bearer ${API_CONFIG.userApiKey}`);
+      }
+    }
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      console.error('🚨 API Error:', response.status, errorData);
+      let errorMessage = 'API request failed';
+      if (errorData.error) {
+        if (typeof errorData.error === 'string') {
+          errorMessage = errorData.error;
+        } else if (errorData.error.message) {
+          errorMessage = errorData.error.message;
+        } else if (errorData.error.type) {
+          errorMessage = `${errorData.error.type}: ${errorData.error.message || 'Unknown error'}`;
+        }
+      }
+      throw new Error(errorMessage);
+    }
+    return response;
+  } catch (error) {
+    console.error('🚨 API call error:', error);
+    throw error;
+  }
+}
+// Helper function to fetch news from NewsAPI directly
+async function fetchNewsFromNewsAPI(query) {
+  if (!API_CONFIG.NEWS_API_KEY) {
+    console.warn('⚠️ News API key not found, skipping NewsAPI');
+    return [];
+  }
+  try {
+    const response = await fetch(`${API_CONFIG.NEWS_API_ENDPOINT}?q=${encodeURIComponent(query)}&apiKey=${API_CONFIG.NEWS_API_KEY}&language=en&sortBy=publishedAt&pageSize=5`);
+    if (!response.ok) {
+      console.error('NewsAPI error:', response.status);
+      return [];
+    }
+    const data = await response.json();
+    if (data.articles) {
+      return data.articles.map(article => ({
+        title: article.title,
+        url: article.url,
+        description: article.description || article.title,
+        publishedAt: article.publishedAt,
+        source: {
+          name: article.source.name
+        }
+      }));
+    }
+  } catch (error) {
+    console.error('NewsAPI error:', error);
+  }
+  return [];
+}
+// Helper function to fetch from Reddit API directly
+async function fetchAlternativeNews(query) {
+  try {
+    const response = await fetch(`${API_CONFIG.REDDIT_SEARCH_ENDPOINT}?q=${encodeURIComponent(query)}&sort=new&t=day&limit=3&restrict_sr=false&type=link`);
+    if (!response.ok) {
+      console.error('Reddit API error:', response.status);
+      return [];
+    }
+    const data = await response.json();
+    if (data?.data?.children) {
+      return data.data.children.filter(post => post.data.url && !post.data.is_self).slice(0, 3).map(post => ({
+        title: post.data.title,
+        url: post.data.url,
+        description: `Discussion: ${post.data.title} (${post.data.score} upvotes)`,
+        publishedAt: new Date(post.data.created_utc * 1000).toISOString(),
+        source: {
+          name: `r/${post.data.subreddit}`
+        }
+      }));
+    }
+  } catch (error) {
+    console.error('Reddit API error:', error);
+  }
+  return [];
+}
+// Helper function to search DuckDuckGo directly
+async function searchDuckDuckGo(query) {
+  try {
+    const response = await fetch(`${API_CONFIG.DUCKDUCKGO_ENDPOINT}?q=${encodeURIComponent(query)}&format=json&no_html=1&skip_disambig=1`);
+    if (!response.ok) {
+      console.error('DuckDuckGo API error:', response.status);
+      return [];
+    }
+    const data = await response.json();
+    const results = [];
+    // Add abstract if available
+    if (data.Abstract) {
+      results.push({
+        title: data.Heading || `About ${query}`,
+        url: data.AbstractURL || `https://duckduckgo.com/?q=${encodeURIComponent(query)}`,
+        snippet: data.Abstract,
+        source: 'DuckDuckGo'
+      });
+    }
+    // Add related topics
+    if (data.RelatedTopics && data.RelatedTopics.length > 0) {
+      data.RelatedTopics.slice(0, 3).forEach(topic => {
+        if (topic.Text && topic.FirstURL) {
+          results.push({
+            title: topic.Text.split(' - ')[0] || topic.Text.substring(0, 60),
+            url: topic.FirstURL,
+            snippet: topic.Text,
+            source: 'DuckDuckGo'
+          });
+        }
+      });
+    }
+    return results;
+  } catch (error) {
+    console.error('DuckDuckGo API error:', error);
+    return [];
+  }
+}
+// Helper function to get trending news from Reddit directly
+async function getTrendingNews() {
+  try {
+    const response = await fetch(`${API_CONFIG.REDDIT_TRENDING_ENDPOINT}?limit=5`);
+    if (!response.ok) {
+      console.error('Reddit trending error:', response.status);
+      return [];
+    }
+    const data = await response.json();
+    if (data?.data?.children) {
+      return data.data.children.filter(post => post.data.url && !post.data.is_self).map(post => ({
+        title: post.data.title,
+        url: post.data.url,
+        description: `Trending: ${post.data.title} (${post.data.score} upvotes, ${post.data.num_comments} comments)`,
+        publishedAt: new Date(post.data.created_utc * 1000).toISOString(),
+        source: {
+          name: 'r/news'
+        }
+      }));
+    }
+  } catch (error) {
+    console.error('Reddit trending error:', error);
+  }
+  return [];
+}
+// Direct MCP search function - no more server dependency
+async function performDirectMCPSearch(query, includeNews = true, includeWeb = true) {
+  try {
+    console.log(`🔍 Performing direct MCP search for: "${query}" (news: ${includeNews}, web: ${includeWeb})`);
+    const promises = [];
+    // Fetch news if requested
+    if (includeNews) {
+      // Try multiple news sources
+      promises.push(fetchNewsFromNewsAPI(query), fetchAlternativeNews(query));
+      // For US news specifically, get trending
+      if (query.toLowerCase().includes('us news') || query.toLowerCase().includes('american news')) {
+        promises.push(getTrendingNews());
+      }
+    }
+    // Fetch web search if requested
+    if (includeWeb) {
+      promises.push(searchDuckDuckGo(query));
+    }
+    // Execute all searches concurrently
+    const results = await Promise.allSettled(promises);
+    // Combine all successful results
+    let searchResults = [];
+    let newsArticles = [];
+    results.forEach((result, index) => {
+      if (result.status === 'fulfilled' && Array.isArray(result.value)) {
+        if (includeWeb && index === results.length - 1) {
+          // Last promise is web search
+          searchResults = result.value;
+        } else if (includeNews) {
+          // Other promises are news sources
+          newsArticles = [...newsArticles, ...result.value];
+        }
+      }
+    });
+    // Remove duplicates and limit results
+    newsArticles = newsArticles.filter((article, index, self) => index === self.findIndex(a => a.title === article.title)).slice(0, 8);
+    searchResults = searchResults.slice(0, 5);
+    const response = {
+      searchResults: includeWeb ? searchResults : [],
+      newsArticles: includeNews ? newsArticles : [],
+      summary: `Found ${searchResults.length} web results and ${newsArticles.length} news articles for "${query}"`,
+      sources: [...(includeWeb ? ['DuckDuckGo'] : []), ...(includeNews ? ['NewsAPI', 'Reddit', 'Alternative Sources'] : [])].filter(Boolean),
+      searchTime: Date.now(),
+      realData: true // Flag to indicate this is real data
+    };
+    console.log(`✅ Direct MCP search completed: ${response.searchResults.length} web + ${response.newsArticles.length} news results`);
+    return response;
+  } catch (error) {
+    console.error('🚨 Direct MCP search error:', error);
+    throw error;
+  }
+}
+// Helper function to detect if a query needs multi-message response
+function needsMultiMessageResponse(query) {
+  const multiMessageKeywords = ['explain step by step', 'break down', 'tutorial', 'guide', 'how to', 'teach me', 'walk me through', 'step-by-step', 'detailed explanation', 'in detail', 'comprehensive', 'thorough', 'complete guide', 'coding', 'programming', 'development', 'build', 'create', 'multiple', 'several', 'various', 'different ways'];
+  const lowerQuery = query.toLowerCase();
+  return multiMessageKeywords.some(keyword => lowerQuery.includes(keyword)) || query.length > 200; // Long queries often benefit from multi-message responses
+}
+// Helper function to detect if a query needs real-time data
+function needsRealTimeData(query) {
+  const realTimeKeywords = ['latest', 'recent', 'news', 'current', 'today', 'yesterday', 'breaking', 'update', 'now', 'price', 'stock', 'weather', 'trending', 'popular', 'search', "what's happening", 'tell me about', 'find', 'look up', 'research'];
+  const lowerQuery = query.toLowerCase();
+  return realTimeKeywords.some(keyword => lowerQuery.includes(keyword));
+}
+// Helper function to format MCP data for the agent
+function formatMCPDataForAgent(mcpData) {
+  let context = '';
+  if (mcpData.searchResults && mcpData.searchResults.length > 0) {
+    context += 'Current web search results:\n';
+    mcpData.searchResults.forEach((result, i) => {
+      context += `${i + 1}. **${result.title}**\n   ${result.snippet}\n   Source: ${result.url}\n\n`;
+    });
+  }
+  if (mcpData.newsArticles && mcpData.newsArticles.length > 0) {
+    context += 'Recent news articles:\n';
+    mcpData.newsArticles.forEach((article, i) => {
+      context += `${i + 1}. **${article.title}**\n   ${article.description}\n   Published: ${new Date(article.publishedAt).toLocaleDateString()}\n   Source: ${article.source.name}\n\n`;
+    });
+  }
+  if (context) {
+    context = 'Here is the current information I have access to:\n\n' + context + '\nPlease use this information to provide an accurate, up-to-date response.';
+  }
+  return context;
+}
+// Helper function to get the appropriate system prompt based on provider
+function getSystemPrompt(provider, includeMCP = false) {
+  const basePrompt = includeMCP ? 'You are a helpful AI assistant that can access real-time information through web search and news APIs. When provided with current information, use it to give accurate, up-to-date responses. Always cite your sources when referencing specific information from search results or news articles. You excel at providing comprehensive analysis and insights based on the latest data available.' : 'You are a helpful AI assistant that provides detailed, step-by-step responses. Focus on the specific aspect requested and provide practical, actionable information.';
+  if (provider === 'anthropic') {
+    return basePrompt;
+  } else if (provider === 'openai') {
+    return basePrompt;
+  }
+  return basePrompt;
+}
+// Helper function to get conversation context from regular messages
+function getConversationContext(regularMessages) {
+  if (!regularMessages || regularMessages.length === 0) return '';
+  // Get the last few messages for context
+  const recentMessages = regularMessages.slice(-5);
+  let context = 'Recent conversation context:\n';
+  recentMessages.forEach((msg, index) => {
+    const author = msg.author?.username || msg.author?.givenName || 'User';
+    const content = msg.message?.substring(0, 200) || ''; // Limit content length
+    if (content.trim()) {
+      context += `${index + 1}. ${author}: ${content}\n`;
+    }
+  });
+  return context + '\n';
+}
+const aiAgentMachine = createMachine({
+  /** @xstate-layout N4IgpgJg5mDOIC5QEMCWBBGA7ALgOlQgBswBiAZQFEA5AEQH0BZS889AcUoG0AGAXUSgADgHtYqHKhFZBIAB6IA7ACZleAGwBWdYoAsmngA4AzAE5Fi4wBoQAT0S6AjKbzHHy06aO7Du3eoBfAJs0TDBcAmIyAElqAAUAVQAVegBhAAl0ak5eASQQUXFJaVkFBE1dF0dvXx49Q19NG3sEXUUXHz9lRydFA2dNIJCMbHxCElJUgBlKdAAleko5uYB5OdzZQokpGXyyzU1jPFN9ZXVdHmN9dUNmxGNfPB7NRUNnR0N1ZX0hkFDRvDILDIIi2ABeqCwUFIG3yW2Ku1AZXcykUGlMhk0hh4PEcenU5zurV0R16yiupkODV+-3C+CBIPBkOhXEceWEYm2JT2iBRaPUGKxOLx-kJdkQ33UeA8ZnUxiuulRuhpIzpeAAZmAcABjAAWzNoyBwyFIEGkYAIWAAbiIANYWzU63WMVJxQ3G2Ecoo7Uq87FS8lnE6KardInGc54TTKF48bQVE4VQbBP6qiKOvUGo0msAAJ1zIlzeCERCN6sLAFsNVq9S63dnPQVOQjfQgPjwA8Yg21Q44idc8J8LspcapHMYeMqU7SIkIC9q4OIoabzZabfa8Ng80awHM4KIsLAwI34T6eW3-dKuwKezww+LynLjoZVDxPKiu20VWFZ-PF8zSDzAsixLMtK03cJtxwXd92kI8T2bM8kT9Ooo0sN9HEwrpLiJN4nkMSxTEwgjFHUONFG-AEgMLUg5koJI5gATQQ71uWQhByU0KMfDOao3zfZRbgfFQpVqaNtAJTRiMotVqNzCgaAYZhWA4bh+E2RC2PkCVjC4ioX3UPivFMQSiW+HhjlI-xugFD4Xgo6c03wOTSFiRIUgyLIcnUuFNMRbTWmUIlDN0fDsUxPofCMYwZIiFzplmBYllWdYfK9Ll-LKTjuIMoyBKEloEw0KS3zImUzAclMsBECA4FkGccA01jMsQABadQiVarjPB63revaWKxiiJqMtbTQTjwfijH4vxxtMIkXhcF8JzIoi5XaGLHJ-elgVBCEoRGltz2qJxpUcc5elIyk5X7S5Bx0HE4yIypLEG6snSzY1DqQgKehfPBh3ld9cTjawHycQxJq+Ui3wjEy8U24ZtuLP9YCXKBvq0rK4wsr5DhDLwe10fsYyeO930Mkw9HMN65MxlqEEeO9qbleVun8RQiRDULox0GMYwjTFAiCAIgA */
+  id: 'aiAgent',
+  types: {},
+  initial: 'idle',
+  context: {
+    messages: [],
+    currentInput: '',
+    error: null,
+    isTyping: false,
+    multiMessageMode: false,
+    currentMultiStep: 0,
+    totalMultiSteps: 0,
+    multiMessagePlan: [],
+    mcpData: undefined,
+    regularMessages: [] // Add regular messages from query
+  },
+  states: {
+    idle: {
+      on: {
+        SEND_MESSAGE: {
+          target: 'analyzing',
+          guard: 'hasValidMessage',
+          actions: 'addUserMessage'
+        },
+        FORCE_MULTI_MESSAGE: {
+          target: 'analyzing',
+          guard: 'hasValidMessage',
+          actions: 'addUserMessage'
+        },
+        AUTO_RESPOND_TO_MESSAGE: {
+          target: 'processing',
+          guard: 'hasValidMessage',
+          actions: 'addAutoResponseMessage'
+        },
+        INPUT_CHANGE: {
+          actions: 'updateInput'
+        },
+        CLEAR_ERROR: {
+          actions: 'clearError'
+        },
+        UPDATE_REGULAR_MESSAGES: {
+          actions: 'updateRegularMessages'
+        },
+        ANALYZE_EXISTING_CONTEXT: {
+          target: 'analyzing',
+          guard: 'hasExistingContext',
+          actions: 'addContextAnalysisMessage'
+        },
+        CONTINUE_PROCESSING: {
+          // Just stay in idle state to trigger the useEffect again
+          actions: 'logContinueProcessing'
+        }
+      }
+    },
+    analyzing: {
+      entry: 'setTyping',
+      always: [{
+        target: 'planningMultiMessage',
+        guard: 'shouldUseMultiMessage'
+      }, {
+        target: 'fetchingData',
+        guard: 'queryNeedsRealTimeData'
+      }, {
+        target: 'processing'
+      }]
+    },
+    planningMultiMessage: {
+      entry: 'setMultiMessageMode',
+      invoke: {
+        id: 'generateMultiMessagePlan',
+        src: 'generateMultiMessagePlan',
+        input: ({
+          context
+        }) => ({
+          query: context.messages[context.messages.length - 1]?.content || '',
+          regularMessages: context.regularMessages
+        }),
+        onDone: {
+          target: 'multiProcessing',
+          actions: 'setMultiMessagePlan'
+        },
+        onError: {
+          target: 'processing' // Fall back to single message
+        }
+      }
+    },
+    multiProcessing: {
+      invoke: {
+        id: 'generateMultiMessage',
+        src: 'generateMultiMessage',
+        input: ({
+          context
+        }) => ({
+          messages: context.messages,
+          plan: context.multiMessagePlan,
+          currentStep: context.currentMultiStep,
+          mcpData: context.mcpData,
+          regularMessages: context.regularMessages
+        }),
+        onDone: [{
+          target: 'waitingBetweenMessages',
+          guard: 'hasMoreMultiMessages',
+          actions: ['addAIMessage', 'incrementMultiStep']
+        }, {
+          target: 'idle',
+          actions: ['addAIMessage', 'resetMultiMessage']
+        }],
+        onError: {
+          target: 'error',
+          actions: 'setError'
+        }
+      }
+    },
+    waitingBetweenMessages: {
+      entry: 'setTyping',
+      after: {
+        1500: 'multiProcessing'
+      }
+    },
+    fetchingData: {
+      invoke: {
+        id: 'fetchMCPData',
+        src: 'fetchMCPData',
+        input: ({
+          context
+        }) => ({
+          query: context.messages[context.messages.length - 1]?.content || ''
+        }),
+        onDone: {
+          target: 'processing',
+          actions: 'setMCPData'
+        },
+        onError: {
+          target: 'processing'
+        }
+      }
+    },
+    processing: {
+      entry: () => {
+        console.log('🤖 Entering processing state');
+      },
+      invoke: {
+        id: 'generateResponse',
+        src: 'generateAIResponse',
+        input: ({
+          context
+        }) => {
+          console.log('🤖 generateAIResponse input:', {
+            messagesCount: context.messages.length,
+            hasMessageToRespondTo: !!context.messageToRespondTo,
+            messageToRespondTo: context.messageToRespondTo,
+            regularMessagesCount: context.regularMessages?.length || 0
+          });
+          return {
+            messages: context.messages,
+            mcpData: context.mcpData,
+            regularMessages: context.regularMessages,
+            messageToRespondTo: context.messageToRespondTo
+          };
+        },
+        onDone: {
+          target: 'idle',
+          actions: [assign(({
+            context,
+            event
+          }) => {
+            console.log('🤖 🎯 onDone transition triggered with event:', event);
+            console.log('🤖 🎯 Event type:', typeof event);
+            console.log('🤖 🎯 Event content:', event);
+            return context;
+          }), 'addAIMessage']
+        },
+        onError: {
+          target: 'error',
+          actions: 'setError'
+        }
+      }
+    },
+    error: {
+      on: {
+        RETRY: {
+          target: 'processing'
+        },
+        SEND_MESSAGE: {
+          target: 'analyzing',
+          guard: 'hasValidMessage',
+          actions: 'addUserMessage'
+        },
+        INPUT_CHANGE: {
+          actions: 'updateInput'
+        },
+        CLEAR_ERROR: {
+          target: 'idle',
+          actions: 'clearError'
+        },
+        UPDATE_REGULAR_MESSAGES: {
+          actions: 'updateRegularMessages'
+        }
+      }
+    }
+  }
+}, {
+  guards: {
+    hasValidMessage: ({
+      event
+    }) => {
+      console.log('🔍 hasValidMessage guard called with event:', event);
+      if (event.type === 'AUTO_RESPOND_TO_MESSAGE') {
+        const isValid = event.message?.trim().length > 0;
+        console.log('🔍 AUTO_RESPOND_TO_MESSAGE guard result:', isValid, 'message:', event.message);
+        return isValid;
+      }
+      if (event.type === 'SEND_MESSAGE' || event.type === 'FORCE_MULTI_MESSAGE') {
+        const isValid = event.message?.trim().length > 0;
+        console.log('🔍 SEND_MESSAGE/FORCE_MULTI_MESSAGE guard result:', isValid, 'message:', event.message);
+        return isValid;
+      }
+      console.log('🔍 Unknown event type in hasValidMessage guard:', event.type);
+      return false;
+    },
+    shouldUseMultiMessage: ({
+      context,
+      event
+    }) => {
+      if (event.type === 'FORCE_MULTI_MESSAGE') return true;
+      const lastMessage = context.messages[context.messages.length - 1];
+      if (!lastMessage || lastMessage.sender !== 'user') return false;
+      const shouldUse = needsMultiMessageResponse(lastMessage.content);
+      console.log('🔄 Should use multi-message:', shouldUse, 'for:', lastMessage.content);
+      return shouldUse;
+    },
+    queryNeedsRealTimeData: ({
+      context
+    }) => {
+      const lastMessage = context.messages[context.messages.length - 1];
+      if (!lastMessage || lastMessage.sender !== 'user') return false;
+      const needs = needsRealTimeData(lastMessage.content);
+      console.log('🔍 Query needs real-time data:', needs, 'for:', lastMessage.content);
+      return needs;
+    },
+    hasMoreMultiMessages: ({
+      context
+    }) => {
+      return context.currentMultiStep < context.totalMultiSteps - 1;
+    },
+    hasExistingContext: ({
+      context
+    }) => {
+      return context.regularMessages && context.regularMessages.length > 0;
+    }
+  },
+  actions: {
+    addUserMessage: assign(({
+      context,
+      event
+    }) => {
+      if (event.type !== 'SEND_MESSAGE' && event.type !== 'FORCE_MULTI_MESSAGE') return context;
+      const newMessage = {
+        id: Date.now().toString(),
+        content: event.message,
+        sender: 'user',
+        timestamp: new Date()
+      };
+      return {
+        ...context,
+        messages: [...context.messages, newMessage],
+        currentInput: '',
+        error: null,
+        mcpData: undefined,
+        messageToRespondTo: undefined // Clear the message to respond to when adding new user message
+      };
+    }),
+    addAIMessage: assign(({
+      context,
+      event
+    }) => {
+      console.log('🤖 addAIMessage called with event:', event);
+      // Extract the AI response content from the event
+      let aiResponseContent = '';
+      // Handle different event formats
+      if (event && typeof event === 'object') {
+        if ('output' in event) {
+          aiResponseContent = event.output;
+        } else if ('data' in event) {
+          aiResponseContent = event.data;
+        } else if (typeof event === 'string') {
+          // Direct string response from generateAIResponse actor
+          aiResponseContent = event;
+        } else {
+          console.error('🤖 Could not extract AI response content from event:', event);
+          aiResponseContent = 'Sorry, I encountered an error generating the response.';
+        }
+      } else if (typeof event === 'string') {
+        // Direct string response from generateAIResponse actor
+        aiResponseContent = event;
+      } else {
+        console.error('🤖 Could not extract AI response content from event:', event);
+        aiResponseContent = 'Sorry, I encountered an error generating the response.';
+      }
+      console.log('🤖 AI response content:', aiResponseContent.substring(0, 100) + '...');
+      const newMessage = {
+        id: (Date.now() + 1).toString(),
+        content: aiResponseContent,
+        sender: 'ai',
+        timestamp: new Date()
+      };
+      console.log('🤖 Adding AI message to context:', newMessage);
+      return {
+        ...context,
+        messages: [...context.messages, newMessage],
+        isTyping: false,
+        error: null,
+        messageToRespondTo: undefined // Clear the message to respond to after processing
+      };
+    }),
+    updateInput: assign(({
+      context,
+      event
+    }) => {
+      if (event.type !== 'INPUT_CHANGE') return context;
+      return {
+        ...context,
+        currentInput: event.value
+      };
+    }),
+    updateRegularMessages: assign(({
+      context,
+      event
+    }) => {
+      if (event.type !== 'UPDATE_REGULAR_MESSAGES') return context;
+      return {
+        ...context,
+        regularMessages: event.messages || []
+      };
+    }),
+    setMultiMessageMode: assign(({
+      context
+    }) => ({
+      ...context,
+      multiMessageMode: true,
+      currentMultiStep: 0
+    })),
+    setMultiMessagePlan: assign(({
+      context,
+      event
+    }) => {
+      const plan = event.output;
+      console.log('📝 Multi-message plan created:', plan.totalSteps, 'steps');
+      return {
+        ...context,
+        multiMessagePlan: plan.plan,
+        totalMultiSteps: plan.totalSteps
+      };
+    }),
+    incrementMultiStep: assign(({
+      context
+    }) => ({
+      ...context,
+      currentMultiStep: context.currentMultiStep + 1
+    })),
+    logContinueProcessing: () => {
+      console.log('🤖 Continue processing triggered - machine will stay in idle state');
+    },
+    resetMultiMessage: assign(({
+      context
+    }) => ({
+      ...context,
+      multiMessageMode: false,
+      currentMultiStep: 0,
+      totalMultiSteps: 0,
+      multiMessagePlan: [],
+      isTyping: false
+    })),
+    setTyping: assign(({
+      context
+    }) => ({
+      ...context,
+      isTyping: true
+    })),
+    setMCPData: assign(({
+      context,
+      event
+    }) => {
+      console.log('📊 MCP data fetched successfully');
+      return {
+        ...context,
+        mcpData: event.output
+      };
+    }),
+    setError: assign(({
+      context,
+      event
+    }) => {
+      console.error('❌ AI processing error:', event);
+      let errorMessage = 'An unexpected error occurred';
+      const error = event.error;
+      if (error instanceof Error) {
+        errorMessage = error.message;
+      } else if (typeof error === 'string') {
+        errorMessage = error;
+      }
+      if (errorMessage.includes('API key')) {
+        errorMessage = 'API key not configured. Please add your API key in Model Settings.';
+      } else if (errorMessage.includes('rate limit')) {
+        errorMessage = 'Rate limit exceeded. Please try again in a moment.';
+      } else if (errorMessage.includes('network') || errorMessage.includes('fetch')) {
+        errorMessage = 'Network error. Please check your connection and try again.';
+      }
+      return {
+        ...context,
+        error: errorMessage,
+        isTyping: false
+      };
+    }),
+    clearError: assign(({
+      context
+    }) => ({
+      ...context,
+      error: null
+    })),
+    addContextAnalysisMessage: assign(({
+      context
+    }) => {
+      const newMessage = {
+        id: (Date.now() + 2).toString(),
+        content: 'Please analyze the existing conversation and provide insights, continue the discussion, or ask relevant follow-up questions based on the context.',
+        sender: 'user',
+        timestamp: new Date()
+      };
+      return {
+        ...context,
+        messages: [...context.messages, newMessage],
+        currentInput: '',
+        error: null
+      };
+    }),
+    addAutoResponseMessage: assign(({
+      context,
+      event
+    }) => {
+      if (event.type !== 'AUTO_RESPOND_TO_MESSAGE') return context;
+      console.log('🤖 addAutoResponseMessage called with event:', event);
+      console.log('🤖 Current context before update:', {
+        messagesCount: context.messages.length,
+        hasMessageToRespondTo: !!context.messageToRespondTo,
+        messageToRespondTo: context.messageToRespondTo
+      });
+      // For auto-responses, we store the message content for AI processing
+      // but don't add it as a new user message to avoid duplicates
+      const updatedContext = {
+        ...context,
+        currentInput: '',
+        error: null,
+        mcpData: undefined,
+        // Store the message to respond to without adding it to messages array
+        messageToRespondTo: event.message
+      };
+      console.log('🤖 Context updated with messageToRespondTo:', event.message);
+      console.log('🤖 Updated context:', {
+        messagesCount: updatedContext.messages.length,
+        hasMessageToRespondTo: !!updatedContext.messageToRespondTo,
+        messageToRespondTo: updatedContext.messageToRespondTo
+      });
+      return updatedContext;
+    })
+  },
+  actors: {
+    generateMultiMessagePlan: fromPromise(async ({
+      input
+    }) => {
+      try {
+        console.log('📋 Generating multi-message plan for:', input.query);
+        // Check if we have an available AI provider
+        if (!API_CONFIG.availableProvider) {
+          throw new Error('No AI API key configured. Please set VITE_ANTHROPIC_API_KEY or VITE_OPENAI_API_KEY in your environment.');
+        }
+        console.log(`🤖 Using ${API_CONFIG.availableProvider} provider for multi-message planning`);
+        // Add conversation context if available
+        let systemPrompt = `You are a planning assistant. Break down complex queries into 3-5 independent messages that can be sent sequentially. 
+              
+              Each message should be a complete, standalone response that builds upon the previous ones.
+              
+              Return ONLY a JSON object in this exact format:
+              {
+                "plan": ["First message topic/focus", "Second message topic/focus", "Third message topic/focus"],
+                "totalSteps": 3
+              }
+              
+              Keep each step concise but descriptive. Make sure the breakdown makes sense for step-by-step explanations.`;
+        if (input.regularMessages && input.regularMessages.length > 0) {
+          const conversationContext = getConversationContext(input.regularMessages);
+          systemPrompt = `${systemPrompt}\n\n${conversationContext}`;
+        }
+        const response = await makeApiCall(API_CONFIG.primaryEndpoint, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify({
+            model: API_CONFIG.primaryModel,
+            max_tokens: 500,
+            system: systemPrompt,
+            messages: [{
+              role: 'user',
+              content: `Please create a multi-message plan for this query: "${input.query}"`
+            }]
+          })
+        });
+        const data = await response.json();
+        const planText = data.content[0]?.text || '';
+        // Parse the JSON response
+        try {
+          const plan = JSON.parse(planText);
+          console.log('✅ Multi-message plan created:', plan);
+          return plan;
+        } catch {
+          // Fallback plan if parsing fails
+          return {
+            plan: ['Introduction and overview', 'Detailed explanation with examples', 'Summary and next steps'],
+            totalSteps: 3
+          };
+        }
+      } catch (error) {
+        console.error('🚨 Multi-message planning error:', error);
+        throw error;
+      }
+    }),
+    generateMultiMessage: fromPromise(async ({
+      input
+    }) => {
+      console.log(`🔄 Generating multi-message ${input.currentStep + 1}/${input.plan?.length || 1}`);
+      try {
+        // Check if we have an available AI provider
+        if (!API_CONFIG.availableProvider) {
+          throw new Error('No AI API key configured. Please set VITE_ANTHROPIC_API_KEY or VITE_OPENAI_API_KEY in your environment.');
+        }
+        console.log(`🤖 Using ${API_CONFIG.availableProvider} provider for multi-message generation`);
+        const userMessages = input.messages.filter(msg => msg.sender === 'user');
+        const latestUserMessage = userMessages[userMessages.length - 1];
+        if (!latestUserMessage) {
+          throw new Error('No user message found');
+        }
+        const currentStepTopic = input.plan?.[input.currentStep] || 'General response';
+        const stepNumber = input.currentStep + 1;
+        const totalSteps = input.plan?.length || 1;
+        let prompt = `User's original question: "${latestUserMessage.content}"
+
+This is message ${stepNumber} of ${totalSteps} in a multi-message response.
+Focus specifically on: ${currentStepTopic}
+
+Guidelines:
+- Start with a clear indicator like "**Step ${stepNumber}/${totalSteps}: ${currentStepTopic}**"
+- Provide a complete, standalone response for this specific aspect
+- Keep it focused and detailed but not overwhelming
+- Use examples, code snippets, or bullet points where helpful
+- End with a brief transition to what's coming next (unless it's the final message)`;
+        // Add conversation context if available
+        if (input.regularMessages && input.regularMessages.length > 0) {
+          const conversationContext = getConversationContext(input.regularMessages);
+          prompt = `${conversationContext}${prompt}`;
+        }
+        // Add MCP context if available
+        if (input.mcpData) {
+          const mcpContext = formatMCPDataForAgent(input.mcpData);
+          if (mcpContext) {
+            prompt = `${mcpContext}\n\n${prompt}`;
+          }
+        }
+        const response = await makeApiCall(API_CONFIG.primaryEndpoint, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify({
+            model: API_CONFIG.primaryModel,
+            max_tokens: 800,
+            system: getSystemPrompt(API_CONFIG.availableProvider || 'anthropic', false),
+            messages: [...input.messages.slice(-5).map(msg => ({
+              role: msg.sender === 'user' ? 'user' : 'assistant',
+              content: msg.content
+            })), {
+              role: 'user',
+              content: prompt
+            }]
+          })
+        });
+        const data = await response.json();
+        return data.content[0]?.text || "Sorry, I couldn't generate a response for this step.";
+      } catch (error) {
+        console.error('🚨 Multi-message generation error:', error);
+        throw error;
+      }
+    }),
+    fetchMCPData: fromPromise(async ({
+      input
+    }) => {
+      try {
+        console.log('🌐 Fetching MCP data for query:', input.query);
+        const response = await performDirectMCPSearch(input.query, true, true);
+        console.log('✅ MCP data fetched:', response.summary);
+        return response;
+      } catch (error) {
+        console.error('🚨 MCP fetch error:', error);
+        throw error;
+      }
+    }),
+    generateAIResponse: fromPromise(async ({
+      input
+    }) => {
+      console.log('🤖 Generating response using server-side AI proxy');
+      console.log('🤖 Input received:', {
+        messagesCount: input.messages.length,
+        hasMCPData: !!input.mcpData,
+        regularMessagesCount: input.regularMessages?.length || 0,
+        messageToRespondTo: input.messageToRespondTo
+      });
+      try {
+        // Check if we have an available AI provider
+        if (!API_CONFIG.availableProvider) {
+          throw new Error('No AI API key configured. Please set VITE_ANTHROPIC_API_KEY or VITE_OPENAI_API_KEY in your environment.');
+        }
+        console.log(`🤖 Using ${API_CONFIG.availableProvider} provider for AI response generation`);
+        // Get the latest user message or the message to respond to
+        let prompt;
+        let userMessages = input.messages.filter(msg => msg.sender === 'user');
+        if (input.messageToRespondTo) {
+          // Use the message to respond to for auto-responses
+          prompt = input.messageToRespondTo;
+          console.log('🤖 Auto-responding to message:', prompt.substring(0, 50) + '...');
+        } else if (userMessages.length > 0) {
+          const latestUserMessage = userMessages[userMessages.length - 1];
+          prompt = latestUserMessage.content;
+        } else {
+          // If no user messages, this might be an auto-response
+          prompt = 'Please provide a helpful response to the conversation context.';
+        }
+        // Add conversation context if available
+        if (input.regularMessages && input.regularMessages.length > 0) {
+          const conversationContext = getConversationContext(input.regularMessages);
+          prompt = `${conversationContext}User question: ${prompt}`;
+          console.log('🚀 Enhanced prompt with conversation context - Recent messages:', input.regularMessages.length);
+        }
+        // Add MCP context if available
+        if (input.mcpData) {
+          const mcpContext = formatMCPDataForAgent(input.mcpData);
+          if (mcpContext) {
+            prompt = `${mcpContext}\n\nUser question: ${prompt}`;
+            console.log('🚀 Enhanced prompt with MCP data - Web results:', input.mcpData.searchResults?.length || 0, 'News articles:', input.mcpData.newsArticles?.length || 0);
+          }
+        }
+        // Use Vite proxy for AI API calls (avoids CORS issues)
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 15000); // Increased to 15s timeout for better reliability
+        try {
+          const response = await makeApiCall(API_CONFIG.primaryEndpoint, {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+              model: API_CONFIG.primaryModel,
+              max_tokens: 300,
+              // Further reduced for faster responses
+              system: getSystemPrompt(API_CONFIG.availableProvider || 'anthropic', true),
+              messages: [
+              // Only include the last 2 messages for faster processing
+              ...input.messages.slice(-2).map(msg => ({
+                role: msg.sender === 'user' ? 'user' : 'assistant',
+                content: msg.content
+              })), {
+                role: 'user',
+                content: prompt
+              }]
+            }),
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          const data = await response.json();
+          console.log('🤖 AI API response received:', data);
+          const aiResponseText = data.content[0]?.text || data.choices?.[0]?.message?.content || "Sorry, I couldn't generate a response.";
+          console.log('🤖 Extracted AI response text:', aiResponseText.substring(0, 100) + '...');
+          console.log('🤖 ✅ generateAIResponse actor completing successfully with text length:', aiResponseText.length);
+          return aiResponseText;
+        } catch (error) {
+          clearTimeout(timeoutId);
+          if (error.name === 'AbortError') {
+            throw new Error('AI response generation timed out. Please try again.');
+          }
+          throw error;
+        }
+      } catch (error) {
+        console.error('🚨 AI generation error:', error);
+        if (error instanceof Error) {
+          if (error.message.includes('API key')) {
+            throw new Error('AI API key is not configured. Please set your API keys in the environment variables.');
+          }
+          if (error.message.includes('rate limit')) {
+            throw new Error('Rate limit exceeded. Please try again in a moment.');
+          }
+          if (error.message.includes('network') || error.message.includes('fetch')) {
+            throw new Error('Network error. Please check your connection and ensure your Vite dev server is running on localhost:3011.');
+          }
+          throw error; // Re-throw the Error instance
+        }
+        // If error is not an Error instance, create a proper Error with string message
+        const errorMessage = typeof error === 'string' ? error : error && typeof error === 'object' && 'message' in error ? String(error.message) : 'An unexpected error occurred while generating the response';
+        throw new Error(errorMessage);
+      }
+    })
+  }
+});export{aiAgentMachine};//# sourceMappingURL=aiAgentMachine.js.map