Update main.ts

main.ts

@@ -1,209 +1,202 @@
-// freeai_proxy.ts
-import { serve } from "https://deno.land/std@0.190.0/http/server.ts";
+import { serve } from "https://deno.land/std@0.220.1/http/server.ts";
 
-const FREEAI_API_BASE = "https://freeaichatplayground.com/api/v1";
-const DEFAULT_MODEL = "Deepseek R1";
+// 定义常量
+const BASE_URL = "https://api.codegpt.co/api";
+const PORT = 3000;
 
-// 获取可用模型列表
-async function fetchModels() {
+interface CodegptModel {
+  id: string;
+  org_id: string;
+  name: string;
+  model: string;
+}
+
+// 从请求头中获取API_KEY
+function getApiKeyFromRequest(req: Request): string | null {
+  const authHeader = req.headers.get("authorization");
+  if (!authHeader) return null;
+
+  // 支持 "Bearer sk-xxx" 或直接 "sk-xxx" 格式
+  const match = authHeader.match(/^(Bearer\s+)?(sk-[a-zA-Z0-9-]+)$/);
+  return match ? match[2] : null;
+}
+
+// 获取模型列表
+async function getModels(apiKey: string): Promise<CodegptModel[]> {
   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",
+    const response = await fetch(
+      `${BASE_URL}/v1/agent`,
+      {
+        method: "GET",
+        headers: {
+          "Accept": "application/json",
+          "Authorization": `Bearer ${apiKey}`,
+        },
       },
-      body: JSON.stringify({ type: "text" }),
-    });
+    );
 
     if (!response.ok) {
-      throw new Error(`Failed to fetch models: ${response.status}`);
+      const errorData = await response.json();
+      if (errorData.message === "Invalid credentials") {
+        throw new Error("🚀 ~ Your API key or access token is invalid.!");
+      }
+      throw new Error(`Failed to get models: ${response.status}`);
     }
 
-    const models = await response.json();
-    return models;
+    const data = await response.json();
+    // console.log("🚀 ~ codegpt agents 响应：", data);
+    return data;
   } catch (error) {
-    console.error("Error fetching models:", error);
-    return [];
+    console.error("Error getting models:", error);
+    throw error;
   }
 }
 
