Update app.js

app.js

@@ -1,459 +1,499 @@
 // app.js
-// 导入所需的Node.js模块
-const http = require('http');
-const { v4: uuidv4 } = require('uuid');
+const express = require('express');
 const fetch = require('node-fetch');
+const app = express();
+const PORT = process.env.PORT || 7860;
 
-const JULEP_API_BASE_URL = "https://api.julep.ai/api";
-const PORT = process.env.PORT || 7860; // Hugging Face通常使用7860端口
-
-// 支持的模型列表
-const supportedModels = [
-  'mistral-large-2411', 'o1', 'text-embedding-3-large', 'vertex_ai/text-embedding-004',
-  'claude-3.5-haiku', 'cerebras/llama-4-scout-17b-16e-instruct', 'llama-3.1-8b',
-  'magnum-v4-72b', 'voyage-multilingual-2', 'claude-3-haiku', 'gpt-4o', 'BAAI/bge-m3',
-  'openrouter/meta-llama/llama-4-maverick', 'openrouter/meta-llama/llama-4-scout',
-  'claude-3.5-sonnet', 'hermes-3-llama-3.1-70b', 'claude-3.5-sonnet-20240620',
-  'qwen-2.5-72b-instruct', 'l3.3-euryale-70b', 'gpt-4o-mini', 'cerebras/llama-3.3-70b',
-  'o1-preview', 'gemini-1.5-pro-latest', 'l3.1-euryale-70b', 'claude-3-sonnet',
-  'Alibaba-NLP/gte-large-en-v1.5', 'openrouter/meta-llama/llama-4-scout:free',
-  'llama-3.1-70b', 'eva-qwen-2.5-72b', 'claude-3.5-sonnet-20241022', 'gemini-2.0-flash',
-  'deepseek-chat', 'o1-mini', 'eva-llama-3.33-70b', 'gemini-2.5-pro-preview-03-25',
-  'gemini-1.5-pro', 'gpt-4-turbo', 'openrouter/meta-llama/llama-4-maverick:free',
-  'o3-mini', 'claude-3.7-sonnet', 'voyage-3', 'cerebras/llama-3.1-8b', 'claude-3-opus'
+// Julep API Base URL (fixed)
+const JULEP_API_BASE = "https://api.julep.ai/api";
+
+// Hardcoded list of models (Agent IDs in this context)
+const HARDCODED_MODELS = [
+    'mistral-large-2411', 'o1', 'text-embedding-3-large', 'vertex_ai/text-embedding-004',
+    'claude-3.5-haiku', 'cerebras/llama-4-scout-17b-16e-instruct', 'llama-3.1-8b',
+    'magnum-v4-72b', 'voyage-multilingual-2', 'claude-3-haiku', 'gpt-4o',
+    'BAAI/bge-m3', 'openrouter/meta-llama/llama-4-maverick', 'openrouter/meta-llama/llama-4-scout',
+    'claude-3.5-sonnet', 'hermes-3-llama-3.1-70b', 'claude-3.5-sonnet-20240620',
+    'qwen-2.5-72b-instruct', 'l3.3-euryale-70b', 'gpt-4o-mini', 'cerebras/llama-3.3-70b',
+    'o1-preview', 'gemini-1.5-pro-latest', 'l3.1-euryale-70b', 'claude-3-sonnet',
+    'Alibaba-NLP/gte-large-en-v1.5', 'openrouter/meta-llama/llama-4-scout:free',
+    'llama-3.1-70b', 'eva-qwen-2.5-72b', 'claude-3.5-sonnet-20241022', 'gemini-2.0-flash',
+    'deepseek-chat', 'o1-mini', 'eva-llama-3.33-70b', 'gemini-2.5-pro-preview-03-25',
+    'gemini-1.5-pro', 'gpt-4-turbo', 'openrouter/meta-llama/llama-4-maverick:free',
+    'o3-mini', 'claude-3.7-sonnet', 'voyage-3', 'cerebras/llama-3.1-8b', 'claude-3-opus'
 ];
 
-// 处理/v1/models端点
-function listModelsHandler(res) {
-  const models = supportedModels.map(modelId => ({
-    id: modelId,
-    object: "model",
-    created: Math.floor(Date.now() / 1000),
-    owned_by: "julep-proxy",
-  }));
-
-  const responseBody = {
-    object: "list",
-    data: models,
-  };
-
-  res.writeHead(200, { 'Content-Type': 'application/json' });
-  res.end(JSON.stringify(responseBody));
-}
+// --- Helper Functions ---
+
+// Define acceptable log levels
+const LogLevels = {
+    DEBUG: 'debug',
+    INFO: 'info',
+    WARN: 'warn',
+    ERROR: 'error',
+    TRACE: 'trace'
+};
 
-// 将OpenAI格式转换为Julep格式
-function convertOpenaiToJulep(openaiPayload) {
-  // 处理system消息
-  let systemMessage = null;
-  let userMessages = [];
-  
-  // 分离system消息和其他消息
-  if (openaiPayload.messages && Array.isArray(openaiPayload.messages)) {
-    openaiPayload.messages.forEach(msg => {
-      if (msg.role === 'system') {
-        // 保存system消息，Julep可能有特殊处理方式
-        systemMessage = msg;
-      } else {
-        userMessages.push(msg);
-      }
-    });
-  }
-  
-  // 创建Julep格式的payload
-  const julepPayload = {
-    messages: userMessages.map(msg => ({
-      role: msg.role,
-      content: msg.content,
-      name: msg.name,
-      tool_call_id: msg.tool_call_id,
-      tool_calls: msg.tool_calls ? msg.tool_calls.map(tc => ({
-        type: tc.type,
-        function: tc.function ? {
-          name: tc.function.name,
-          arguments: tc.function.arguments
-        } : undefined,
-        integration: tc.integration,
-        system: tc.system,
-        api_call: tc.api_call,
-        computer_20241022: tc.computer_20241022,
-        text_editor_20241022: tc.text_editor_20241022,
-        bash_20241022: tc.bash_20241022,
-        id: tc.id,
-      })) : undefined,
-    })),
-    tools: openaiPayload.tools,
-    tool_choice: openaiPayload.tool_choice,
-    recall: openaiPayload.recall,
-    save: openaiPayload.save,
-    model: openaiPayload.model,
-    stream: openaiPayload.stream,
-    stop: openaiPayload.stop,
-    seed: openaiPayload.seed,
-    max_tokens: openaiPayload.max_tokens,
-    logit_bias: openaiPayload.logit_bias,
-    response_format: openaiPayload.response_format,
-    agent: openaiPayload.agent,
-    repetition_penalty: openaiPayload.repetition_penalty,
-    length_penalty: openaiPayload.length_penalty,
-    min_p: openaiPayload.min_p,
-    frequency_penalty: openaiPayload.frequency_penalty,
-    presence_penalty: openaiPayload.presence_penalty,
-    temperature: openaiPayload.temperature,
-    top_p: openaiPayload.top_p,
-  };
-  
-  // 如果有system消息，添加到Julep payload中
-  // Julep API可能使用system_prompt字段或其他方式处理system消息
-  if (systemMessage) {
-    julepPayload.system_prompt = systemMessage.content;
-  }
-
-  // 删除可能错误包含的session_id
-  delete julepPayload.session_id;
-
-  return julepPayload;
+function log(level, message, data = null) {
+    // Basic check if the console object has the method
+    if (typeof console[level] === 'function') {
+        console[level](`[${level.toUpperCase()}] ${new Date().toISOString()} - ${message}${data ? ':' : ''}`, data !== null ? JSON.stringify(data, null, 2) : '');
+    } else {
+        // Fallback for potentially missing methods like 'trace' in some environments
+        console.log(`[${level.toUpperCase()}] ${new Date().toISOString()} - ${message}${data ? ':' : ''}`, data !== null ? JSON.stringify(data, null, 2) : '');
+    }
 }
 
-// 将非流式Julep响应转换为OpenAI格式
-function convertJulepToOpenai(julepData, model, sessionId) {
-  const openaiResponse = {
-    id: sessionId,
-    object: "chat.completion",
-    created: Math.floor(new Date(julepData.created_at).getTime() / 1000),
-    model: model,
-    choices: julepData.choices.map(choice => ({
-      index: choice.index,
-      message: {
-        role: choice.message?.role || "assistant",
-        content: choice.message?.content || "",
-        tool_calls: choice.message?.tool_calls ? choice.message.tool_calls.map(tc => ({
-            id: tc.id,
-            type: tc.type,
-            function: tc.function ? {
-                name: tc.function.name,
-                arguments: tc.function.arguments
-            } : undefined,
-        })) : undefined,
-      },
-      finish_reason: choice.finish_reason,
-    })),
-    usage: julepData.usage ? {
-      prompt_tokens: julepData.usage.prompt_tokens,
-      completion_tokens: julepData.usage.completion_tokens,
-      total_tokens: julepData.usage.total_tokens,
-    } : undefined,
-  };
-
-  return openaiResponse;
+function getJulepApiKey(req) {
+    const authHeader = req.headers.authorization;
+    if (authHeader && authHeader.startsWith("Bearer ")) {
+        log(LogLevels.DEBUG, 'Extracted Julep API Key successfully.');
+        return authHeader.substring(7);
+    }
+    log(LogLevels.WARN, 'Could not extract Julep API Key from Authorization header.');
+    return null;
 }
 
-// 将单个Julep流式块转换为OpenAI流式格式
-function convertJulepChunkToOpenai(julepChunk, model, sessionId) {
-  const openaiChunk = {
-    id: sessionId,
-    object: "chat.completion.chunk",
-    created: Math.floor(Date.now() / 1000),
-    model: model,
-    choices: julepChunk.choices.map(choice => {
-      const openaiChoice = {
-        index: choice.index,
-        delta: {
-          role: choice.delta?.role,
-          content: choice.delta?.content,
-          tool_calls: choice.delta?.tool_calls ? choice.delta.tool_calls.map(tc => ({
-            id: tc.id,
-            type: tc.type,
-            function: tc.function ? {
-              name: tc.function.name,
-              arguments: tc.function.arguments
-            } : undefined,
-          })) : undefined,
-        },
-        finish_reason: choice.finish_reason,
-      };
-
-      // 清理空的delta字段
-      if (openaiChoice.delta.role === undefined) delete openaiChoice.delta.role;
-      if (openaiChoice.delta.content === undefined) delete openaiChoice.delta.content;
-      if (openaiChoice.delta.tool_calls === undefined) delete openaiChoice.delta.tool_calls;
-      if (Object.keys(openaiChoice.delta).length === 0 && openaiChoice.finish_reason === undefined) {
-        delete openaiChoice.delta;
-      }
-
-      return openaiChoice;
-    }),
-  };
-
-  return openaiChunk;
+// Helper for small delays
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
 }
 
-// 处理/v1/chat/completions端点
-async function chatCompletionsHandler(req, res) {
-  let body = '';
-  req.on('data', chunk => {
-    body += chunk.toString();
-  });
+// Note: Using fire-and-forget for background tasks
+async function cleanupJulepResources(agentId, sessionId, headers) {
+    log(LogLevels.INFO, 'Attempting Julep resource cleanup.', { agentId, sessionId });
+    const cleanupPromises = [];
 
-  req.on('end', async () => {
-    try {
-      // 检查授权头
-      if (!req.headers.authorization) {
-        res.writeHead(401, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: "Authorization header is required." }));
-        return;
-      }
-
-      const openaiPayload = JSON.parse(body);
-      
-      // 1. 为此会话创建一个新的Agent
-      const agentId = uuidv4();
-      
-      // 检查是否有system消息，如果有，将其添加到agent的描述中
-      let systemPrompt = "";
-      if (openaiPayload.messages && Array.isArray(openaiPayload.messages)) {
-        const systemMessage = openaiPayload.messages.find(msg => msg.role === 'system');
-        if (systemMessage) {
-          systemPrompt = systemMessage.content;
+    // Define cleanup logic as separate async functions for clarity
+    const deleteResource = async (url, type, id) => {
+        try {
+            log(LogLevels.DEBUG, `Sending DELETE request for ${type} ${id} to: ${url}`);
+            const response = await fetch(url, { method: "DELETE", headers });
+            const responseText = await response.text(); // Get text regardless of status
+            if (!response.ok) {
+                log(LogLevels.WARN, `Cleanup failed for ${type} ${id}: ${response.status} ${response.statusText}`, { body: responseText });
+            } else {
+                log(LogLevels.INFO, `Cleanup successful for ${type} ${id}.`, { status: response.status, body: responseText });
+            }
+        } catch (err) {
+            log(LogLevels.ERROR, `Cleanup error during fetch for ${type} ${id}: ${err instanceof Error ? err.message : String(err)}`, { error: err });
         }
-      }
-      
-      const createAgentPayload = {
-        name: `temp-agent-${agentId}`,
-        about: "Temporary agent created for a chat session.",
-        system_prompt: systemPrompt || undefined  // 如果有system消息，添加到agent配置中
-      };
-      
-      const createAgentResponse = await fetch(`${JULEP_API_BASE_URL}/agents/${agentId}`, {
-        method: "POST",
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': req.headers.authorization
-        },
-        body: JSON.stringify(createAgentPayload),
-      });
-
-      if (!createAgentResponse.ok) {
-        console.error("Failed to create agent:", await createAgentResponse.text());
-        res.writeHead(createAgentResponse.status, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: "Failed to initialize chat session (agent creation failed)." }));
-        return;
-      }
-
-      // 2. 使用创建的Agent创建一个新的Session
-      const sessionId = uuidv4();
-      const createSessionPayload = {
-        agent: agentId,
-      };
-
-      const createSessionResponse = await fetch(`${JULEP_API_BASE_URL}/sessions/${sessionId}`, {
-        method: "POST",
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': req.headers.authorization
+    };
+
+    if (sessionId) {
+        const sessionDeleteUrl = `${JULEP_API_BASE}/sessions/${sessionId}`;
+        cleanupPromises.push(deleteResource(sessionDeleteUrl, 'session', sessionId));
+    }
+    if (agentId) {
+        const agentDeleteUrl = `${JULEP_API_BASE}/agents/${agentId}`;
+        // Add a small delay before deleting the agent, sometimes helps if session deletion is slow
+        await sleep(100);
+        cleanupPromises.push(deleteResource(agentDeleteUrl, 'agent', agentId));
+    }
+
+    if (cleanupPromises.length > 0) {
+        log(LogLevels.DEBUG, `Waiting for ${cleanupPromises.length} cleanup promises.`);
+        // Run cleanup in background
+        Promise.allSettled(cleanupPromises)
+            .then(results => {
+                log(LogLevels.INFO, 'Cleanup promises settled.', { results });
+            })
+            .catch(error => {
+                log(LogLevels.ERROR, 'Unexpected error during Promise.allSettled for cleanup.', { error });
+            });
+    } else {
+        log(LogLevels.INFO, 'No Julep resources to clean up.');
+    }
+}
+
+// Helper to format Julep ToolCall delta to OpenAI format
+function toolCallDeltaToOpenAI(julepToolCalls) {
+    if (!julepToolCalls) return undefined;
+    return julepToolCalls.map((toolCall, index) => ({
+        index: toolCall.index ?? index,
+        id: toolCall.id,
+        type: "function",
+        function: {
+            name: toolCall.function?.name,
+            arguments: toolCall.function?.arguments,
         },
-        body: JSON.stringify(createSessionPayload),
-      });
-
-      if (!createSessionResponse.ok) {
-        console.error("Failed to create session:", await createSessionResponse.text());
-        res.writeHead(createSessionResponse.status, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: "Failed to initialize chat session (session creation failed)." }));
-        return;
-      }
-
-      // 3. 使用新的session ID发起聊天
-      const julepPayload = convertOpenaiToJulep(openaiPayload);
-      const julepUrl = `${JULEP_API_BASE_URL}/sessions/${sessionId}/chat`;
-
-      const julepResponse = await fetch(julepUrl, {
-        method: "POST",
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': req.headers.authorization
+    }));
+}
+
+// Helper to format Julep ToolCall message to OpenAI format
+function toolCallMessageToOpenAI(julepToolCalls) {
+    if (!julepToolCalls) return undefined;
+    return julepToolCalls.map(toolCall => ({
+        id: toolCall.id,
+        type: "function",
+        function: {
+            name: toolCall.function?.name,
+            arguments: toolCall.function?.arguments,
         },
-        body: JSON.stringify(julepPayload),
-      });
-
-      // 处理流式响应
-      if (openaiPayload.stream && julepResponse.headers.get('content-type')?.includes('text/event-stream')) {
-        // 设置正确的响应头
-        res.writeHead(200, {
-          'Content-Type': 'text/event-stream',
-          'Cache-Control': 'no-cache',
-          'Connection': 'keep-alive',
-          'Transfer-Encoding': 'chunked'
-        });
+    }));
+}
 
-        // 使用更可靠的方式处理流
-        const stream = julepResponse.body;
-        
-        // 创建一个TextDecoder来处理二进制数据
-        const decoder = new TextDecoder();
-        let buffer = '';
-        
-        // 处理数据块
-        stream.on('data', (chunk) => {
-          // 将二进制数据转换为文本
-          const textChunk = decoder.decode(chunk, { stream: true });
-          buffer += textChunk;
-          
-          // 处理完整的SSE事件
-          const lines = buffer.split('\n');
-          // 保留最后一个可能不完整的行
-          buffer = lines.pop() || '';
-          
-          for (const line of lines) {
-            if (line.startsWith('data:')) {
-              const data = line.substring(5).trim();
-              
-              // 处理结束标记
-              if (data === '[DONE]') {
-                res.write('data: [DONE]\n\n');
-                continue;
-              }
-              
-              try {
-                // 解析Julep的JSON响应
-                const julepChunk = JSON.parse(data);
-                // 转换为OpenAI格式
-                const openaiChunk = convertJulepChunkToOpenai(julepChunk, openaiPayload.model || 'julep-model', sessionId);
-                // 发送给客户端
-                res.write(`data: ${JSON.stringify(openaiChunk)}\n\n`);
-              } catch (parseError) {
-                console.error("Error parsing Julep stream chunk:", parseError, "Raw data:", data);
-                // 可选：发送错误信息给客户端
-                // res.write(`data: ${JSON.stringify({ error: "Failed to parse response" })}\n\n`);
-              }
-            } else if (line.trim() && !line.startsWith(':')) {
-              // 记录非注释的未知行类型
-              console.warn("Received unexpected stream line:", line);
+// Helper function to simulate streaming from a complete response
+async function simulateStream(julepChatData, requestedModel, res) {
+    log(LogLevels.INFO, 'Starting stream simulation.');
+    try {
+        const baseChunk = {
+            id: julepChatData.id || `chatcmpl-sim-${Date.now()}`,
+            object: "chat.completion.chunk",
+            created: Math.floor(new Date(julepChatData.created_at || Date.now()).getTime() / 1000),
+            model: requestedModel,
+            system_fingerprint: julepChatData.system_fingerprint || null,
+        };
+
+        for (const [index, choice] of julepChatData.choices.entries()) {
+            log(LogLevels.DEBUG, `Simulating stream for choice index ${index}.`);
+            const role = choice.message?.role;
+            const content = choice.message?.content;
+            const toolCallsInput = choice.message?.tool_calls;
+            const toolCallsDelta = toolCallsInput ? toolCallDeltaToOpenAI(toolCallsInput) : undefined; // Format as delta
+            const finishReason = choice.finish_reason;
+
+            // 1. Send role chunk
+            if (role) {
+                const roleChunk = { ...baseChunk, choices: [{ index: index, delta: { role: role }, finish_reason: null }] };
+                log(LogLevels.DEBUG, 'Sending role chunk:', roleChunk);
+                res.write(`data: ${JSON.stringify(roleChunk)}\n\n`);
+                await sleep(5);
             }
-          }
-          
-          // 确保数据立即发送
-          res.flushHeaders();
-        });
-        
-        // 处理流结束
-        stream.on('end', () => {
-          // 确保发送[DONE]标记（如果Julep没有发送）
-          if (buffer.trim()) {
-            // 处理缓冲区中剩余的数据
-            if (buffer.startsWith('data:')) {
-              const data = buffer.substring(5).trim();
-              if (data && data !== '[DONE]') {
-                try {
-                  const julepChunk = JSON.parse(data);
-                  const openaiChunk = convertJulepChunkToOpenai(julepChunk, openaiPayload.model || 'julep-model', sessionId);
-                  res.write(`data: ${JSON.stringify(openaiChunk)}\n\n`);
-                } catch (e) {
-                  console.error("Error parsing final chunk:", e);
+
+            // 2. Send tool calls chunk(s) if they exist
+            if (toolCallsDelta && toolCallsDelta.length > 0) {
+                const toolCallDeltaChunk = { ...baseChunk, choices: [{ index: index, delta: { tool_calls: toolCallsDelta }, finish_reason: null }] };
+                log(LogLevels.DEBUG, 'Sending tool_calls chunk:', toolCallDeltaChunk);
+                res.write(`data: ${JSON.stringify(toolCallDeltaChunk)}\n\n`);
+                await sleep(5);
+            }
+
+            // 3. Stream content
+            if (content && typeof content === 'string') {
+                log(LogLevels.DEBUG, `Streaming content for choice ${index} (length: ${content.length})`);
+                for (const char of content) {
+                    const contentChunk = { ...baseChunk, choices: [{ index: index, delta: { content: char }, finish_reason: null }] };
+                    res.write(`data: ${JSON.stringify(contentChunk)}\n\n`);
+                    await sleep(2); // Simulate typing delay
                 }
-              }
+                log(LogLevels.DEBUG, `Finished streaming content for choice ${index}`);
+            } else if (content) {
+                // Send non-string content as a single chunk (might be structured JSON etc.)
+                const contentChunk = { ...baseChunk, choices: [{ index: index, delta: { content: JSON.stringify(content) }, finish_reason: null }] };
+                log(LogLevels.DEBUG, 'Sending non-string content chunk:', contentChunk);
+                res.write(`data: ${JSON.stringify(contentChunk)}\n\n`);
+                await sleep(5);
+            }
+
+            // 4. Send finish reason chunk
+            if (finishReason) {
+                const finishChunk = { ...baseChunk, choices: [{ index: index, delta: {}, finish_reason: finishReason }] };
+                log(LogLevels.DEBUG, 'Sending finish reason chunk:', finishChunk);
+                res.write(`data: ${JSON.stringify(finishChunk)}\n\n`);
+                await sleep(5);
+            }
+        }
+
+        // 5. Send DONE marker
+        log(LogLevels.INFO, 'Sending [DONE] marker.');
+        res.write('data: [DONE]\n\n');
+        res.end();
+        log(LogLevels.INFO, 'Stream simulation completed successfully.');
+
+    } catch (error) {
+        log(LogLevels.ERROR, `Error during stream simulation: ${error instanceof Error ? error.message : String(error)}`, { error: error });
+        // Try to end the response if possible
+        try {
+            if (!res.headersSent) {
+                res.status(500).json({ error: 'Stream simulation error' });
+            } else {
+                res.end();
             }
-          }
-          
-          // 发送最终的[DONE]标记
-          res.write('data: [DONE]\n\n');
-          res.end();
-          console.log(`Stream completed for session ${sessionId}`);
+        } catch (endError) {
+            log(LogLevels.ERROR, 'Error ending response after stream error', { error: endError });
+        }
+    }
+}
+
+// --- Middleware ---
+app.use(express.json());
+
+// CORS middleware
+app.use((req, res, next) => {
+    res.header('Access-Control-Allow-Origin', '*');
+    res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.header('Access-Control-Allow-Headers', 'Authorization, Content-Type');
+    
+    if (req.method === 'OPTIONS') {
+        return res.status(204).end();
+    }
+    next();
+});
+
+// --- Routes ---
+app.get('/v1/models', async (req, res) => {
+    log(LogLevels.INFO, 'Handling /v1/models request.');
+    const julepApiKey = getJulepApiKey(req);
+    if (!julepApiKey) {
+        log(LogLevels.WARN, 'Unauthorized /v1/models request (missing API key).');
+        // Optionally allow models request without key, or enforce it
+    }
+
+    const now = Math.floor(Date.now() / 1000);
+    const openaiModels = HARDCODED_MODELS.map((modelId) => ({
+        id: modelId, object: "model", created: now, owned_by: "julep",
+        permission: [{ id: `modelperm-${modelId}-${now}`, object: "model_permission", created: now, allow_create_engine: false, allow_sampling: true, allow_logprobs: true, allow_search_indices: false, allow_view: true, allow_fine_tuning: false, organization: "*", group: null, is_blocking: false, }],
+        root: modelId, parent: null,
+    }));
+    log(LogLevels.DEBUG, 'Returning hardcoded models list.');
+    res.json({ data: openaiModels, object: "list" });
+});
+
+app.post('/v1/chat/completions', async (req, res) => {
+    log(LogLevels.INFO, 'Handling /v1/chat/completions request.');
+    const julepApiKey = getJulepApiKey(req);
+    if (!julepApiKey) {
+        log(LogLevels.ERROR, 'Unauthorized chat completions request: Missing Julep API Key.');
+        return res.status(401).send("Unauthorized: Missing or invalid Authorization header");
+    }
+
+    // Define headers early, use this single object throughout
+    const headers = {
+        "Authorization": `Bearer ${julepApiKey}`,
+        "Content-Type": "application/json",
+    };
+    log(LogLevels.DEBUG, 'Julep API request headers prepared (key omitted).', { "Content-Type": headers["Content-Type"] });
+
+    let agentId = null;
+    let sessionId = null;
+    let requestBody = req.body;
+
+    try {
+        const { model, messages, stream, ...rest } = requestBody;
+        const clientRequestedStream = stream === true;
+        log(LogLevels.INFO, `Request details: model=${model}, clientRequestedStream=${clientRequestedStream}`);
+
+        // Validate essential parameters
+        if (!model || !messages || !Array.isArray(messages) || messages.length === 0) {
+            log(LogLevels.ERROR, 'Invalid request body: "model" and "messages" are required.', { model, messages });
+            return res.status(400).send("Invalid request body. 'model' and 'messages' are required.");
+        }
+        if (!HARDCODED_MODELS.includes(model)) {
+            log(LogLevels.ERROR, `Invalid model requested: ${model}`);
+            return res.status(400).send(`Invalid model: ${model}. Please use one of the available models.`);
+        }
+        log(LogLevels.DEBUG, 'Request parameters validated.');
+
+        // --- Agent and Session Creation ---
+        // 2. Create Agent
+        const createAgentUrl = `${JULEP_API_BASE}/agents`;
+        const createAgentBody = {
+            name: `temp-openai-${model}-${Date.now()}`,
+            model: model,
+            about: `Temporary agent for OpenAI model ${model}`,
+        };
+        log(LogLevels.INFO, 'Attempting to create Julep Agent.', { url: createAgentUrl, body: createAgentBody });
+        const createAgentResponse = await fetch(createAgentUrl, { 
+            method: "POST", 
+            headers, 
+            body: JSON.stringify(createAgentBody) 
         });
-        
-        // 处理错误
-        stream.on('error', (error) => {
-          console.error("Stream error:", error);
-          // 尝试发送错误信息给客户端
-          try {
-            res.write(`data: ${JSON.stringify({ error: "Stream error occurred" })}\n\n`);
-            res.write('data: [DONE]\n\n');
-          } catch (e) {
-            // 可能客户端已断开连接
-          }
-          res.end();
+        log(LogLevels.DEBUG, `Create Agent response status: ${createAgentResponse.status}`);
+
+        if (!createAgentResponse.ok) {
+            const errorStatus = createAgentResponse.status;
+            const errorStatusText = createAgentResponse.statusText;
+            let errorText = "[Could not read error body]";
+            try { 
+                errorText = await createAgentResponse.text(); 
+            } catch (e) { 
+                log(LogLevels.WARN, `Could not read error text from createAgentResponse: ${e instanceof Error ? e.message : String(e)}`); 
+            }
+            log(LogLevels.ERROR, `Error creating Julep Agent: ${errorStatus} - ${errorText}`);
+            return res.status(errorStatus).send(`Error creating Julep Agent: ${errorStatusText} - ${errorText}`);
+        }
+
+        let agentData;
+        try {
+            const agentResponseText = await createAgentResponse.text();
+            log(LogLevels.DEBUG, 'Create Agent raw response text:', agentResponseText);
+            agentData = JSON.parse(agentResponseText);
+            log(LogLevels.INFO, 'Julep Agent created successfully.', { agentData });
+            agentId = agentData.id;
+        } catch (e) {
+            log(LogLevels.ERROR, `Failed to parse Julep Agent creation response JSON: ${e instanceof Error ? e.message : String(e)}`, { error: e });
+            // Attempt cleanup (fire-and-forget)
+            cleanupJulepResources(agentId, sessionId, headers).catch(err => log(LogLevels.ERROR, 'Background cleanup failed after agent parse error', err));
+            return res.status(500).send(`Internal Server Error: Failed to parse Julep Agent response. ${e instanceof Error ? e.message : String(e)}`);
+        }
+
+        // 3. Create Session
+        const createSessionUrl = `${JULEP_API_BASE}/sessions`;
+        const createSessionBody = { agent: agentId }; // Julep API uses agent
+        log(LogLevels.INFO, 'Attempting to create Julep Session.', { url: createSessionUrl, body: createSessionBody });
+        const createSessionResponse = await fetch(createSessionUrl, { 
+            method: "POST", 
+            headers, 
+            body: JSON.stringify(createSessionBody) 
         });
-        
-        // 处理客户端断开连接
-        req.on('close', () => {
-          console.log(`Client disconnected for session ${sessionId}`);
-          // 可以选择在这里清理资源
+        log(LogLevels.DEBUG, `Create Session response status: ${createSessionResponse.status}`);
+
+        if (!createSessionResponse.ok) {
+            const errorStatus = createSessionResponse.status;
+            const errorStatusText = createSessionResponse.statusText;
+            let errorText = "[Could not read error body]";
+            try { 
+                errorText = await createSessionResponse.text(); 
+            } catch (e) { 
+                log(LogLevels.WARN, `Could not read error text from createSessionResponse: ${e instanceof Error ? e.message : String(e)}`); 
+            }
+            log(LogLevels.ERROR, `Error creating Julep Session: ${errorStatus} - ${errorText}`);
+            // Cleanup the agent we just created (fire-and-forget)
+            cleanupJulepResources(agentId, null, headers).catch(err => log(LogLevels.ERROR, 'Background cleanup failed after session creation error', err));
+            return res.status(errorStatus).send(`Error creating Julep Session: ${errorStatusText} - ${errorText}`);
+        }
+
+        let sessionData;
+        try {
+            const sessionResponseText = await createSessionResponse.text();
+            log(LogLevels.DEBUG, 'Create Session raw response text:', sessionResponseText);
+            sessionData = JSON.parse(sessionResponseText);
+            log(LogLevels.INFO, 'Julep Session created successfully.', { sessionData });
+            sessionId = sessionData.id;
+        } catch (e) {
+            log(LogLevels.ERROR, `Failed to parse Julep Session creation response JSON: ${e instanceof Error ? e.message : String(e)}`, { error: e });
+            // Cleanup agent and session (fire-and-forget)
+            cleanupJulepResources(agentId, sessionId, headers).catch(err => log(LogLevels.ERROR, 'Background cleanup failed after session parse error', err));
+            return res.status(500).send(`Internal Server Error: Failed to parse Julep Session response. ${e instanceof Error ? e.message : String(e)}`);
+        }
+
+        // --- Perform Chat Completion (ALWAYS non-streaming to Julep) ---
+        // 4. Send Chat Request to Julep
+        const chatUrl = `${JULEP_API_BASE}/sessions/${sessionId}/chat`;
+        const chatBodyToJulep = {
+            messages: messages.map((msg) => ({
+                role: msg.role,
+                content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+                // Include tool_calls if present in the input message (OpenAI format)
+                tool_calls: msg.tool_calls, // Assuming Julep accepts OpenAI tool call format here
+                tool_call_id: msg.tool_call_id // If it's a tool response message
+            })),
+            stream: false, // Force non-streaming
+            ...rest, // Pass through other OpenAI parameters like temperature, top_p, etc.
+        };
+        log(LogLevels.INFO, 'Sending Chat request to Julep (forced non-stream).', { url: chatUrl });
+        log(LogLevels.DEBUG, 'Julep Chat Request Body:', chatBodyToJulep);
+        const chatResponse = await fetch(chatUrl, { 
+            method: "POST", 
+            headers, 
+            body: JSON.stringify(chatBodyToJulep) 
         });
-      } else {
-        // 处理非流式响应
-        const julepData = await julepResponse.json();
-        const openaiResponse = convertJulepToOpenai(julepData, openaiPayload.model || 'julep-model', sessionId);
-
-        res.writeHead(julepResponse.status, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify(openaiResponse));
-      }
+        log(LogLevels.DEBUG, `Julep Chat response status: ${chatResponse.status}`);
+
+        // --- Handle Julep Response ---
+        if (!chatResponse.ok) {
+            const errorStatus = chatResponse.status;
+            const errorStatusText = chatResponse.statusText;
+            let errorText = "[Could not read error body]";
+            try { 
+                errorText = await chatResponse.text(); 
+            } catch (e) { 
+                log(LogLevels.WARN, `Could not read error text from chatResponse: ${e instanceof Error ? e.message : String(e)}`); 
+            }
+            log(LogLevels.ERROR, `Error during Julep Chat Completion: ${errorStatus} - ${errorText}`);
+            // Cleanup agent and session (fire-and-forget)
+            cleanupJulepResources(agentId, sessionId, headers).catch(err => log(LogLevels.ERROR, 'Background cleanup failed after chat error', err));
+            return res.status(errorStatus).send(`Error during Julep Chat Completion: ${errorStatusText} - ${errorText}`);
+        }
+
+        // Julep request was successful, get the full JSON body
+        let julepChatData;
+        try {
+            const chatResponseText = await chatResponse.text();
+            log(LogLevels.DEBUG, 'Julep Chat raw response text:', chatResponseText);
+            julepChatData = JSON.parse(chatResponseText);
+            log(LogLevels.INFO, 'Julep chat completion successful.', { responseId: julepChatData.id })
+            log(LogLevels.DEBUG, 'Julep Chat response data:', julepChatData);
+        } catch (e) {
+            log(LogLevels.ERROR, `Failed to parse Julep Chat response JSON (status was OK): ${e instanceof Error ? e.message : String(e)}`, { error: e });
+            // Cleanup agent and session (fire-and-forget)
+            cleanupJulepResources(agentId, sessionId, headers).catch(err => log(LogLevels.ERROR, 'Background cleanup failed after chat parse error', err));
+            return res.status(500).send(`Internal Server Error: Failed to parse Julep Chat response. ${e instanceof Error ? e.message : String(e)}`);
+        }
+
+        // *** Trigger cleanup NOW (fire-and-forget), before returning the response/stream ***
+        log(LogLevels.INFO, 'Julep chat successful, queueing cleanup.');
+        cleanupJulepResources(agentId, sessionId, headers).catch(err => log(LogLevels.ERROR, 'Background cleanup failed after successful chat', err));
+
+        // --- Format and Return Response to Client ---
+        // Access the actual chat response data
+        const julepResponseData = julepChatData;
+        if (!julepResponseData || !julepResponseData.choices) {
+            log(LogLevels.ERROR, 'Julep response format unexpected. Missing "response" or "response.choices".', { julepChatData });
+            return res.status(500).send('Internal Server Error: Unexpected format from Julep API.');
+        }
+
+        if (clientRequestedStream) {
+            log(LogLevels.INFO, 'Client requested stream, starting simulation.');
+            // Set headers for SSE
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.setHeader('Cache-Control', 'no-cache');
+            res.setHeader('Connection', 'keep-alive');
+            res.flushHeaders(); // Flush the headers to establish SSE with client
+
+            // Start simulation
+            simulateStream(julepResponseData, model, res)
+                .catch(streamErr => {
+                    log(LogLevels.ERROR, 'Stream simulation task failed.', { error: streamErr });
+                });
+        } else {
+            log(LogLevels.INFO, 'Client requested non-streaming response.');
+            // Format julepResponseData to OpenAI format
+            const openaiCompletion = {
+                id: julepResponseData.id || `chatcmpl-${Date.now()}`,
+                object: "chat.completion",
+                created: Math.floor(new Date(julepResponseData.created_at || Date.now()).getTime() / 1000),
+                model: model, // Use the originally requested model
+                choices: julepResponseData.choices.map((choice) => ({
+                    index: choice.index,
+                    message: {
+                        role: choice.message.role,
+                        content: choice.message.content,
+                        // Use toolCallMessageToOpenAI here for the completed message format
+                        tool_calls: choice.message.tool_calls ? toolCallMessageToOpenAI(choice.message.tool_calls) : undefined
+                    },
+                    finish_reason: choice.finish_reason
+                })),
+                usage: julepResponseData.usage ? {
+                    prompt_tokens: julepResponseData.usage.prompt_tokens,
+                    completion_tokens: julepResponseData.usage.completion_tokens,
+                    total_tokens: julepResponseData.usage.total_tokens
+                } : undefined,
+                system_fingerprint: julepResponseData.system_fingerprint || null,
+            };
+            log(LogLevels.DEBUG, 'Formatted non-streaming OpenAI response:', openaiCompletion);
+            log(LogLevels.INFO, 'Returning non-streaming JSON response to client.');
+            res.json(openaiCompletion);
+        }
+
     } catch (error) {
-      console.error("Error processing request:", error);
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: "Internal Server Error", details: error.message }));
+        // Catch errors from initial parsing, validation, or unexpected issues within the try block
+        log(LogLevels.ERROR, `Error in handleChatCompletions (outer catch): ${error instanceof Error ? error.message : String(error)}`, { error: error, agentId, sessionId });
+        // Use the headers defined at the start if available
+        // Attempt cleanup (fire-and-forget)
+        cleanupJulepResources(agentId, sessionId, headers).catch(err => log(LogLevels.ERROR, 'Background cleanup failed in outer catch block', err));
+        res.status(500).send(`Internal Server Error: ${error instanceof Error ? error.message : String(error)}`);
     }
-  });
-}
+});
 
-// 创建HTTP服务器
-const server = http.createServer((req, res) => {
-  const url = new URL(req.url, `http://${req.headers.host}`);
-  
-  // 处理CORS预检请求
-  if (req.method === 'OPTIONS') {
-    res.writeHead(204, {
-      'Access-Control-Allow-Origin': '*',
-      'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
-      'Access-Control-Allow-Headers': 'Content-Type, Authorization',
-      'Access-Control-Max-Age': '86400'
-    });
-    res.end();
-    return;
-  }
-
-  // 为所有响应添加CORS头
-  res.setHeader('Access-Control-Allow-Origin', '*');
-  
-  // 处理/v1/models端点
-  if (url.pathname === '/v1/models' && req.method === 'GET') {
-    listModelsHandler(res);
-  }
-  // 处理/v1/chat/completions端点
-  else if (url.pathname === '/v1/chat/completions' && req.method === 'POST') {
-    chatCompletionsHandler(req, res);
-  }
-  // 处理根路径，返回简单的HTML页面
-  else if (url.pathname === '/' && req.method === 'GET') {
-    res.writeHead(200, { 'Content-Type': 'text/html' });
-    res.end(`
-      <!DOCTYPE html>
-      <html>
-        <head>
-          <title>Julep API Proxy</title>
-          <style>
-            body { font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
-            h1 { color: #333; }
-            pre { background: #f4f4f4; padding: 10px; border-radius: 5px; }
-          </style>
-        </head>
-        <body>
-          <h1>Julep API Proxy</h1>
-          <p>This server proxies requests to the Julep API using OpenAI-compatible endpoints:</p>
-          <ul>
-            <li><code>GET /v1/models</code> - List available models</li>
-            <li><code>POST /v1/chat/completions</code> - Create a chat completion</li>
-          </ul>
-          <p>Server is running on port ${PORT}</p>
-        </body>
-      </html>
-    `);
-  }
-  // 返回404
-  else {
-    res.writeHead(404, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ error: "Not Found" }));
-  }
+// Health check endpoint for Hugging Face
+app.get('/', (req, res) => {
+    res.send('Julep API Proxy is running');
 });
 
-// 启动服务器
-server.listen(PORT, () => {
-  console.log(`Server running on port ${PORT}`);
+// Start the server
+app.listen(PORT, () => {
+    log(LogLevels.INFO, `Server running on port ${PORT}`);
 });
+