updated api & template tasks

Author: Gerome-Elassaad

app/api/ai/enhance-text/route.ts

@@ -130,11 +130,10 @@ export async function POST(req: NextRequest) {
       )
     }
 
-    // Create model client
     let modelClient: LanguageModel
     try {
       console.log(`[Enhance Text API ${requestId}] Creating model client: ${defaultModel.providerId}/${defaultModel.id}`)
-      modelClient = getModelClient(defaultModel, {}) as LanguageModel
+      modelClient = await getModelClient(defaultModel, {}) as LanguageModel
     } catch (error: any) {
       logError("Model client creation failed", error, { requestId, provider: defaultModel.providerId, modelId: defaultModel.id })
       return NextResponse.json(
@@ -148,7 +147,6 @@ export async function POST(req: NextRequest) {
       )
     }
 
-    // Generate enhanced text using streamObject for compatibility
     try {
       console.log(`[Enhance Text API ${requestId}] Generating enhanced text`)
 
@@ -180,7 +178,6 @@ Make it more clear, engaging, and well-structured while keeping the same general
         temperature: 0.7,
       })
 
-      // Wait for the complete object
       const finalResult = await result.object
 
       console.log(`[Enhance Text API ${requestId}] Enhancement completed successfully`)

app/api/chat/route.ts

@@ -1,11 +1,10 @@
 import type { Duration } from "@/lib/duration"
 import type { LLMModel, LLMModelConfig } from "@/lib/models"
-import { getModelClient } from "@/lib/models"
+import { getModelClient } from "@/lib/models" // Assuming getModelClient is a named export
 import { toEnhancedPrompt } from "@/lib/enhanced-prompt"
 import ratelimit from "@/lib/ratelimit"
 import { fragmentSchema as schema } from "@/lib/schema"
-import type { TemplatesDataObject, TemplateId } from "@/lib/templates" // Import TemplateId
-import templatesDataFromFile from "@/lib/templates" // Import the actual templates data
+import type { TemplatesDataObject } from "@/lib/templates"
 import { ProjectAnalyzer, type ProjectStructure } from "@/lib/project-analyzer"
 import { streamObject, type LanguageModel, type CoreMessage } from "ai"
 import { logError, generateRequestId, validateRequestData } from "@/lib/debug"
