Update main.ts

main.ts

@@ -1,274 +1,415 @@
-const lunaryApiBaseUrl = "https://api.lunary.ai/v1";
+import { serve } from "https://deno.land/std@0.220.1/http/server.ts";
 
-// Using Deno.Kv for caching (requires --allow-env and --allow-read for .env or config)
-const kv = await Deno.openKv();
+// 定义常量
+const UNLIMITED_AI_URL = "https://app.unlimitedai.chat/api/chat";
+const PORT = 3000;
+const MAX_RETRIES = 3;
 
-async function getOrgId(apiKey: string): Promise<string | null> {
-  // Direct storage of API key as the cache key
-  const cachedOrgId = await kv.get(["orgIdCache", apiKey]);
-
-  if (cachedOrgId.value) {
-    console.log(`Cache hit for orgId: ${cachedOrgId.value}`);
-    return cachedOrgId.value as string;
-  }
-
-  console.log("Cache miss for orgId, fetching from Lunary API...");
-
-  const response = await fetch(`${lunaryApiBaseUrl}/users/me/org`, {
-    method: "GET",
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-      "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:138.0) Gecko/20100101 Firefox/138.0",
-      "Accept": "application/json",
-      "Accept-Language": "en-US,en;q=0.5",
-      "Referer": "https://app.lunary.ai/",
-      "Origin": "https://app.lunary.ai",
-      "DNT": "1",
-      "Sec-GPC": "1",
-      "Connection": "keep-alive",
-      "Sec-Fetch-Dest": "empty",
-      "Sec-Fetch-Mode": "cors",
-      "Sec-Fetch-Site": "same-site",
-      "Priority": "u=4",
-      "Pragma": "no-cache",
-      "Cache-Control": "no-cache",
-      "TE": "trailers",
-    },
-  });
-
-  if (!response.ok) {
-    console.error(`Failed to get orgId: ${response.status} - ${await response.text()}`);
-    return null;
-  }
+// 定义接口
+interface UnlimitedAIMessage {
+  id: string;
+  createdAt: string;
+  role: string;
+  content: string;
+  parts: Array<{ type: string; text: string }>;
+}
 
-  const data = await response.json();
-  const orgId = data.id;
+interface OpenAIMessage {
+  role: string;
+  content: string;
+}
 
