Create app.js

app.js

@@ -0,0 +1,459 @@
+// app.js
+// 导入所需的Node.js模块
+const http = require('http');
+const { v4: uuidv4 } = require('uuid');
+const fetch = require('node-fetch');
+
+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'
+];
+
+// 处理/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));
+}
+
+// 将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;
+}
+
+// 将非流式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;
+}
+
+// 将单个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;
+}
+
+// 处理/v1/chat/completions端点
+async function chatCompletionsHandler(req, res) {
+  let body = '';
+  req.on('data', chunk => {
+    body += chunk.toString();
+  });
+
+  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;
+        }
+      }
+      
+      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
+        },
+        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
+        },
+        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);
+            }
+          }
+          
+          // 确保数据立即发送
+          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);
+                }
+              }
+            }
+          }
+          
+          // 发送最终的[DONE]标记
+          res.write('data: [DONE]\n\n');
+          res.end();
+          console.log(`Stream completed for session ${sessionId}`);
+        });
+        
+        // 处理错误
+        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();
+        });
+        
+        // 处理客户端断开连接
+        req.on('close', () => {
+          console.log(`Client disconnected for session ${sessionId}`);
+          // 可以选择在这里清理资源
+        });
+      } 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));
+      }
+    } 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 }));
+    }
+  });
+}
+
+// 创建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" }));
+  }
+});
+
+// 启动服务器
+server.listen(PORT, () => {
+  console.log(`Server running on port ${PORT}`);
+});