Update main.ts

main.ts

@@ -1,217 +1,209 @@
-import { serve } from "https://deno.land/std@0.220.1/http/server.ts";
+// freeai_proxy.ts
+import { serve } from "https://deno.land/std@0.190.0/http/server.ts";
 
-// 定义常量
-const UNLIMITED_AI_URL = "https://app.unlimitedai.chat/api/chat";
-const PORT = 7860;
-const MAX_RETRIES = 3;
+const FREEAI_API_BASE = "https://freeaichatplayground.com/api/v1";
+const DEFAULT_MODEL = "Deepseek R1";
 
-// 定义接口
-interface UnlimitedAIMessage {
-  id: string;
-  createdAt: string;
-  role: string;
-  content: string;
-  parts: Array<{ type: string; text: string }>;
-}
+// 获取可用模型列表
+async function fetchModels() {
+  try {
+    const response = await fetch(`${FREEAI_API_BASE}/models`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:137.0) Gecko/20100101 Firefox/137.0",
+        "Origin": "https://freeaichatplayground.com",
+        "Referer": "https://freeaichatplayground.com/chat",
+      },
+      body: JSON.stringify({ type: "text" }),
+    });
 
-interface OpenAIMessage {
-  role: string;
-  content: string;
-}
+    if (!response.ok) {
+      throw new Error(`Failed to fetch models: ${response.status}`);
+    }
 
-// 将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." }],
-    });
+    const models = await response.json();
+    return models;
+  } catch (error) {
+    console.error("Error fetching models:", error);
+    return [];
   }
-  
-  // 添加其余非系统消息
-  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;
 }
 
