@messenger-box/platform-server 10.0.3-alpha.72 → 10.0.3-alpha.74

package/lib/inngest/functions.js

@@ -0,0 +1,1385 @@
+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
+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
+const domain = config.E2B_DOMAIN;
+const apiKey = config.E2B_API_KEY;
+// Helper function to get the correct coding prompt based on template
+const getCodingPrompt = modelConfig => {
+  if (modelConfig?.template === 'vue') {
+    return VUE_CODING_PROMPT;
+  }
+  if (modelConfig?.template === 'vite-react') {
+    return VITE_REACT_CODING_PROMPT;
+  }
+  return CODING_PROMPT; // Default Next.js prompt
+};
+// Helper function to get the correct template ID based on modal config
+const getTemplateId = modelConfig => {
+  if (modelConfig?.template === 'vue' && vueTemplateID) {
+    return vueTemplateID;
+  }
+  if (modelConfig?.template === 'vite-react' && viteReactTemplateID) {
+    return viteReactTemplateID;
+  }
+  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) {
+    // Default to Gemini if nothing provided
+    return gemini({
+      model: 'gemini-2.5-flash'
+    });
+  }
+  switch (modelConfig.provider) {
+    case 'openai':
+      return openai({
+        model: modelConfig.model || 'gpt-4o',
+        apiKey: modelConfig.apiKey,
+        defaultParameters: {
+          temperature: 0.7
+        }
+      });
+    case 'anthropic':
+      return anthropic({
+        model: modelConfig.model || 'claude-3-5-sonnet-latest',
+        apiKey: modelConfig.apiKey,
+        defaultParameters: {
+          max_tokens: 4096,
+          temperature: 0.7
+        }
+      });
+    case 'gemini':
+    default:
+      return gemini({
+        model: modelConfig.model || 'gemini-2.5-flash',
+        apiKey: modelConfig.apiKey
+      });
+  }
+};
+const createChannelWithProjectId = (inngest, container) => inngest.createFunction({
+  id: 'create-channel-with-projectid'
+}, {
+  event: 'channel-with-project-id.create'
+}, async ({
+  event,
+  step
+}) => {
+  console.log('=== Project create FUNCTION STARTED ===');
+  console.log('Event data:', JSON.stringify(event.data, null, 2));
+  const {
+    projectId,
+    channelInput
+  } = event.data || {};
+  const {
+    content,
+    createdBy,
+    orgName,
+    organization,
+    team,
+    files,
+    notificationParams,
+    modelConfig,
+    accountId,
+    teamId,
+    orgId
+  } = channelInput;
+  // Validate that projectId is provided
+  if (!projectId) {
+    throw new Error('Project ID is required but was not provided');
+  }
+  // Create channel in database with template immutability logic
+  const channelData = await step.run('ensure-channel', async () => {
+    const channelService = container.getNamed(SERVER_TYPES.ChannelService, TaggedType.MICROSERVICE);
+    // If a channel already exists for this project, reuse it
+    const existingList = await channelService.getAll({
+      criteria: {
+        projectId,
+        type: RoomType.Aiassistant
+      }
+    });
+    const existing = Array.isArray(existingList) ? existingList[0] : null;
+    if (existing) {
+      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',
+      projectId,
+      _id: undefined
+    });
+    return await newChannel;
+  });
+  if (channelData) {
+    const channelId = channelData?.id?.toString?.() || channelData?._id?.toString?.() || '';
+    if (!channelId) {
+      throw new Error('Failed to resolve channel id for post creation');
+    }
+    await step.sendEvent('emit-send-message', {
+      name: 'channel.message.send',
+      data: {
+        channelId,
+        content,
+        createdBy,
+        files,
+        notificationParams,
+        projectId,
+        modelConfig,
+        accountId,
+        teamId,
+        orgId
+      }
+    });
+  }
+  return channelData;
+});
+const sendMessageHandler = (inngest, container) => inngest.createFunction({
+  id: 'channel-message-send'
+}, {
+  event: 'channel.message.send'
+}, async ({
+  event,
+  step
+}) => {
+  console.log('=== Send Message Handler FUNCTION STARTED ===');
+  console.log('=== Send Message Handler Event data:', JSON.stringify(event.data, null, 2));
+  const {
+    projectId,
+    channelId,
+    content,
+    createdBy,
+    files,
+    notificationParams,
+    modelConfig,
+    accountId,
+    teamId,
+    orgId
+  } = event.data || {};
+  if (!channelId || !content || !createdBy || !accountId) {
+    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,
+      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);
+  });
+  // 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'
+}, {
+  event: 'ai-code-agent/run-code-generation'
+}, async ({
+  event,
+  step
+}) => {
+  console.log('=== 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);
+  console.log('ai-event-post', JSON.stringify(post, null, 2));
+  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
+    };
+  });
+  // 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 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);
+      return [];
+    }
+    return result;
+  });
+  const state = createState({
+    summary: '',
+    files: event.data.activeFragmentFiles || {},
+    // Use active fragment files if provided
+    canvasLayers: []
+  }, {
+    messages: previousMessages
+  });
+  // Create a new agent with the template-specific coding prompt
+  const selectedCodingPrompt = getCodingPrompt(modelConfig);
+  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 = post.message;
+  // 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
+  });
+  // 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;
+  // Save to database using handler
+  const messageData = await step.run('save-ai-code-result', async () => {
+    if (agentError) {
+      return await postService.create({
+        channel: post.channel,
+        message: 'Something went wrong. Please try again.',
+        type: PostTypeEnum.Simple,
+        editedBy: post.editedBy,
+        author: post.editedBy,
+        files: [],
+        props: {
+          role: AiAgentMessageRole.ASSISTANT,
+          projectId: post.props.projectId,
+          template: modelConfig?.template || 'vite-react',
+          sendNotificationWithProjectId: true,
+          fragment: {
+            sandboxUrl: sandboxUrl,
+            title: parseAgentOutput(fragmentTitleOutput) || 'Generated Page',
+            files: result.state.data.files || [],
+            summary: result.state.data.summary || '',
+            canvasLayers: result.state.data.canvasLayers || [],
+            type: AiAgentMessageType.ERROR,
+            messageId: messageId,
+            isError: agentError
+          }
+        }
+      });
+    }
+    return await postService.create({
+      channel: post.channel,
+      message: parseAgentOutput(responseOutput) || 'Code generated successfully',
+      type: PostTypeEnum.Simple,
+      editedBy: post.editedBy,
+      author: post.editedBy,
+      files: [],
+      props: {
+        role: AiAgentMessageRole.ASSISTANT,
+        projectId: post.props.projectId,
+        template: modelConfig?.template || 'vite-react',
+        sendNotificationWithProjectId: true,
+        fragment: {
+          sandboxUrl: sandboxUrl,
+          title: parseAgentOutput(fragmentTitleOutput) || 'Generated Page',
+          files: result.state.data.files || [],
+          summary: result.state.data.summary || '',
+          canvasLayers: result.state.data.canvasLayers || [],
+          type: AiAgentMessageType.RESULT,
+          messageId: messageId,
+          isError: agentError
+        }
+      }
+    });
+  });
+  // Publish subscription update for real-time client updates
+  // await step.run('publish-subscription-ai-code-result', async () => {
+  //     const pubsub = container.get<PubSub>('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;
+});
+// Sandbox recreation function - recreates sandbox with existing files from fragment
+const recreateSandboxUrlFunction = (inngest, container) => inngest.createFunction({
+  id: 'recreate-sandbox-url-function'
+}, {
+  event: 'recreate-sandbox-url'
+}, async ({
+  event,
+  step
+}) => {
+  console.log('=== RECREATE SANDBOX FUNCTION STARTED ===');
+  console.log('Event data:', JSON.stringify(event.data, null, 2));
+  const {
+    projectId,
+    messageId
+  } = event.data;
+  // Fetch the fragment with existing files
+  const messageData = await step.run('fetch-message', async () => {
+    const postService = container.getNamed(SERVER_TYPES.PostService, TaggedType.MICROSERVICE);
+    return await postService.get(messageId);
+  });
+  if (!messageData || !messageData?.props?.fragment?.files) {
+    throw new Error(`Message ${messageId} not found or has no files`);
+  }
+  // Create new sandbox with existing files using the stored template
+  const {
+    sandboxId,
+    sandboxUrl
+  } = await step.run('create-new-sandbox', async () => {
+    // Get the correct template ID based on the stored template
+    const selectedTemplateId = getTemplateId({
+      template: messageData.props.template
+    });
+    console.log(`Recreating sandbox with template: ${selectedTemplateId} (stored: ${messageData.props.template || 'react-vite'})`);
+    const sandbox = await Sandbox.create(selectedTemplateId, {
+      apiKey,
+      domain
+    });
+    const sandboxUrl = `https://3000-${sandbox.sandboxId}.yarntra.ai`;
+    console.log(`Created new sandbox ${sandbox.sandboxId} for project ${projectId}`);
+    // Write all existing files to the new sandbox
+    for (const [filePath, fileContent] of Object.entries(messageData.props.fragment.files)) {
+      await sandbox.files.write(filePath, fileContent);
+      console.log(`Wrote file ${filePath} to new sandbox`);
+    }
+    // Start error monitoring for the new sandbox
+    const sandboxErrorService = container.get(SERVER_TYPES.SandboxErrorService);
+    console.log(`Starting error monitoring for recreated sandbox ${sandbox.sandboxId}`);
+    await sandboxErrorService.startErrorMonitoring(projectId, sandbox.sandboxId, sandboxUrl, messageId);
+    return {
+      sandboxId: sandbox.sandboxId,
+      sandboxUrl
+    };
+  });
+  // Update the fragment with new sandbox URL
+  const updatedMessage = await step.run('update-message', async () => {
+    const postService = container.getNamed(SERVER_TYPES.PostService, TaggedType.MICROSERVICE);
+    return await postService.update(messageId, {
+      props: {
+        ...messageData.props,
+        fragment: {
+          ...messageData.props.fragment,
+          sandboxUrl: sandboxUrl
+        }
+      }
+    });
+  });
+  // Publish update to notify clients of the new sandbox URL for the same fragment
+  await step.run('notify-sandbox-recreation', async () => {
+    const pubsub = container.get('PubSub');
+    // Publish a fragment update instead of a project update
+    await pubsub.publish(`POST_UPDATED.${projectId}`, updatedMessage);
+  });
+  return {
+    success: true,
+    projectId,
+    messageId,
+    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