@@ -47,7 +46,7 @@ export async function POST(req: Request) {
       messages,
       userID,
       teamID,
-      selectedTemplateId, // Changed from 'template' to 'selectedTemplateId'
+      template,
       model,
       config,
       uploadedFiles,
@@ -56,7 +55,7 @@ export async function POST(req: Request) {
       messages: CoreMessage[]
       userID: string
       teamID: string
-      selectedTemplateId: TemplateId // Type is now TemplateId (string)
+      template: TemplatesDataObject
       model: LLMModel
       config: LLMModelConfig
       uploadedFiles?: File[]
@@ -127,14 +126,12 @@ export async function POST(req: Request) {
       }
     } catch (error) {
       logError("Rate limiting check failed", error, { requestId })
-      // Continue without rate limiting if it fails
     }
 
-    // Create model client with enhanced error handling
     let modelClient: LanguageModel
     try {
       console.log(`[Chat API ${requestId}] Creating model client for: ${model.providerId}/${model.id}`)
-      modelClient = getModelClient(model, config) as LanguageModel
+      modelClient = await getModelClient(model, config) as LanguageModel
       console.log(`[Chat API ${requestId}] Model client created successfully`)
     } catch (error: any) {
       logError("Model client creation failed", error, { requestId, provider: model.providerId, modelId: model.id })
@@ -168,12 +165,10 @@ export async function POST(req: Request) {
     try {
       if (projectStructure && userPrompt) {
         console.log(`[Chat API ${requestId}] Generating enhanced prompt with project context`)
-        // Pass the full templatesDataFromFile to toEnhancedPrompt
-        systemPrompt = toEnhancedPrompt(templatesDataFromFile, userPrompt, projectStructure)
+        systemPrompt = toEnhancedPrompt(template, userPrompt, projectStructure)
       } else {
         console.log(`[Chat API ${requestId}] Using standard prompt generation`)
-        // Pass the full templatesDataFromFile to generateFallbackPrompt
-        systemPrompt = generateFallbackPrompt(templatesDataFromFile)
+        systemPrompt = generateFallbackPrompt(template)
       }
 
       console.log(`[Chat API ${requestId}] System prompt generated`)
@@ -193,10 +188,8 @@ export async function POST(req: Request) {
       )
     }
 
-    // Prepare model parameters from config
     const { model: _modelFromConfig, apiKey: _apiKeyFromConfig, ...providerSpecificConfig } = config
 
-    // Clean up undefined values from provider-specific config
     const cleanProviderSpecificConfig = Object.fromEntries(
       Object.entries(providerSpecificConfig).filter(([_, value]) => value !== undefined),
     )
@@ -306,20 +299,18 @@ export async function POST(req: Request) {
 }
 
 function generateFallbackPrompt(template: TemplatesDataObject): string {
+  const validTemplates = Object.entries(template)
+    .filter(([_, t]) => typeof t === 'object' && t !== null && 'instructions' in t && 'lib' in t)
+    .map(([id, t], index) => {
+      const templateObject = t as { instructions: string; file?: string | null; lib: string[]; port?: number | null };
+      return `${index + 1}. ${id}: "${templateObject.instructions}". File: ${templateObject.file || 'none'}. Dependencies: ${templateObject.lib.join(', ')}. Port: ${templateObject.port || 'none'}.`;
+    });
+
   return `You are an expert software engineer with deep knowledge of modern web development, programming languages, frameworks, and best practices.
 
 Generate production-ready code based on the user's requirements using the following templates:
 
-${Object.entries(template).map(([id, t], index) => {
-  const instructions = "instructions" in t
-    ? t.instructions
-    : (t.files as any).instructions;
-  const port = "port" in t
-    ? t.port
-    : (t.files as any).port;
-  const fileNames = Object.keys(t.files).join(', ');
-  return `${index + 1}. ${id}: "${instructions}". Files: ${fileNames || 'none'}. Dependencies: ${t.lib.join(', ')}. Port: ${port ?? 'none'}.`;
-}).join('\n')}
+${validTemplates.join('\n')}
 
 IMPORTANT GUIDELINES:
 - Write clean, maintainable, and well-documented code
@@ -332,4 +323,4 @@ IMPORTANT GUIDELINES:
 - Include proper security measures
 
 Generate complete, functional code that fulfills the user's request.`
-}
+}

app/api/index.ts

@@ -1,13 +1,49 @@
-import 'dotenv/config'
-import { Sandbox } from '@e2b/code-interpreter'
+import 'dotenv/config';
+import { Sandbox, SandboxOpts } from '@e2b/code-interpreter';
 
 async function main() {
-  const sbx = await Sandbox.create() // By default the sandbox is alive for 5 minutes
-  const execution = await sbx.runCode('print("hello world")') // Execute Python inside the sandbox
-  console.log(execution.logs)
+  let sbx: Sandbox | undefined = undefined;
 
-  const files = await sbx.files.list('/')
-  console.log(files)
+  try {
+    const sandboxOptions: SandboxOpts = { timeoutMs: 300000 };
+    sbx = await Sandbox.create(sandboxOptions);
+    console.log('Sandbox created successfully.');
+
+    const codeToRun = 'print("hello world")';
+    console.log(`Executing code: ${codeToRun}`);
+    const execution = await sbx.runCode(codeToRun); // Execute Python inside the sandbox
+
+    console.log('Execution logs:');
+    execution.logs.stdout.forEach(log => console.log(`[STDOUT] ${log}`));
+    execution.logs.stderr.forEach(log => console.error(`[STDERR] ${log}`));
+
+    if (execution.error) {
+      console.error('Execution error:', execution.error);
+    } else {
+      console.log('Execution results:', execution.results);
+    }
+
+    console.log('Listing files in /:');
+    const files = await sbx.files.list('/');
+    console.log(files);
+
+  } catch (error) {
+    console.error('An error occurred:', error);
+    // Depending on the application, you might want to exit or handle the error differently
+    // process.exit(1); 
+  } finally {
+    if (sbx) {
+      console.log('Closing preview...');
+      try {
+        await (sbx as any).close();
+        console.log('Sandbox closed successfully.');
+      } catch (closeError) { // Updated variable name
+        console.error('Error closing sandbox:', closeError); // Updated log message
+      }
+    }
+  }
 }
 
 main()
+  .then(() => console.log('Script finished.'))
+  .catch(error => console.error('Unhandled error in main:', error));