-// 将OpenAI请求体转换为UnlimitedAI请求体
-function convertOpenAIToUnlimitedBody(openaiBody: any): any {
+// 转换为 OpenAI 格式的模型列表
+function transformModelsToOpenAIFormat(models) {
   return {
-    id: openaiBody.id || crypto.randomUUID(),
-    messages: convertOpenAIToUnlimitedMessages(openaiBody.messages),
-    selectedChatModel: openaiBody.model || "chat-model-reasoning",
+    object: "list",
+    data: models.map(model => ({
+      id: model.name,
+      object: "model",
+      created: new Date(model.createdAt).getTime() / 1000,
+      owned_by: model.provider,
+      permission: [],
+      root: model.name,
+      parent: null,
+    })),
   };
 }
 
-// 处理流式响应
-async function* transformStreamResponse(
-  reader: ReadableStreamDefaultReader<Uint8Array>
-): AsyncGenerator<string> {
-  let buffer = "";
-  const decoder = new TextDecoder();
-  let messageId = "";
-  let firstResult = true;
-
+// 解析 SSE 格式的响应
+async function parseSSEResponse(response) {
+  const reader = response.body.getReader();
+  let content = "";
+  let id = `chatcmpl-${Date.now()}`;
+  let finishReason = "stop";
+  
   try {
     while (true) {
       const { done, value } = await reader.read();
-      if (done) {
-        yield "data: [DONE]\n\n";
-        break;
-      }
+      if (done) 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";
+      const chunk = new TextDecoder().decode(value);
+      content += chunk;
+    }
+    
+    // 解析所有 SSE 消息
+    const messages = content.split('\n\n')
+      .filter(msg => msg.trim().startsWith('data:'))
+      .map(msg => {
+        const jsonStr = msg.replace('data:', '').trim();
+        try {
+          return JSON.parse(jsonStr);
+        } catch (e) {
+          console.warn("Failed to parse SSE message:", jsonStr);
+          return null;
         }
+      })
+      .filter(Boolean);
+    
+    // 找到最后一条完整消息
+    const lastCompleteMessage = messages.findLast(msg => 
+      msg.choices && msg.choices[0] && msg.choices[0].message && msg.choices[0].message.content
+    );
+    
+    if (lastCompleteMessage) {
+      id = lastCompleteMessage.id || id;
+      if (lastCompleteMessage.choices && 
+          lastCompleteMessage.choices[0] && 
+          lastCompleteMessage.choices[0].finish_reason) {
+        finishReason = lastCompleteMessage.choices[0].finish_reason;
+      }
+      
+      return {
+        id,
+        content: lastCompleteMessage.choices[0].message.content,
+        finish_reason: finishReason,
+        usage: lastCompleteMessage.usage || null
+      };
+    }
+    
+    // 如果没有找到完整消息，尝试从所有消息中提取内容
+    let combinedContent = "";
+    for (const msg of messages) {
+      if (msg.choices && msg.choices[0] && msg.choices[0].delta && msg.choices[0].delta.content) {
+        combinedContent += msg.choices[0].delta.content;
+      } else if (msg.choices && msg.choices[0] && msg.choices[0].message && msg.choices[0].message.content) {
+        combinedContent += msg.choices[0].message.content;
       }
     }
+    
+    return {
+      id,
+      content: combinedContent || "No content found in response",
+      finish_reason: finishReason,
+      usage: null
+    };
+    
   } catch (error) {
-    console.error("Stream transformation error:", error);
-    yield "data: [DONE]\n\n";
-  } finally {
-    reader.releaseLock();
+    console.error("Error parsing SSE response:", error);
+    return {
+      id,
+      content: "Error parsing response: " + error.message,
+      finish_reason: "error",
+      usage: null
+    };
   }
 }
 
-// 转换非流式响应
-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;
+// 发送聊天请求到 freeaichatplayground
+async function sendChatRequest(modelName, messages) {
+  try {
+    const formattedMessages = messages.map((msg, index) => ({
+      id: `${Date.now() + index}`,
+      role: msg.role,
+      content: msg.content,
+      model: {
+        id: "", // 这个ID会在下面被填充
+        name: modelName,
+        icon: "",
+        provider: "",
+        contextWindow: 63920
+      }
+    }));
+
+    // 获取模型列表以找到正确的ID
+    const models = await fetchModels();
+    const selectedModel = models.find(m => m.name === modelName);
     
-    const key = line.slice(0, idx);
-    let val = line.slice(idx + 1).trim();
-    try {
-      val = JSON.parse(val);
-    } catch (error) {
-      // 如果解析失败，保持原始字符串
+    if (!selectedModel) {
+      throw new Error(`Model "${modelName}" not found`);
     }
     
-    data[key] = val;
+    // 填充模型信息
+    formattedMessages.forEach(msg => {
+      if (msg.model) {
+        msg.model.id = selectedModel.id;
+        msg.model.icon = selectedModel.icon;
+        msg.model.provider = selectedModel.provider;
+      }
+    });
+
+    const response = await fetch(`${FREEAI_API_BASE}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:137.0) Gecko/20100101 Firefox/137.0",
+        "Origin": "https://freeaichatplayground.com",
+        "Referer": "https://freeaichatplayground.com/chat",
+      },
+      body: JSON.stringify({
+        model: modelName,
+        messages: formattedMessages,
+      }),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Chat completion failed: ${response.status} - ${errorText}`);
+    }
+
+    // 处理 SSE 流式响应
+    const parsedResponse = await parseSSEResponse(response);
+    return parsedResponse;
+  } catch (error) {
+    console.error("Error in chat completion:", error);
+    throw error;
   }
-  
-  const content = data["0"];
-  const reasoning_content = data.g;
-  
+}
+
+// 转换为 OpenAI 格式的聊天响应
+function transformChatResponseToOpenAIFormat(response, modelName) {
   return {
-    id: data.f?.messageId || crypto.randomUUID(),
+    id: response.id || `chatcmpl-${Date.now()}`,
     object: "chat.completion",
     created: Math.floor(Date.now() / 1000),
-    model: "chat-model-reasoning",
+    model: modelName,
     choices: [
       {
         index: 0,
         message: {
           role: "assistant",
-          reasoning_content,
-          content,
+          content: response.content,
         },
-        finish_reason: "stop",
+        finish_reason: response.finish_reason || "stop",
       },
     ],
-    usage: {
+    usage: response.usage || {
       prompt_tokens: 0,
       completion_tokens: 0,
       total_tokens: 0,
@@ -219,197 +211,227 @@ async function transformNonStreamResponse(text: string): Promise<any> {
   };
 }
 
-// 处理聊天完成请求
-async function handleChatCompletions(
-  openaiBody: any,
-  isStream: boolean,
-  retryCount = 0
-): Promise<Response> {
-  try {
-    // 转换为 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/"
-    };
+// 处理流式响应请求
+async function handleStreamRequest(request, modelName, messages) {
+  const encoder = new TextEncoder();
+  const formattedMessages = messages.map((msg, index) => ({
+    id: `${Date.now() + index}`,
+    role: msg.role,
+    content: msg.content,
+    model: {
+      id: "", // 这个ID会在下面被填充
+      name: modelName,
+      icon: "",
+      provider: "",
+      contextWindow: 63920
+    }
+  }));
 
-    // 获取 X-API-TOKEN
-    const XApiTokenRes = await fetch("https://app.unlimitedai.chat/api/token", {
-      method: "GET",
-      headers: upstreamHeaders
-    });
-    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),
-    });
-    
-    if (!upstreamRes.ok) {
-      throw new Error(`Chat completion failed: ${upstreamRes.status}`);
+  // 获取模型列表以找到正确的ID
+  const models = await fetchModels();
+  const selectedModel = models.find(m => m.name === modelName);
+  
+  if (!selectedModel) {
+    throw new Error(`Model "${modelName}" not found`);
+  }
+  
+  // 填充模型信息
+  formattedMessages.forEach(msg => {
+    if (msg.model) {
+      msg.model.id = selectedModel.id;
+      msg.model.icon = selectedModel.icon;
+      msg.model.provider = selectedModel.provider;
     }
-    
-    if (isStream) {
-      // 流式响应处理
-      const reader = upstreamRes.body?.getReader();
-      if (!reader) {
-        throw new Error("Failed to get response body reader");
-      }
+  });
+
+  const response = await fetch(`${FREEAI_API_BASE}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:137.0) Gecko/20100101 Firefox/137.0",
+      "Origin": "https://freeaichatplayground.com",
+      "Referer": "https://freeaichatplayground.com/chat",
+    },
+    body: JSON.stringify({
+      model: modelName,
+      messages: formattedMessages,
+      stream: true,
+    }),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Chat completion failed: ${response.status} - ${errorText}`);
+  }
+
+  const stream = new ReadableStream({
+    async start(controller) {
+      const reader = response.body.getReader();
+      const chatId = `chatcmpl-${Date.now()}`;
       
-      const transformedStream = new ReadableStream({
-        async start(controller) {
-          try {
-            for await (const chunk of transformStreamResponse(reader)) {
-              controller.enqueue(new TextEncoder().encode(chunk));
+      // 发送初始消息
+      const initialChunk = {
+        id: chatId,
+        object: "chat.completion.chunk",
+        created: Math.floor(Date.now() / 1000),
+        model: modelName,
+        choices: [{
+          index: 0,
+          delta: { role: "assistant" },
+          finish_reason: null
+        }]
+      };
+      controller.enqueue(encoder.encode(`data: ${JSON.stringify(initialChunk)}\n\n`));
+      
+      try {
+        let buffer = "";
+        
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          
+          const chunk = new TextDecoder().decode(value);
+          buffer += chunk;
+          
+          // 处理缓冲区中的所有完整 SSE 消息
+          const messages = buffer.split('\n\n');
+          buffer = messages.pop() || ""; // 保留最后一个可能不完整的消息
+          
+          for (const msg of messages) {
+            if (!msg.trim().startsWith('data:')) continue;
+            
+            try {
+              const jsonStr = msg.replace('data:', '').trim();
+              const data = JSON.parse(jsonStr);
+              
+              if (data.choices && data.choices[0]) {
+                // 转换为 OpenAI 流式格式
+                const openAIChunk = {
+                  id: chatId,
+                  object: "chat.completion.chunk",
+                  created: Math.floor(Date.now() / 1000),
+                  model: modelName,
+                  choices: [{
+                    index: 0,
+                    delta: {},
+                    finish_reason: data.choices[0].finish_reason || null
+                  }]
+                };
+                
+                // 提取内容
+                if (data.choices[0].delta && data.choices[0].delta.content) {
+                  openAIChunk.choices[0].delta.content = data.choices[0].delta.content;
+                } else if (data.choices[0].message && data.choices[0].message.content) {
+                  openAIChunk.choices[0].delta.content = data.choices[0].message.content;
+                }
+                
+                controller.enqueue(encoder.encode(`data: ${JSON.stringify(openAIChunk)}\n\n`));
+                
+                // 如果是最后一条消息，发送 [DONE]
+                if (data.choices[0].finish_reason) {
+                  controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+                }
+              }
+            } catch (e) {
+              console.warn("Failed to parse SSE message:", msg);
+              continue;
             }
-            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": "*",
-        },
-      });
+        }
+        
+        // 确保发送最终的 [DONE] 消息
+        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+        controller.close();
+      } catch (error) {
+        console.error("Stream processing error:", error);
+        controller.error(error);
+      }
     }
-  } 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": "*",
-        },
-      },
-    );
-  }
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive",
+      "Access-Control-Allow-Origin": "*",
+    }
+  });
 }
 