-  if (orgId) {
-    // Cache the orgId for 24 hours (adjust TTL as needed)
-    await kv.set(["orgIdCache", apiKey], orgId, { expireIn: 24 * 60 * 60 * 1000 });
-    console.log(`OrgId cached: ${orgId}`);
-    return orgId;
+// 将OpenAI消息转换为UnlimitedAI消息
+function convertOpenAIToUnlimitedMessages(messages: OpenAIMessage[]): UnlimitedAIMessage[] {
+  // 提取系统消息
+  const systemMessages = messages.filter(msg => msg.role === "system");
+  const nonSystemMessages = messages.filter(msg => msg.role !== "system");
+  
+  const result: UnlimitedAIMessage[] = [];
+  
+  // 如果有系统消息，将其转换为用户消息和助手回复
+  if (systemMessages.length > 0) {
+    // 合并所有系统消息内容
+    const systemContent = systemMessages.map(msg => msg.content).join("\n\n");
+    
+    // 添加作为用户消息的系统提示
+    result.push({
+      id: crypto.randomUUID(),
+      createdAt: new Date().toISOString(),
+      role: "user",
+      content: systemContent,
+      parts: [{ type: "text", text: systemContent }],
+    });
+    
+    // 添加助手确认回复
+    result.push({
+      id: crypto.randomUUID(),
+      createdAt: new Date().toISOString(),
+      role: "assistant",
+      content: "Ok, I got it, I'll remember it and do it.",
+      parts: [{ type: "text", text: "Ok, I got it, I'll remember it and do it." }],
+    });
   }
+  
+  // 添加其余非系统消息
+  nonSystemMessages.forEach(msg => {
+    result.push({
+      id: crypto.randomUUID(),
+      createdAt: new Date().toISOString(),
+      role: msg.role,
+      content: msg.content,
+      parts: [{ type: "text", text: msg.content }],
+    });
+  });
+  
+  return result;
+}
 
-  return null;
+// 将OpenAI请求体转换为UnlimitedAI请求体
+function convertOpenAIToUnlimitedBody(openaiBody: any): any {
+  return {
+    id: openaiBody.id || crypto.randomUUID(),
+    messages: convertOpenAIToUnlimitedMessages(openaiBody.messages),
+    selectedChatModel: openaiBody.model || "chat-model-reasoning",
+  };
 }
 
-async function handler(req: Request): Promise<Response> {
-  if (req.method !== "POST") {
-    return new Response("Method Not Allowed", { status: 405 });
-  }
+// 处理流式响应
+async function* transformStreamResponse(
+  reader: ReadableStreamDefaultReader<Uint8Array>
+): AsyncGenerator<string> {
+  let buffer = "";
+  const decoder = new TextDecoder();
+  let messageId = "";
+  let firstResult = true;
 
-  const authHeader = req.headers.get("Authorization");
-  const apiKey = authHeader?.split(" ")[1];
-  if (!apiKey) {
-    return new Response("Unauthorized", { status: 401 });
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        yield "data: [DONE]\n\n";
+        break;
+      }
+      
+      buffer += decoder.decode(value, { stream: true });
+      let lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        const idx = line.indexOf(":");
+        if (idx === -1) continue;
+        
+        const key = line.slice(0, idx);
+        let val = line.slice(idx + 1).trim();
+        if (val.startsWith('"') && val.endsWith('"')) {
+          val = val.slice(1, -1);
+        }
+        
+        if (key === "f") {
+          // 记录 messageId
+          try {
+            const obj = JSON.parse(val);
+            messageId = obj.messageId || "";
+          } catch (error) {
+            console.error("Error parsing messageId:", error);
+          }
+        } else if (key === "g") {
+          const delta = firstResult
+            ? {
+                role: "assistant",
+                reasoning_content: val.replace(/\\n/g, "\n"),
+              }
+            : { reasoning_content: val.replace(/\\n/g, "\n") };
+          
+          // 思考过程
+          const chunk = {
+            id: messageId || crypto.randomUUID(),
+            object: "chat.completion.chunk",
+            created: Math.floor(Date.now() / 1000),
+            model: "chat-model-reasoning",
+            choices: [
+              {
+                delta,
+                index: 0,
+                finish_reason: null,
+              },
+            ],
+          };
+          
+          yield `data: ${JSON.stringify(chunk)}\n\n`;
+        } else if (key === "0") {
+          // 最终结果
+          const delta = { content: val.replace(/\\n/g, "\n") };
+          const chunk = {
+            id: messageId || crypto.randomUUID(),
+            object: "chat.completion.chunk",
+            created: Math.floor(Date.now() / 1000),
+            model: "chat-model-reasoning",
+            choices: [
+              {
+                delta,
+                index: 0,
+                finish_reason: null,
+              },
+            ],
+          };
+          
+          yield `data: ${JSON.stringify(chunk)}\n\n`;
+          firstResult = false;
+        } else if (key === "e" || key === "d") {
+          // 结束
+          yield "data: [DONE]\n\n";
+        }
+      }
+    }
+  } catch (error) {
+    console.error("Stream transformation error:", error);
+    yield "data: [DONE]\n\n";
+  } finally {
+    reader.releaseLock();
   }
+}
 
-  const orgId = await getOrgId(apiKey);
-  if (!orgId) {
-    return new Response("Could not retrieve organization ID for the provided API key.", { status: 400 });
+// 转换非流式响应
+async function transformNonStreamResponse(text: string): Promise<any> {
+  const lines = text.split("\n");
+  const data: Record<string, any> = {};
+  
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    
+    const key = line.slice(0, idx);
+    let val = line.slice(idx + 1).trim();
+    try {
+      val = JSON.parse(val);
+    } catch (error) {
+      // 如果解析失败，保持原始字符串
+    }
+    
+    data[key] = val;
   }
+  
+  const content = data["0"];
+  const reasoning_content = data.g;
+  
+  return {
+    id: data.f?.messageId || crypto.randomUUID(),
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1000),
+    model: "chat-model-reasoning",
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: "assistant",
+          reasoning_content,
+          content,
+        },
+        finish_reason: "stop",
+      },
+    ],
+    usage: {
+      prompt_tokens: 0,
+      completion_tokens: 0,
+      total_tokens: 0,
+    },
+  };
+}
 
