@messenger-box/platform-server 10.0.3-alpha.95 → 10.0.3-alpha.97

package/lib/inngest/functions.js

@@ -1,4 +1,4 @@
-import {SERVER_TYPES,RoomType,PostTypeEnum,AiAgentMessageRole,AiAgentMessageType}from'common/server';import {TaggedType}from'@common-stack/core';import {createAgent,createTool,createState,createNetwork,gemini,anthropic,openai}from'@inngest/agent-kit';import {Sandbox}from'@e2b/code-interpreter';import {z}from'zod';import {lastAssistantTextMessageContent,getSandbox,parseAgentOutput}from'./utils.js';import {CODING_PROMPT,FRAGMENT_TITLE_PROMPT,RESPONSE_PROMPT,VUE_CODING_PROMPT,VITE_REACT_CODING_PROMPT}from'./prompt.js';import {config}from'../config/env-config.js';// E2B Configuration constants
+import {WorkflowNamespace,SERVER_TYPES,RoomType,AiAgentMessageRole,PostTypeEnum,AiAgentMessageType}from'common/server';import {TaggedType}from'@common-stack/core';import {createState,createAgent,createTool,createNetwork,gemini,anthropic,openai}from'@inngest/agent-kit';import {Sandbox}from'@e2b/code-interpreter';import {z}from'zod';import {lastAssistantTextMessageContent,getSandbox,parseAgentOutput}from'./utils.js';import {FRAGMENT_TITLE_PROMPT,RESPONSE_PROMPT,VUE_CODING_PROMPT,VITE_REACT_CODING_PROMPT,CODING_PROMPT}from'./prompt.js';import {config}from'../config/env-config.js';// E2B Configuration constants
 const templateID = config.E2B_TEMPLATE_ID; // Next.js template (default)
 const vueTemplateID = config.E2B_VUE_TEMPLATE_ID; // Vue template
 const viteReactTemplateID = config.E2B_VITE_REACT_TEMPLATE_ID; // Vite+React template
@@ -24,21 +24,6 @@ const getTemplateId = modelConfig => {
   }
   return templateID; // Default to Next.js template
 };