-// 主处理函数
-async function handler(req: Request): Promise<Response> {
-  const url = new URL(req.url);
+// 处理请求
+async function handleRequest(request) {
+  const url = new URL(request.url);
   const path = url.pathname;
 
-  // CORS预检请求处理
-  if (req.method === "OPTIONS") {
+  // CORS 预检请求处理
+  if (request.method === "OPTIONS") {
     return new Response(null, {
-      status: 204,
+      status: 200,
       headers: {
         "Access-Control-Allow-Origin": "*",
         "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
         "Access-Control-Allow-Headers": "Content-Type, Authorization",
-        "Access-Control-Max-Age": "86400",
       },
     });
   }
 
+  // 设置通用响应头
+  const headers = {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*",
+  };
+
   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": "*",
-          },
-        }
-      );
+    if (path === "/v1/models" && request.method === "GET") {
+      const models = await fetchModels();
+      const openAIModels = transformModelsToOpenAIFormat(models);
+      return new Response(JSON.stringify(openAIModels), { headers });
     }
     
     // 聊天完成接口
-    else if (path === "/v1/chat/completions" && req.method === "POST") {
-      const openaiBody = await req.json();
-      const isStream = openaiBody.stream === true;
+    else if (path === "/v1/chat/completions" && request.method === "POST") {
+      const requestData = await request.json();
+      const modelName = requestData.model || DEFAULT_MODEL;
+      const messages = requestData.messages || [];
+      const stream = requestData.stream || false;
       
-      return await handleChatCompletions(openaiBody, isStream);
+      // 处理流式响应
+      if (stream) {
+        return handleStreamRequest(request, modelName, messages);
+      }
+      
+      // 处理普通响应
+      const chatResponse = await sendChatRequest(modelName, messages);
+      const openAIResponse = transformChatResponseToOpenAIFormat(chatResponse, modelName);
+      
+      return new Response(JSON.stringify(openAIResponse), { headers });
     }
     
-    // 未找到路由
+    // 未知路径
     else {
-      return new Response(
-        JSON.stringify({ error: "Not found", message: "Endpoint not supported" }),
-        {
-          status: 404,
-          headers: {
-            "Content-Type": "application/json",
-            "Access-Control-Allow-Origin": "*",
-          },
+      return new Response(JSON.stringify({
+        error: {
+          message: "Not found",
+          type: "invalid_request_error",
+          code: "path_not_found",
         }
-      );
+      }), { status: 404, headers });
     }
   } 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": "*",
-        },
+    console.error("Error handling request:", error);
+    return new Response(JSON.stringify({
+      error: {
+        message: error.message,
+        type: "server_error",
+        code: "internal_server_error",
       }
-    );
+    }), { status: 500, headers });
   }
 }
 
 // 启动服务器
-console.log(`Starting server on port ${PORT}...`);
-serve(handler, { port: PORT });
+const port = parseInt(Deno.env.get("PORT") || "7860");
+console.log(`Starting server on port ${port}...`);
+serve(handleRequest, { port });