-  let requestBody;
+// 处理聊天完成请求
+async function handleChatCompletions(
+  openaiBody: any,
+  isStream: boolean,
+  retryCount = 0
+): Promise<Response> {
   try {
-    requestBody = await req.json();
-  } catch (error) {
-    return new Response("Invalid JSON", { status: 400 });
-  }
+    // 转换为 UnlimitedAI.Chat 请求体
+    const unlimitedBody = convertOpenAIToUnlimitedBody(openaiBody);
+    
+    // 只转发必要 headers
+    const upstreamHeaders = {
+      "content-type": "application/json",
+      "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.0.0",
+      // 可以根据需要转发 Authorization 等
+      "referer": "https://app.unlimitedai.chat/"
+    };
 
-  const { messages, model, stream, ...extraParams } = requestBody;
-
-  if (!messages || !Array.isArray(messages)) {
-    return new Response("Missing or invalid 'messages' parameter", {
-      status: 400,
+    // 获取 X-API-TOKEN
+    const XApiTokenRes = await fetch("https://app.unlimitedai.chat/api/token", {
+      method: "GET",
+      headers: upstreamHeaders
     });
-  }
-
-  if (!model || typeof model !== "string") {
-    return new Response("Missing or invalid 'model' parameter", {
-      status: 400,
+    const XApiToken = await XApiTokenRes.json().then(data => data.token);
+    upstreamHeaders["X-API-TOKEN"] = XApiToken;
+    
+    // 转发到 UnlimitedAI.Chat
+    const upstreamRes = await fetch(UNLIMITED_AI_URL, {
+      method: "POST",
+      headers: upstreamHeaders,
+      body: JSON.stringify(unlimitedBody),
     });
-  }
-
-  const modelParts = model.split("/");
-  if (modelParts.length !== 2) {
+    
+    if (!upstreamRes.ok) {
+      throw new Error(`Chat completion failed: ${upstreamRes.status}`);
+    }
+    
+    if (isStream) {
+      // 流式响应处理
+      const reader = upstreamRes.body?.getReader();
+      if (!reader) {
+        throw new Error("Failed to get response body reader");
+      }
+      
+      const transformedStream = new ReadableStream({
+        async start(controller) {
+          try {
+            for await (const chunk of transformStreamResponse(reader)) {
+              controller.enqueue(new TextEncoder().encode(chunk));
+            }
+            controller.close();
+          } catch (error) {
+            console.error("Stream transformation error:", error);
+            controller.error(error);
+          }
+        },
+      });
+      
+      return new Response(transformedStream, {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive",
+          "Access-Control-Allow-Origin": "*",
+        },
+      });
+    } else {
+      // 非流式响应处理
+      const text = await upstreamRes.text();
+      const transformedResponse = await transformNonStreamResponse(text);
+      
+      return new Response(JSON.stringify(transformedResponse), {
+        status: 200,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+        },
+      });
+    }
+  } catch (error) {
+    console.error("Request handling error:", error);
+    
     return new Response(
-      "Invalid 'model' format. Expected 'provider/model_id'",
-      { status: 400 }
+      JSON.stringify({ error: "Internal server error", message: error.message }),
+      {
+        status: 500,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+        },
+      },
     );
   }
+}
 
-  const [provider, modelId] = modelParts;
-
-  const lunaryRequestBody = {
-    content: messages,
-    extra: {
-      model: {
-        id: modelId,
-        name: modelId, // Lunary uses name and id as the same
-        provider: provider,
-      },
-      temperature: extraParams.temperature ?? 1, // Default temperature
-      stream: false, // This API doesn't support streaming directly
-      tools: extraParams.tools,
-      ...extraParams, // Include other extra parameters
-    },
-    variables: extraParams.variables ?? {}, // Include variables if provided
-  };
+// 主处理函数
+async function handler(req: Request): Promise<Response> {
+  const url = new URL(req.url);
+  const path = url.pathname;
 
-  const lunaryResponse = await fetch(
-    `${lunaryApiBaseUrl}/orgs/${orgId}/playground`,
-    {
-      method: "POST",
+  // CORS预检请求处理
+  if (req.method === "OPTIONS") {
+    return new Response(null, {
+      status: 204,
       headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`, // Use the original API key for the playground request
-        // Add realistic browser headers
-        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:138.0) Gecko/20100101 Firefox/138.0",
-        "Accept": "*/*",
-        "Accept-Language": "en-US,en;q=0.5",
-        "Referer": "https://app.lunary.ai/",
-        "Origin": "https://app.lunary.ai",
-        "DNT": "1",
-        "Sec-GPC": "1",
-        "Connection": "keep-alive",
-        "Sec-Fetch-Dest": "empty",
-        "Sec-Fetch-Mode": "cors",
-        "Sec-Fetch-Site": "same-site",
-        "Priority": "u=4",
-        "Pragma": "no-cache",
-        "Cache-Control": "no-cache",
-        "TE": "trailers",
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type, Authorization",
+        "Access-Control-Max-Age": "86400",
       },
-      body: JSON.stringify(lunaryRequestBody),
-    }
-  );
-
-  if (!lunaryResponse.ok) {
-    const errorText = await lunaryResponse.text();
-    console.error(`Lunary Playground API error: ${lunaryResponse.status} - ${errorText}`);
-    return new Response(`Lunary Playground API error: ${lunaryResponse.status} - ${errorText}`, {
-      status: lunaryResponse.status,
     });
   }
 
-  const lunaryData = await lunaryResponse.json();
-
-  const openaiFormattedResponse = {
-    id: lunaryData.id,
-    object: "chat.completion",
-    created: lunaryData.created,
-    model: lunaryData.model, // Lunary returns the actual model name
-    choices: lunaryData.choices.map((choice: any) => ({
-      index: choice.index,
-      message: {
-        role: choice.message.role,
-        content: choice.message.content,
-        tool_calls: choice.message.tool_calls,
-      },
-      logprobs: choice.logprobs,
-      finish_reason: choice.finish_reason,
-    })),
-    usage: lunaryData.usage,
-    system_fingerprint: lunaryData.system_fingerprint,
-  };
-
-  if (stream) {
-    const encoder = new TextEncoder();
-    const stream = new ReadableStream({
-      async start(controller) {
-        // Simulate streaming by sending chunks of the content
-        // In a real streaming scenario, you would process the upstream
-        // stream and send chunks as they arrive. Since Lunary's playground
-        // doesn't stream, we'll break down the final response.
-
-        // Send the initial chunk with role and potential tool_calls if any
-        if (openaiFormattedResponse.choices && openaiFormattedResponse.choices.length > 0) {
-            const firstChoice = openaiFormattedResponse.choices[0];
-            const initialChunk = {
-                id: openaiFormattedResponse.id,
-                object: "chat.completion.chunk",
-                created: openaiFormattedResponse.created,
-                model: openaiFormattedResponse.model,
-                choices: [
-                    {
-                        index: 0,
-                        delta: {
-                            role: firstChoice.message.role,
-                            tool_calls: firstChoice.message.tool_calls // Include tool_calls if present
-                        },
-                        logprobs: firstChoice.logprobs, // Include logprobs if present
-                        finish_reason: null, // Indicate not finished yet
-                    }
-                ],
-                system_fingerprint: openaiFormattedResponse.system_fingerprint,
-            };
-             controller.enqueue(encoder.encode(`data: ${JSON.stringify(initialChunk)}\n\n`));
-
-            // Break down the content into smaller chunks
-            const content = firstChoice.message.content || "";
-            const chunkSize = 10; // Adjust chunk size as needed for a more realistic stream feel
-            for (let i = 0; i < content.length; i += chunkSize) {
-                const chunkContent = content.substring(i, i + chunkSize);
-                const contentChunk = {
-                     id: openaiFormattedResponse.id,
-                     object: "chat.completion.chunk",
-                     created: openaiFormattedResponse.created,
-                     model: openaiFormattedResponse.model,
-                     choices: [
-                         {
-                             index: 0,
-                             delta: {
-                                 content: chunkContent
-                             },
-                              logprobs: null, // Logprobs are typically not sent in content chunks
-                             finish_reason: null,
-                         }
-                     ],
-                     system_fingerprint: openaiFormattedResponse.system_fingerprint,
-                };
-                 controller.enqueue(encoder.encode(`data: ${JSON.stringify(contentChunk)}\n\n`));
-                 // Add a small delay to better simulate streaming
-                 await new Promise(resolve => setTimeout(resolve, 20)); // Adjust delay as needed
-            }
-
-             // Send the final chunk with the finish_reason
-             const finalChunk = {
-                  id: openaiFormattedResponse.id,
-                  object: "chat.completion.chunk",
-                  created: openaiFormattedResponse.created,
-                  model: openaiFormattedResponse.model,
-                  choices: [
-                      {
-                          index: 0,
-                          delta: {}, // Delta is empty for the last chunk
-                          logprobs: null,
-                          finish_reason: firstChoice.finish_reason,
-                      }
-                  ],
-                  system_fingerprint: openaiFormattedResponse.system_fingerprint,
-                  usage: openaiFormattedResponse.usage, // Include usage in the final chunk
-             };
-             controller.enqueue(encoder.encode(`data: ${JSON.stringify(finalChunk)}\n\n`));
+  try {
+    // 模型列表接口
+    if (path === "/v1/models" && req.method === "GET") {
+      return new Response(
+        JSON.stringify({
+          object: "list",
+          data: [
+            {
+              id: "chat-model-reasoning",
+              object: "model",
+              created: 0,
+              owned_by: "unlimitedai",
+              permission: [{
+                id: "modelperm-chat-model-reasoning",
+                object: "model_permission",
+                created: 0,
+                allow_create_engine: false,
+                allow_sampling: true,
+                allow_logprobs: false,
+                allow_search_indices: false,
+                allow_view: true,
+                allow_fine_tuning: false,
+                organization: "*",
+                group: null,
+                is_blocking: false,
+              }],
+              root: "chat-model-reasoning",
+              parent: null,
+            },
+          ],
+        }),
+        {
+          status: 200,
+          headers: {
+            "Content-Type": "application/json",
+            "Access-Control-Allow-Origin": "*",
+          },
         }
-
-
-        // Send the [DONE] marker
-        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-        controller.close();
-      },
-    });
-
-    return new Response(stream, {
-      headers: { "Content-Type": "text/event-stream" },
-    });
-  } else {
-    // Non-streaming: return the JSON response directly
-    return new Response(JSON.stringify(openaiFormattedResponse), {
-      headers: { "Content-Type": "application/json" },
-    });
+      );
+    }
+    
+    // 聊天完成接口
+    else if (path === "/v1/chat/completions" && req.method === "POST") {
+      const openaiBody = await req.json();
+      const isStream = openaiBody.stream === true;
+      
+      return await handleChatCompletions(openaiBody, isStream);
+    }
+    
+    // 未找到路由
+    else {
+      return new Response(
+        JSON.stringify({ error: "Not found", message: "Endpoint not supported" }),
+        {
+          status: 404,
+          headers: {
+            "Content-Type": "application/json",
+            "Access-Control-Allow-Origin": "*",
+          },
+        }
+      );
+    }
+  } catch (error) {
+    console.error("Request handling error:", error);
+    
+    return new Response(
+      JSON.stringify({ error: "Internal server error", message: error.message }),
+      {
+        status: 500,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+        },
+      }
+    );
   }
 }
 
-Deno.serve(handler);
+// 启动服务器
+console.log(`Starting server on port ${PORT}...`);
+serve(handler, { port: PORT });