-// Helper function to normalize template names for database validation
-const normalizeTemplateName = template => {
-  if (!template) return 'NEXTJS';
-  switch (template.toLowerCase()) {
-    case 'nextjs':
-      return 'NEXTJS';
-    case 'vue':
-      return 'VUE';
-    case 'vite-react':
-    case 'vitereact':
-      return 'VITE_REACT';
-    default:
-      return 'NEXTJS';
-  }
-};
 // Helper to create model instance from modelConfig (provider/model/apiKey)
 const createModelInstance = modelConfig => {
   if (!modelConfig || !modelConfig.apiKey) {
@@ -74,9 +59,9 @@ const createModelInstance = modelConfig => {
   }
 };
 const createChannelWithProjectId = (inngest, container) => inngest.createFunction({
-  id: 'create-channel-with-projectid'
+  id: WorkflowNamespace.MESSENGER_PLATFORM_CREATE_CHANNEL_FUNCTION
 }, {
-  event: 'channel-with-project-id.create'
+  event: WorkflowNamespace.MESSENGER_PLATFORM_CREATE_CHANNEL_EVENT
 }, async ({
   event,
   step
@@ -88,17 +73,16 @@ const createChannelWithProjectId = (inngest, container) => inngest.createFunctio
     channelInput
   } = event.data || {};
   const {
-    content,
     createdBy,
+    type,
+    title,
+    displayName,
+    topic,
+    description,
     orgName,
-    organization,
     team,
-    files,
-    notificationParams,
     modelConfig,
-    accountId,
-    teamId,
-    orgId
+    postData
   } = channelInput;
   // Validate that projectId is provided
   if (!projectId) {
@@ -111,7 +95,7 @@ const createChannelWithProjectId = (inngest, container) => inngest.createFunctio
     const existingList = await channelService.getAll({
       criteria: {
         projectId,
-        type: RoomType.Aiassistant
+        type: type || RoomType.Aiassistant
       }
     });
     const existing = Array.isArray(existingList) ? existingList[0] : null;
@@ -119,15 +103,16 @@ const createChannelWithProjectId = (inngest, container) => inngest.createFunctio
       return existing;
     }
     const newChannel = await channelService.saveChannel({
-      type: RoomType.Aiassistant,
-      orgName: orgId,
-      organization: orgId,
-      creator: createdBy || accountId,
-      title: 'AI Assistant',
-      displayName: 'AI Assistant',
-      topic: 'AI Assistant',
-      team: teamId,
-      description: 'AI Assistant',
+      ...channelInput,
+      type: type || RoomType.Aiassistant,
+      orgName,
+      organization: orgName,
+      creator: createdBy,
+      title: title || 'AI Assistant',
+      displayName: displayName || 'AI Assistant',
+      topic: topic || 'AI Assistant',
+      team: team,
+      description: description || 'AI Assistant',
       projectId,
       _id: undefined
     });
@@ -138,28 +123,36 @@ const createChannelWithProjectId = (inngest, container) => inngest.createFunctio
     if (!channelId) {
       throw new Error('Failed to resolve channel id for post creation');
     }
+    const {
+      content,
+      files,
+      props: propsData
+    } = postData;
+    const props = propsData || {
+      notificationParams: {},
+      template: modelConfig?.template || 'vite-react',
+      projectId: projectId,
+      role: AiAgentMessageRole.User,
+      fragment: {},
+      sendNotificationWithProjectId: false
+    };
     await step.sendEvent('emit-send-message', {
-      name: 'channel.message.send',
+      name: WorkflowNamespace.MESSENGER_PLATFORM_CREATE_POST_EVENT,
       data: {
         channelId,
         content,
         createdBy,
         files,
-        notificationParams,
-        projectId,
-        modelConfig,
-        accountId,
-        teamId,
-        orgId
+        props
       }
     });
   }
   return channelData;
 });
 const sendMessageHandler = (inngest, container) => inngest.createFunction({
-  id: 'channel-message-send'
+  id: WorkflowNamespace.MESSENGER_PLATFORM_CREATE_POST_FUNCTION
 }, {
-  event: 'channel.message.send'
+  event: WorkflowNamespace.MESSENGER_PLATFORM_CREATE_POST_EVENT
 }, async ({
   event,
   step
@@ -167,717 +160,38 @@ const sendMessageHandler = (inngest, container) => inngest.createFunction({
   console.log('=== Send Message Handler FUNCTION STARTED ===');
   console.log('=== Send Message Handler Event data:', JSON.stringify(event.data, null, 2));
   const {
-    projectId,
+    props,
     channelId,
     content,
     createdBy,
-    files,
-    notificationParams,
-    modelConfig,
-    accountId,
-    teamId,
-    orgId
+    files
   } = event.data || {};
-  if (!channelId || !content || !createdBy || !accountId) {
+  if (!channelId || !content || !createdBy) {
     throw new Error('channelId, content and createdBy are required');
   }
   const messageData = await step.run('persist-message', async () => {
     const postService = container.getNamed(SERVER_TYPES.PostService, TaggedType.MICROSERVICE);
-    container.get('PubSub');
     const postDoc = await postService.create({
       channel: channelId,
       message: content,
-      editedBy: createdBy || accountId,
-      author: createdBy || accountId,
-      // Convert props to propsConfiguration structure
-      props: {
-        notificationParams: notificationParams || {},
-        template: modelConfig?.template || 'vite-react',
-        projectId: projectId,
-        role: AiAgentMessageRole.USER,
-        fragment: {},
-        sendNotificationWithProjectId: false
-      },
-      type: PostTypeEnum.Simple,
+      editedBy: createdBy,
+      author: createdBy,
+      props: props || {},
+      type: PostTypeEnum.Aiassistant,
       files
     });
-    // if (postDoc) {
-    //     pubsub.publish(`POST_CREATED.${projectId}`, postDoc);
-    // }
     return await postDoc;
   });
   await step.run('publish-subscription-update', async () => {
     const pubsub = container.get('PubSub');
-    pubsub.publish(`POST_CREATED.${projectId}`, messageData);
+    pubsub.publish(`POST_CREATED.${props.projectId}`, messageData);
   });
-  // Prepare final model config with the template that was actually used
-  // const finalModelConfig = await step.run('prepare-final-model-config', async () => {
-  //     let actualTemplate = modelConfig?.template || 'nextjs';
-  //     if (modelConfig) {
-  //         // Use provided modelConfig but ensure template is what was actually stored
-  //         const finalConfig = {
-  //             ...modelConfig,
-  //             template: actualTemplate, // Always use the immutable template from DB
-  //         };
-  //         console.log('Final modelConfig for code generation:', finalConfig);
-  //         return finalConfig;
-  //     }
-  //     return {
-  //         template: actualTemplate,
-  //         provider: 'gemini',
-  //         model: 'gemini-1.5-flash',
-  //         apiKey: '', // Will need to be provided via environment
-  //     };
-  // });
-  // Trigger code generation
-  //  await step.run('trigger-code-generation', async () => {
-  //     await inngest.send({
-  //         name: 'code-agent/run-code-creation',
-  //         data: {
-  //             value:messageData.message,
-  //             projectId,
-  //             messageId: messageData.id,
-  //             owner: messageData?.author || createdBy || accountId,
-  //             orgName: orgId,
-  //             modelConfig: finalModelConfig,
-  //             accountId,
-  //             teamId,
-  //             orgId,
-  //             channelId
-  //         },
-  //     });
-  // });
-  // Send event after result is available
-  // await step.sendEvent('emit-ai-response-generate', {
-  //     name: 'ai.response.generate',
-  //     data: {
-  //         projectId,
-  //         post: result,
-  //         modelConfig,
-  //      },
-  // });
   return messageData;
 });
-// Main code agent function - processes queries and generates code
-const codeAgentFunction = (inngest, container) => inngest.createFunction({
-  id: 'code-agent'
-}, {
-  event: 'code-agent/run-code-creation'
-}, async ({
-  event,
-  step
-}) => {
-  console.log('=== CODE AGENT FUNCTION STARTED ===');
-  console.log('Event data:', JSON.stringify(event.data, null, 2));
-  const {
-    sandboxId,
-    sandboxUrl
-  } = await step.run('create-sandbox-and-start-monitoring', async () => {
-    const selectedTemplateId = getTemplateId(event.data.modelConfig);
-    console.log(`Creating sandbox with template: ${selectedTemplateId} (requested: ${event.data.modelConfig?.template || 'nextjs'})`);
-    const sandbox = await Sandbox.create(selectedTemplateId, {
-      apiKey,
-      domain,
-      timeoutMs: 60_000 * 20
-    });
-    const sandboxUrl = `https://3000-${sandbox.sandboxId}.yarntra.ai`;
-    // Start error monitoring immediately after sandbox creation
-    // const container = await initializeContainer();
-    const sandboxErrorService = container.get(SERVER_TYPES.SandboxErrorService);
-    console.log(`Starting immediate error monitoring for sandbox ${sandbox.sandboxId}`);
-    await sandboxErrorService.startErrorMonitoring(event.data.projectId, sandbox.sandboxId, sandboxUrl);
-    return {
-      sandboxId: sandbox.sandboxId,
-      sandboxUrl
-    };
-  });
-  // Only fetch previous messages if we don't have active fragment files
-  const previousMessages = event.data.activeFragmentFiles ? [] // Skip fetching previous messages when we have active fragment files
-  : await step.run('get-previous-messages', async () => {
-    const postService = container.getNamed(SERVER_TYPES.PostService, TaggedType.MICROSERVICE);
-    const result = await postService.getPreviousMessagesByProjectId(event.data.projectId, 5);
-    // Handle error case - return empty array if getPreviousMessagesByProjectId returns an Error
-    if (result instanceof Error) {
-      console.warn('Failed to get previous messages:', result.message);
-      return [];
-    }
-    return result;
-  });
-  const state = createState({
-    summary: '',
-    files: event.data.activeFragmentFiles || {},
-    // Use active fragment files if provided
-    canvasLayers: []
-  }, {
-    messages: previousMessages
-  });
-  // Get model configuration from event data
-  const {
-    modelConfig
-  } = event.data;
-  console.log('Model configuration received:', JSON.stringify(modelConfig, null, 2));
-  // Create a new agent with the template-specific coding prompt
-  const selectedCodingPrompt = getCodingPrompt(event.data.modelConfig);
-  console.log(`Using coding prompt for template: ${event.data.modelConfig?.template || 'nextjs'}`);
-  const codeAgent = createAgent({
-    name: 'code-agent',
-    description: 'An expert coding agent for page creation',
-    system: selectedCodingPrompt,
-    model: createModelInstance(modelConfig),
-    tools: [createTool({
-      name: 'terminal',
-      description: 'Use the terminal to run commands',
-      parameters: z.object({
-        command: z.string()
-      }),
-      handler: async ({
-        command
-      }, {
-        step
-      }) => await step?.run('terminal', async () => {
-        try {
-          const sandbox = await getSandbox(sandboxId);
-          const result = await sandbox.commands.run(command);
-          return result.stdout;
-        } catch (e) {
-          return `Command failed: ${e}`;
-        }
-      })
-    }), createTool({
-      name: 'createOrUpdateFiles',
-      description: 'Create or update files in the sandbox',
-      parameters: z.object({
-        files: z.union([z.array(z.object({
-          path: z.string(),
-          content: z.string()
-        })), z.string() // Accept JSON string as fallback
-        ])
-      }),
-      // handler: async ({ files }, { step, network }: Tool.Options<AgentState>) => {
-      handler: async ({
-        files
-      }, {
-        step,
-        network
-      }) => {
-        const newFiles = await step?.run('createOrUpdateFiles', async () => {
-          try {
-            console.log('createOrUpdateFiles - Raw files parameter type:', typeof files);
-            console.log('createOrUpdateFiles - Raw files parameter:', `${JSON.stringify(files).substring(0, 200)}...`);
-            // Parse files if it's a JSON string (fallback for AI model behavior)
-            let parsedFiles;
-            if (typeof files === 'string') {
-              try {
-                // First try standard JSON parsing
-                parsedFiles = JSON.parse(files);
-                console.log('createOrUpdateFiles - Successfully parsed files from JSON string');
-              } catch (parseError) {
-                console.log('createOrUpdateFiles - Standard JSON parse failed, trying template literal fix');
-                try {
-                  // AI is using template literals in JSON - need more sophisticated parsing
-                  console.log('createOrUpdateFiles - Attempting to fix template literals in JSON');
-                  // Try to evaluate the string as JavaScript to handle template literals
-                  // This is safe because we're in a sandboxed environment and only parsing our own AI's output
-                  const evalString = `(${files})`;
-                  console.log('createOrUpdateFiles - Evaluating as JavaScript array');
-                  parsedFiles = eval(evalString);
-                  console.log('createOrUpdateFiles - Successfully evaluated template literals');
-                } catch (secondError) {
-                  console.error('createOrUpdateFiles - Both parsing attempts failed:');
-                  console.error('Original error:', parseError.message);
-                  console.error('Template literal fix error:', secondError.message);
-                  console.error('Raw string (first 500 chars):', files.substring(0, 500));
-                  return `Error: Failed to parse files JSON - ${parseError.message}`;
-                }
-              }
-            } else if (Array.isArray(files)) {
-              parsedFiles = files;
-              console.log('createOrUpdateFiles - Using files array directly');
-            } else {
-              console.error('createOrUpdateFiles - Files parameter is neither string nor array:', typeof files);
-              return `Error: Files parameter must be an array or JSON string, got ${typeof files}`;
-            }
-            // Validate that parsedFiles is an array
-            if (!Array.isArray(parsedFiles)) {
-              console.error('createOrUpdateFiles - Parsed files is not an array:', parsedFiles);
-              return `Error: Files must be an array after parsing, got ${typeof parsedFiles}`;
-            }
-            console.log(`createOrUpdateFiles - Processing ${parsedFiles.length} files`);
-            const updatedFiles = network.state.data.files || {};
-            const sandbox = await getSandbox(sandboxId);
-            for (const file of parsedFiles) {
-              if (!file.path || file.content === undefined) {
-                console.error('createOrUpdateFiles - Invalid file object (missing path or content):', file);
-                continue;
-              }
-              console.log(`createOrUpdateFiles - Writing file: ${file.path}`);
-              await sandbox.files.write(file.path, file.content);
-              updatedFiles[file.path] = file.content;
-            }
-            console.log(`createOrUpdateFiles - Successfully updated ${parsedFiles.length} files`);
-            return updatedFiles;
-          } catch (e) {
-            console.error('createOrUpdateFiles - Error:', e);
-            console.error('createOrUpdateFiles - Error stack:', e?.stack);
-            return `Error: ${e}`;
-          }
-        });
-        if (typeof newFiles === 'object' && !Array.isArray(newFiles) && typeof newFiles !== 'string') {
-          network.state.data.files = newFiles;
-        }
-      }
-    }), createTool({
-      name: 'readFiles',
-      description: 'Read files from the sandbox',
-      parameters: z.object({
-        files: z.array(z.string())
-      }),
-      handler: async ({
-        files
-      }, {
-        step
-      }) => await step?.run('readFiles', async () => {
-        try {
-          const sandbox = await getSandbox(sandboxId);
-          const contents = [];
-          for (const file of files) {
-            const content = await sandbox.files.read(file);
-            contents.push({
-              path: file,
-              content
-            });
-          }
-          return JSON.stringify(contents);
-        } catch (e) {
-          return `Error: ${e}`;
-        }
-      })
-    })],
-    lifecycle: {
-      onResponse: async ({
-        result,
-        network
-      }) => {
-        const lastAssistantMessageText = lastAssistantTextMessageContent(result);
-        if (lastAssistantMessageText && network) {
-          if (lastAssistantMessageText.includes('<task_summary>')) {
-            network.state.data.summary = lastAssistantMessageText;
-            // Extract canvas layers if present
-            const canvasLayersMatch = lastAssistantMessageText.match(/<canvas_layers>([\s\S]*?)<\/canvas_layers>/);
-            if (canvasLayersMatch) {
-              try {
-                const layersJson = canvasLayersMatch[1].trim();
-                network.state.data.canvasLayers = JSON.parse(layersJson);
-              } catch (error) {
-                console.error('Error parsing canvas layers:', error);
-                network.state.data.canvasLayers = null;
-              }
-            }
-          }
-        }
-        return result;
-      }
-    }
-  });
-  const network = createNetwork({
-    name: 'coding-agent-network',
-    agents: [codeAgent],
-    maxIter: 15,
-    defaultState: state,
-    router: async ({
-      network
-    }) => {
-      const {
-        summary
-      } = network.state.data;
-      if (summary) {
-        return;
-      }
-      return codeAgent;
-    }
-  });
-  // Prepare the enhanced input message that includes activeFragmentFiles context
-  let enhancedInput = event.data.value;
-  // If we have activeFragmentFiles, include them in the message to the AI
-  if (event.data.activeFragmentFiles && Object.keys(event.data.activeFragmentFiles).length > 0) {
-    console.log('📂 Including activeFragmentFiles context for AI agent:');
-    console.log('- File count:', Object.keys(event.data.activeFragmentFiles).length);
-    console.log('- Files:', Object.keys(event.data.activeFragmentFiles));
-    // Check if ViteVisualEditor exists and warn if it's missing for vite-react template
-    const hasViteVisualEditor = 'src/components/ViteVisualEditor.tsx' in event.data.activeFragmentFiles;
-    const isViteReact = event.data.modelConfig?.template === 'vite-react';
-    if (isViteReact && !hasViteVisualEditor) {
-      console.warn('⚠️ ViteVisualEditor.tsx missing from activeFragmentFiles for vite-react template');
-      console.warn('AI may create stub component instead of importing existing one');
-    }
-    enhancedInput = `${event.data.value}
-
-ACTIVE FRAGMENT FILES CONTEXT:
-The current sandbox contains the following files that you MUST include in your createOrUpdateFiles call:
-
-${Object.entries(event.data.activeFragmentFiles).map(([path, content]) => `FILE: ${path}\n${typeof content === 'string' ? content.substring(0, 500) + (content.length > 500 ? '...' : '') : '[Non-string content]'}`).join('\n\n')}
-
-CRITICAL INSTRUCTIONS FOR VISUAL CHANGES:
-- You MUST include ALL ${Object.keys(event.data.activeFragmentFiles).length} files from the active fragment files in your createOrUpdateFiles call
-- Apply the visual changes described above to the appropriate files
-- Preserve ALL existing files and their content except for the specific changes requested
-- Use the complete file context provided above as your current codebase state
-- DO NOT output only the changed file - output ALL files to rebuild the complete sandbox${isViteReact && !hasViteVisualEditor ? '\n- IMPORTANT: For vite-react template, you MUST import ViteVisualEditor from "./components/ViteVisualEditor" (it exists in the template), do NOT create a new component' : ''}`;
-  }
-  console.log('🤖 Running AI agent with enhanced input length:', enhancedInput.length);
-  const result = await network.run(enhancedInput, {
-    state
-  });
-  // Enhanced file validation with logging
-  const hasFiles = result.state.data.files && Object.keys(result.state.data.files).length > 0;
-  const hasSummary = result.state.data.summary && result.state.data.summary.trim().length > 0;
-  const outputFileCount = Object.keys(result.state.data.files || {}).length;
-  const inputFileCount = event.data.activeFragmentFiles ? Object.keys(event.data.activeFragmentFiles).length : 0;
-  console.log('Agent result validation:', {
-    hasFiles,
-    outputFileCount,
-    inputFileCount,
-    fileCountMatch: inputFileCount > 0 ? outputFileCount === inputFileCount : true,
-    hasSummary,
-    summaryLength: result.state.data.summary?.length || 0,
-    outputFiles: Object.keys(result.state.data.files || {}),
-    inputFiles: event.data.activeFragmentFiles ? Object.keys(event.data.activeFragmentFiles) : []
-  });
-  // Warning if file counts don't match for visual changes
-  if (event.data.activeFragmentFiles && inputFileCount > 0 && outputFileCount !== inputFileCount) {
-    console.warn(`⚠️ File count mismatch! Expected ${inputFileCount} files, got ${outputFileCount} files`);
-    console.warn('Missing files may cause incomplete sandbox rebuild');
-  }
-  const fragmentTitleGenerator = createAgent({
-    name: 'fragment-title-generator',
-    description: 'A fragment title generator',
-    system: FRAGMENT_TITLE_PROMPT,
-    model: createModelInstance(modelConfig)
-  });
-  const responseGenerator = createAgent({
-    name: 'response-generator',
-    description: 'A response generator',
-    system: RESPONSE_PROMPT,
-    model: createModelInstance(modelConfig)
-  });
-  // Run generators in parallel outside of steps (like lovable-clone)
-  const {
-    output: fragmentTitleOutput
-  } = await fragmentTitleGenerator.run(result.state.data.summary || 'Generated Page');
-  const {
-    output: responseOutput
-  } = await responseGenerator.run(result.state.data.summary || 'Code generated successfully');
-  const agentError = !result.state.data.summary || Object.keys(result.state.data.files || {}).length === 0;
-  // sandboxUrl is already available from the previous step
-  // Save to database using handler
-  const messageData = await step.run('save-result', async () => {
-    const postService = container.getNamed(SERVER_TYPES.PostService, TaggedType.MICROSERVICE);
-    // Normalize template name for database validation
-    const normalizedModelConfig = {
-      ...event.data.modelConfig,
-      template: normalizeTemplateName(event.data.modelConfig?.template)
-    };
-    return await postService.saveCodeAgentResult({
-      value: event.data.value,
-      projectId: event.data.projectId,
-      messageId: event.data.messageId,
-      owner: event.data.owner,
-      orgName: event.data.orgName,
-      modelConfig: normalizedModelConfig
-    }, sandboxUrl, parseAgentOutput(fragmentTitleOutput), parseAgentOutput(responseOutput), result.state.data.files || {}, result.state.data.summary || '', agentError, result.state.data.canvasLayers);
-  });
-  // Publish subscription update for real-time client updates
-  await step.run('publish-subscription-update', async () => {
-    // const responseData = {
-    //     projectId: event.data.projectId,
-    //     sandboxId: sandboxId,
-    //     sandboxUrl: sandboxUrl,
-    //     url: sandboxUrl, // Keep both for compatibility
-    //     title: parseAgentOutput(fragmentTitleOutput) || 'Generated Page',
-    //     files: result.state.data.files,
-    //     summary: result.state.data.summary,
-    //     isError: agentError,
-    //     messageId: agentError ? null : (messageData as any).id,
-    //     canvasLayers: result.state.data.canvasLayers,
-    //     template: normalizeTemplateName(event.data.modelConfig?.template),
-    //     timestamp: new Date().toISOString(),
-    // };
-    const pubsub = container.get('PubSub');
-    // const post = event.data.post;
-    // const postData = {
-    //     ...messageData,
-    //     props: {
-    //         ...messageData.props,
-    //         fragment: responseData,
-    //     },
-    // };
-    console.log('=== Publish to subscription Post Data:', JSON.stringify(messageData, null, 2));
-    pubsub.publish(`POST_CREATED.${event.data.projectId}`, messageData);
-  });
-  // Error monitoring was already started immediately after sandbox creation
-  // No need to start it again here
-  return {
-    projectId: event.data.projectId,
-    sandboxId: sandboxId,
-    sandboxUrl: sandboxUrl,
-    url: sandboxUrl,
-    // Keep both for compatibility
-    title: parseAgentOutput(fragmentTitleOutput) || 'Generated Page',
-    files: result.state.data.files,
-    summary: result.state.data.summary,
-    isError: agentError,
-    canvasLayers: result.state.data.canvasLayers,
-    template: normalizeTemplateName(event.data.modelConfig?.template),
-    timestamp: new Date().toISOString()
-  };
-});
-const generateAIResponseWithSandbox = (inngest, container) => inngest.createFunction({
-  id: 'generate-ai-response-with-sandbox'
-}, {
-  event: 'ai.response.generate'
-}, async ({
-  event,
-  step
-}) => {
-  console.log('=== AI Response Generation with Sandbox FUNCTION STARTED ===');
-  console.log('Event data:', JSON.stringify(event.data, null, 2));
-  const {
-    projectId,
-    post,
-    modelConfig
-  } = event.data || {};
-  const message = post.message;
-  // Validate required parameters
-  if (!projectId || !message) {
-    throw new Error('projectId and message are required');
-  }
-  // Create e2b sandbox
-  const sandbox = await step.run('create-sandbox', async () => {
-    try {
-      const selectedTemplateId = getTemplateId(modelConfig);
-      console.log(`Creating sandbox with template: ${selectedTemplateId} (requested: ${modelConfig?.template || 'vite-react'})`);
-      const sandbox = await Sandbox.create(selectedTemplateId, {
-        apiKey,
-        domain,
-        timeoutMs: 60_000 * 20 // 20 minutes timeout
-      });
-      return sandbox;
-    } catch (error) {
-      console.error('Failed to create sandbox:', error);
-      throw new Error(`Failed to create sandbox: ${error.message}`);
-    }
-  });
-  // Create the appropriate coding prompt based on framework
-  let codingPrompt = CODING_PROMPT;
-  if (modelConfig?.template === 'vue') {
-    codingPrompt = VUE_CODING_PROMPT;
-  } else if (modelConfig?.template === 'vite-react') {
-    codingPrompt = VITE_REACT_CODING_PROMPT;
-  }
-  // Create agent with sandbox tools (use modelConfig model if provided)
-  const agent = createAgent({
-    name: 'CodeGenerator',
-    system: codingPrompt,
-    model: createModelInstance(modelConfig?.modelConfig || modelConfig),
-    tools: [createTool({
-      name: 'createOrUpdateFiles',
-      description: 'Create or update files in the sandbox',
-      parameters: z.object({
-        files: z.array(z.object({
-          path: z.string(),
-          content: z.string()
-        }))
-      }),
-      handler: async ({
-        files
-      }) => {
-        try {
-          await sandbox.files.write(files);
-          return {
-            success: true,
-            message: `Updated ${files.length} files`
-          };
-        } catch (error) {
-          return {
-            success: false,
-            error: error.message
-          };
-        }
-      }
-    }), createTool({
-      name: 'readFiles',
-      description: 'Read files from the sandbox',
-      parameters: z.object({
-        paths: z.array(z.string())
-      }),
-      handler: async ({
-        paths
-      }) => {
-        try {
-          const files = await Promise.all(paths.map(async path => {
-            try {
-              const content = await sandbox.files.read(path);
-              return {
-                path,
-                content,
-                exists: true
-              };
-            } catch (error) {
-              return {
-                path,
-                content: '',
-                exists: false,
-                error: error.message
-              };
-            }
-          }));
-          return {
-            success: true,
-            files
-          };
-        } catch (error) {
-          return {
-            success: false,
-            error: error.message
-          };
-        }
-      }
-    }), createTool({
-      name: 'terminal',
-      description: 'Execute terminal commands in the sandbox',
-      parameters: z.object({
-        command: z.string()
-      }),
-      handler: async ({
-        command
-      }) => {
-        try {
-          const result = await sandbox.process.start({
-            cmd: command
-          });
-          const output = await result.finished;
-          return {
-            success: true,
-            output: output.stdout || output.stderr,
-            exitCode: output.exitCode
-          };
-        } catch (error) {
-          return {
-            success: false,
-            error: error.message
-          };
-        }
-      }
-    })]
-  });
-  // Generate AI response using agent-kit (completely outside of step.run to avoid nesting)
-  let aiResponse;
-  try {
-    console.log('=== Starting AI response generation ===');
-    console.log('Message:', message);
-    // Generate response
-    const result = await agent.run(message);
-    // Parse the response to extract task summary and canvas layers
-    const responseContent = lastAssistantTextMessageContent(result);
-    console.log('=== AI Response Content ===');
-    console.log('Response Content:', responseContent);
-    const taskSummary = responseContent?.match(/<task_summary>([\s\S]*?)<\/task_summary>/)?.[1]?.trim();
-    const canvasLayersMatch = responseContent?.match(/<canvas_layers>([\s\S]*?)<\/canvas_layers>/)?.[1];
-    let canvasLayers = null;
-    if (canvasLayersMatch) {
-      try {
-        canvasLayers = JSON.parse(canvasLayersMatch.trim());
-      } catch (error) {
-        console.error('Failed to parse canvas layers:', error);
-      }
-    }
-    aiResponse = {
-      success: true,
-      response: responseContent,
-      taskSummary,
-      canvasLayers,
-      agentResult: result
-    };
-    console.log('=== AI Response Object ===');
-    console.log('AI Response:', JSON.stringify(aiResponse, null, 2));
-  } catch (error) {
-    console.error('AI response generation failed:', error);
-    aiResponse = {
-      success: false,
-      error: error.message,
-      response: null,
-      taskSummary: null,
-      canvasLayers: null
-    };
-  }
-  // Generate sandbox URL
-  const sandboxUrl = await step.run('generate-sandbox-url', async () => {
-    try {
-      // Your domain pattern: https://3000-<sandboxId>.yarntra.ai
-      const url = `https://3000-${sandbox.sandboxId}.yarntra.ai`;
-      console.log(`Generated sandbox URL: ${url}`);
-      return url;
-    } catch (error) {
-      console.error('Failed to generate sandbox URL:', error);
-      throw new Error(`Failed to generate sandbox URL: ${error.message}`);
-    }
-  });
-  console.log('sandboxUrl', sandboxUrl);
-  // Publish to subscription
-  await step.run('publish-to-subscription', async () => {
-    try {
-      const pubsub = container.get('PubSub');
-      const responseData = {
-        projectId,
-        sandboxId: sandbox.sandboxId,
-        sandboxUrl,
-        url: sandboxUrl,
-        // Keep both for compatibility
-        aiResponse: aiResponse.success ? aiResponse.response : null,
-        taskSummary: aiResponse.success ? aiResponse.taskSummary : null,
-        canvasLayers: aiResponse.success ? aiResponse.canvasLayers : null,
-        error: aiResponse.success ? null : aiResponse.error,
-        template: normalizeTemplateName(modelConfig?.template || 'vite-react'),
-        timestamp: new Date().toISOString()
-      };
-      console.log('=== Response Data ===');
-      console.log('Response Data:', JSON.stringify(responseData, null, 2));
-      console.log('AI Response Success:', aiResponse.success);
-      // console.log('AI Response Content:', aiResponse.response);
-      // pubsub.publish(`AI_RESPONSE_GENERATED.${projectId}`, responseData);
-      const postData = {
-        ...post,
-        props: {
-          ...post.props,
-          generatedResponse: responseData
-        }
-      };
-      console.log('=== Publish to subscription Post Data:', JSON.stringify(postData, null, 2));
-      pubsub.publish(`POST_CREATED.${projectId}`, postData);
-      return responseData;
-    } catch (error) {
-      console.error('Failed to publish to subscription:', error);
-      throw new Error(`Failed to publish to subscription: ${error.message}`);
-    }
-  });
-  return {
-    projectId,
-    sandboxId: sandbox.sandboxId,
-    sandboxUrl,
-    url: sandboxUrl,
-    // Keep both for compatibility
-    aiResponse: aiResponse.success ? aiResponse.response : null,
-    taskSummary: aiResponse.success ? aiResponse.taskSummary : null,
-    canvasLayers: aiResponse.success ? aiResponse.canvasLayers : null,
-    error: aiResponse.success ? null : aiResponse.error,
-    template: normalizeTemplateName(modelConfig?.template || 'vite-react'),
-    timestamp: new Date().toISOString()
-  };
-});
 const generateAiCodeFunction = (inngest, container) => inngest.createFunction({
-  id: 'ai-code-agent'
+  id: WorkflowNamespace.MESSENGER_PLATFORM_GENERATE_AI_CODE_FUNCTION
 }, {
-  event: 'ai-code-agent/run-code-generation'
+  event: WorkflowNamespace.MESSENGER_PLATFORM_GENERATE_AI_CODE_EVENT
 }, async ({
   event,
   step
@@ -890,7 +204,6 @@ const generateAiCodeFunction = (inngest, container) => inngest.createFunction({
   } = event.data || {};
   const postService = container.getNamed(SERVER_TYPES.PostService, TaggedType.MICROSERVICE);
   const post = await postService.get(messageId);
-  console.log('ai-event-post', JSON.stringify(post, null, 2));
   if (!post) {
     throw new Error('Post not found');
   }
@@ -919,7 +232,6 @@ const generateAiCodeFunction = (inngest, container) => inngest.createFunction({
   const previousMessages = event.data.activeFragmentFiles ? [] // Skip fetching previous messages when we have active fragment files
   : await step.run('get-previous-messages', async () => {
     const result = await postService.getPreviousMessagesByProjectId(post.props.projectId, 5);
-    console.log('previousMessages', JSON.stringify(result, null, 2));
     // Handle error case - return empty array if getPreviousMessagesByProjectId returns an Error
     if (result instanceof Error) {
       console.warn('Failed to get previous messages:', result.message);
@@ -1119,21 +431,45 @@ const generateAiCodeFunction = (inngest, container) => inngest.createFunction({
   // If we have activeFragmentFiles, include them in the message to the AI
   if (event.data.activeFragmentFiles && Object.keys(event.data.activeFragmentFiles).length > 0) {
     // Check if ViteVisualEditor exists and warn if it's missing for vite-react template
-    const hasViteVisualEditor = 'src/components/ViteVisualEditor.tsx' in event.data.activeFragmentFiles;
-    const isViteReact = modelConfig?.template === 'vite-react';
+    'src/components/ViteVisualEditor.tsx' in event.data.activeFragmentFiles;
+    modelConfig?.template === 'vite-react';
     enhancedInput = `${post.message}
                 ACTIVE FRAGMENT FILES CONTEXT:
                 The current sandbox contains the following files that you MUST include in your createOrUpdateFiles call:
                 
-                ${Object.entries(event.data.activeFragmentFiles).map(([path, content]) => `FILE: ${path}\n${typeof content === 'string' ? content.substring(0, 500) + (content.length > 500 ? '...' : '') : '[Non-string content]'}`).join('\n\n')}
-    
-                CRITICAL INSTRUCTIONS FOR VISUAL CHANGES:
-                - You MUST include ALL ${Object.keys(event.data.activeFragmentFiles).length} files from the active fragment files in your createOrUpdateFiles call
-                - Apply the visual changes described above to the appropriate files
-                - Preserve ALL existing files and their content except for the specific changes requested
-                - Use the complete file context provided above as your current codebase state
-                - DO NOT output only the changed file - output ALL files to rebuild the complete sandbox${isViteReact && !hasViteVisualEditor ? '\n- IMPORTANT: For vite-react template, you MUST import ViteVisualEditor from "./components/ViteVisualEditor" (it exists in the template), do NOT create a new component' : ''}`;
+                ${Object.entries(event.data.activeFragmentFiles).map(([path, content]) => `FILE: ${path}\n${typeof content === 'string' ? content.substring(0, 500) + (content.length > 500 ? '...' : '') : '[Non-string content]'}`).join('\n\n')}`;
   }
+  // // If we have activeFragmentFiles, include them in the message to the AI
+  // if (event.data.activeFragmentFiles && Object.keys(event.data.activeFragmentFiles).length > 0) {
+  //     // Check if ViteVisualEditor exists and warn if it's missing for vite-react template
+  //     const hasViteVisualEditor = 'src/components/ViteVisualEditor.tsx' in event.data.activeFragmentFiles;
+  //     const isViteReact = modelConfig?.template === 'vite-react';
+  //     enhancedInput = `${post.message}
+  //     ACTIVE FRAGMENT FILES CONTEXT:
+  //     The current sandbox contains the following files that you MUST include in your createOrUpdateFiles call:
+  //     ${Object.entries(event.data.activeFragmentFiles)
+  //         .map(
+  //             ([path, content]) =>
+  //                 `FILE: ${path}\n${
+  //                     typeof content === 'string'
+  //                         ? content.substring(0, 500) + (content.length > 500 ? '...' : '')
+  //                         : '[Non-string content]'
+  //                 }`,
+  //         )
+  //         .join('\n\n')}
+  //     CRITICAL INSTRUCTIONS FOR VISUAL CHANGES:
+  //     - You MUST include ALL ${
+  //         Object.keys(event.data.activeFragmentFiles).length
+  //     } files from the active fragment files in your createOrUpdateFiles call
+  //     - Apply the visual changes described above to the appropriate files
+  //     - Preserve ALL existing files and their content except for the specific changes requested
+  //     - Use the complete file context provided above as your current codebase state
+  //     - DO NOT output only the changed file - output ALL files to rebuild the complete sandbox${
+  //         isViteReact && !hasViteVisualEditor
+  //             ? '\n- IMPORTANT: For vite-react template, you MUST import ViteVisualEditor from "./components/ViteVisualEditor" (it exists in the template), do NOT create a new component'
+  //             : ''
+  //     }`;
+  // }
   const result = await network.run(enhancedInput, {
     state
   });
@@ -1188,7 +524,7 @@ const generateAiCodeFunction = (inngest, container) => inngest.createFunction({
         author: post.editedBy,
         files: [],
         props: {
-          role: AiAgentMessageRole.ASSISTANT,
+          role: AiAgentMessageRole.Assistant,
           projectId: post.props.projectId,
           template: modelConfig?.template || 'vite-react',
           sendNotificationWithProjectId: true,
@@ -1198,7 +534,7 @@ const generateAiCodeFunction = (inngest, container) => inngest.createFunction({
             files: result.state.data.files || [],
             summary: result.state.data.summary || '',
             canvasLayers: result.state.data.canvasLayers || [],
-            type: AiAgentMessageType.ERROR,
+            type: AiAgentMessageType.Error,
             messageId: messageId,
             isError: agentError
           }
@@ -1213,7 +549,7 @@ const generateAiCodeFunction = (inngest, container) => inngest.createFunction({
       author: post.editedBy,
       files: [],
       props: {
-        role: AiAgentMessageRole.ASSISTANT,
+        role: AiAgentMessageRole.Assistant,
         projectId: post.props.projectId,
         template: modelConfig?.template || 'vite-react',
         sendNotificationWithProjectId: true,
@@ -1223,7 +559,7 @@ const generateAiCodeFunction = (inngest, container) => inngest.createFunction({
           files: result.state.data.files || [],
           summary: result.state.data.summary || '',
           canvasLayers: result.state.data.canvasLayers || [],
-          type: AiAgentMessageType.RESULT,
+          type: AiAgentMessageType.Result,
           messageId: messageId,
           isError: agentError
         }
@@ -1242,9 +578,9 @@ const generateAiCodeFunction = (inngest, container) => inngest.createFunction({
 });
 // Sandbox recreation function - recreates sandbox with existing files from fragment
 const recreateSandboxUrlFunction = (inngest, container) => inngest.createFunction({
-  id: 'recreate-sandbox-url-function'
+  id: WorkflowNamespace.MESSENGER_PLATFORM_RECREATE_SANDBOX_FUNCTION
 }, {
-  event: 'recreate-sandbox-url'
+  event: WorkflowNamespace.MESSENGER_PLATFORM_RECREATE_SANDBOX_EVENT
 }, async ({
   event,
   step
@@ -1319,67 +655,4 @@ const recreateSandboxUrlFunction = (inngest, container) => inngest.createFunctio
     newSandboxUrl: sandboxUrl,
     newSandboxId: sandboxId
   };
-});
-const regenerateAiCodeFunction = (inngest, container) => inngest.createFunction({
-  id: 'regenerate-ai-code-agent'
-}, {
-  event: 'regenerate-ai-code'
-}, async ({
-  event,
-  step
-}) => {
-  console.log('=== REGENERATE AI CODE AGENT FUNCTION STARTED ===');
-  console.log('Event data:', JSON.stringify(event.data, null, 2));
-  const {
-    messageId,
-    modelConfig
-  } = event.data || {};
-  const postService = container.getNamed(SERVER_TYPES.PostService, TaggedType.MICROSERVICE);
-  const post = await postService.get(messageId);
-  if (!post) {
-    throw new Error('Post not found');
-  }
-  const {
-    sandboxId,
-    sandboxUrl
-  } = await step.run('create-sandbox-and-start-monitoring', async () => {
-    const selectedTemplateId = getTemplateId(modelConfig);
-    const sandbox = await Sandbox.create(selectedTemplateId, {
-      apiKey,
-      domain,
-      timeoutMs: 60_000 * 20
-    });
-    const sandboxUrl = `https://3000-${sandbox.sandboxId}.yarntra.ai`;
-    // Start error monitoring immediately after sandbox creation
-    // const container = await initializeContainer();
-    // const sandboxErrorService = container.get<ISandboxErrorService>(SERVER_TYPES.SandboxErrorService);
-    // console.log(`Starting immediate error monitoring for sandbox ${sandbox.sandboxId}`);
-    // await sandboxErrorService.startErrorMonitoring(post.props.projectId, sandbox.sandboxId, sandboxUrl,messageId);
-    return {
-      sandboxId: sandbox.sandboxId,
-      sandboxUrl
-    };
-  });
-  // Save to database using handler
-  const messageData = await step.run('save-ai-code-result', async () => {
-    return await postService.update(messageId, {
-      props: {
-        ...post.props,
-        sendNotificationWithProjectId: false,
-        fragment: {
-          sandboxUrl: sandboxUrl
-          // files: result.state.data.files || [],
-        }
-      }
-    });
-  });
-  // Publish subscription update for real-time client updates
-  await step.run('publish-subscription-ai-code-result', async () => {
-    const pubsub = container.get('PubSub');
-    console.log('=== Publish to subscription Post Data:', JSON.stringify(messageData, null, 2));
-    pubsub.publish(`POST_CREATED.${post.props.projectId}`, messageData);
-  });
-  // Error monitoring was already started immediately after sandbox creation
-  // No need to start it again here
-  return messageData;
-});export{codeAgentFunction,createChannelWithProjectId,generateAIResponseWithSandbox,generateAiCodeFunction,recreateSandboxUrlFunction,regenerateAiCodeFunction,sendMessageHandler};//# sourceMappingURL=functions.js.map
+});export{createChannelWithProjectId,generateAiCodeFunction,recreateSandboxUrlFunction,sendMessageHandler};//# sourceMappingURL=functions.js.map