-// 转换为 OpenAI 格式的模型列表
-function transformModelsToOpenAIFormat(models) {
+
+// 将 codegpt agent 转换为 OpenAI model 格式
+function transformModelsToOpenAIFormat(models: CodegptModel[]) {
   return {
     object: "list",
-    data: models.map(model => ({
-      id: model.name,
+    data: models.map((model) => ({
+      id: model.id,
+      name: model.model,
       object: "model",
-      created: new Date(model.createdAt).getTime() / 1000,
-      owned_by: model.provider,
-      permission: [],
-      root: model.name,
+      created: Date.now(),
+      owned_by: "codegpt",
+      permission: [{
+        id: `modelperm-${model.model}`,
+        object: "model_permission",
+        created: Date.now(),
+        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: model.model,
       parent: null,
     })),
   };
 }
 
-// 解析 SSE 格式的响应
-async function parseSSEResponse(response) {
-  const reader = response.body.getReader();
-  let content = "";
-  let id = `chatcmpl-${Date.now()}`;
-  let finishReason = "stop";
-  
+// 处理聊天完成请求
+async function handleChatCompletions(
+  apiKey: string,
+  requestBody: any,
+  stream: boolean,
+) {
+
+  const CodegptBody = {
+    stream: stream,
+    agentId: requestBody.model,
+    messages: requestBody.messages,
+    format: "json",
+  };
+  // console.log("🚀 ~ 内部实际请求: ", CodegptBody);
+
+  const response = await fetch(
+    `${BASE_URL}/v1/chat/completions`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`,
+        "Accept": stream ? "text/event-stream" : "application/json",
+      },
+      body: JSON.stringify(CodegptBody),
+    },
+  );
+  // console.log("🚀 ~ 内部请求实际响应: \n", response);
+
+  if (!response.ok) {
+    throw new Error(`Chat completion failed: ${response.status}`);
+  }
+
+  return response;
+}
+
+// 转换流式响应
+async function* transformStreamResponse(
+  readableStream: ReadableStream<Uint8Array>,
+) {
+  const reader = readableStream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+
   try {
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
-      
-      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();
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        if (line.trim() === "" || !line.startsWith("data:")) continue;
+
+        const data = line.substring(5).trim();
+        if (data === "[DONE]") {
+          yield "data: [DONE]\n\n";
+          continue;
+        }
+
         try {
-          return JSON.parse(jsonStr);
+          const CodegptEvent = JSON.parse(data);
+
+          // 转换为OpenAI格式的事件
+          const openAIEvent = {
+            id: CodegptEvent.agentName || `chatcmpl-${Date.now()}`,
+            object: "chat.completion.chunk",
+            created: Math.floor(Date.now() / 1000),
+            model: CodegptEvent.model || CodegptEvent.agentName,
+            choices: [
+              {
+                index: 0,
+                delta: {
+                  reasoning_content: CodegptEvent.choices?.[0]?.delta?.contents?.[0]?.type === "think" ? CodegptEvent.choices[0].delta.contents[0].content || "" : "",
+                  content: CodegptEvent.choices?.[0]?.delta?.content || "",
+                },
+                finish_reason: CodegptEvent.choices?.[0]?.finish_reason || null,
+              },
+            ],
+          };
+
+          yield `data: ${JSON.stringify(openAIEvent)}\n\n`;
         } catch (e) {
-          console.warn("Failed to parse SSE message:", jsonStr);
-          return null;
+          console.error("Error parsing event:", e, "Line:", line);
         }
-      })
-      .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("Error parsing SSE response:", error);
-    return {
-      id,
-      content: "Error parsing response: " + error.message,
-      finish_reason: "error",
-      usage: null
-    };
+  } finally {
+    reader.releaseLock();
   }
 }
 
-// 发送聊天请求到 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);
-    
-    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;
-      }
-    });
+// 转换非流式响应
+async function transformNonStreamResponse(response: Response) {
+  const CodegptResponse = await response.json();
 
-    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;
-  }
-}
-
-// 转换为 OpenAI 格式的聊天响应
-function transformChatResponseToOpenAIFormat(response, modelName) {
   return {
-    id: response.id || `chatcmpl-${Date.now()}`,
+    id: CodegptResponse.id || `chatcmpl-${Date.now()}`,
     object: "chat.completion",
     created: Math.floor(Date.now() / 1000),
-    model: modelName,
+    model: CodegptResponse.model || CodegptResponse.agentName,
     choices: [
       {
         index: 0,
         message: {
           role: "assistant",
-          content: response.content,
+          content: CodegptResponse.choices?.[0]?.message?.content || "",
         },
-        finish_reason: response.finish_reason || "stop",
+        finish_reason: CodegptResponse.choices?.[0]?.finish_reason || "stop",
       },
     ],
-    usage: response.usage || {
+    usage: CodegptResponse.usage || {
       prompt_tokens: 0,
       completion_tokens: 0,
       total_tokens: 0,
@@ -211,227 +204,129 @@ function transformChatResponseToOpenAIFormat(response, modelName) {
   };
 }
 
-// 处理流式响应请求
-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
-    }
-  }));
-
-  // 获取模型列表以找到正确的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;
-    }
-  });
-
-  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}`);
-  }
+// 主处理函数
+async function handler(req: Request): Promise<Response> {
+  const url = new URL(req.url);
+  const path = url.pathname;
 
-  const stream = new ReadableStream({
-    async start(controller) {
-      const reader = response.body.getReader();
-      const chatId = `chatcmpl-${Date.now()}`;
-      
-      // 发送初始消息
-      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;
-            }
-          }
-        }
-        
-        // 确保发送最终的 [DONE] 消息
-        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-        controller.close();
-      } catch (error) {
-        console.error("Stream processing error:", error);
-        controller.error(error);
+  const apiKey = getApiKeyFromRequest(req);
+  if (!apiKey) {
+    return new Response(
+      // 没有填写 apikey 时返回的错误信息
+      JSON.stringify({ error: "Unauthorized", message: "Your API key or access token is invalid." }),
+      {
+        status: 401,
+        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 handleRequest(request) {
-  const url = new URL(request.url);
-  const path = url.pathname;
+    );
+  }
 
-  // CORS 预检请求处理
-  if (request.method === "OPTIONS") {
+  // CORS预检请求处理
+  if (req.method === "OPTIONS") {
     return new Response(null, {
-      status: 200,
+      status: 204,
       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" && request.method === "GET") {
-      const models = await fetchModels();
+    if (path === "/v1/models" && req.method === "GET") {
+      const models = await getModels(apiKey);
       const openAIModels = transformModelsToOpenAIFormat(models);
-      return new Response(JSON.stringify(openAIModels), { headers });
+      // console.log("🚀 ~ openAI格式models: ", openAIModels);
+
+      return new Response(JSON.stringify(openAIModels), {
+        status: 200,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+        },
+      });
     }
-    
+
     // 聊天完成接口
-    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;
-      
-      // 处理流式响应
+    else if (path === "/v1/chat/completions" && req.method === "POST") {
+      const requestBody = await req.json();
+      // console.log("🚀 ~ 外部客户端请求: ", requestBody);
+
+      const stream = requestBody.stream === true;
+
+      const codegptResponse = await handleChatCompletions(apiKey, requestBody, stream);
+
       if (stream) {
-        return handleStreamRequest(request, modelName, messages);
+        const transformedStream = new ReadableStream({
+          async start(controller) {
+            try {
+              for await (const chunk of transformStreamResponse(codegptResponse.body!)) {
+                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 transformedResponse = await transformNonStreamResponse(codegptResponse);
+
+        return new Response(JSON.stringify(transformedResponse), {
+          status: 200,
+          headers: {
+            "Content-Type": "application/json",
+            "Access-Control-Allow-Origin": "*",
+          },
+        });
       }
-      
-      // 处理普通响应
-      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: {
-          message: "Not found",
-          type: "invalid_request_error",
-          code: "path_not_found",
-        }
-      }), { status: 404, headers });
+      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("Error handling request:", error);
-    return new Response(JSON.stringify({
-      error: {
-        message: error.message,
-        type: "server_error",
-        code: "internal_server_error",
-      }
-    }), { status: 500, headers });
+    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": "*",
+        },
+      },
+    );
   }
 }
 
-// 启动服务器
-const port = parseInt(Deno.env.get("PORT") || "7860");
-console.log(`Starting server on port ${port}...`);
-serve(handleRequest, { port });
+console.log(`Starting server on port ${PORT}...`);
+serve(handler, { port: PORT });