Update main.ts

main.ts

@@ -1,352 +1,429 @@
-import { serve } from "https://deno.land/std@0.208.0/http/server.ts";
-
-// 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'
-];
-
-// Helper function to get Julep API Key from Authorization header
-function getJulepApiKey(req: Request): string | null {
-  const authHeader = req.headers.get("Authorization");
-  if (authHeader && authHeader.startsWith("Bearer ")) {
-    return authHeader.substring(7); // Extract the token after "Bearer "
-  }
-  return null;
-}
-
-// OpenAI Models endpoint handler (hardcoded)
-async function handleModels(req: Request): Promise<Response> {
-  const julepApiKey = getJulepApiKey(req);
-  if (!julepApiKey) {
-    return new Response("Unauthorized: Missing or invalid Authorization header", { status: 401 });
-  }
-
-  // Format hardcoded models into OpenAI models format
-  const openaiModels = HARDCODED_MODELS.map((modelId) => ({
-    id: modelId,
-    object: "model",
-    created: Math.floor(Date.now() / 1000), // Use current time for creation
-    owned_by: "julep", // Or "openai" if you prefer
-    permission: [
-      {
-        id: `modelperm-${modelId}`,
-        object: "model_permission",
-        created: Math.floor(Date.now() / 1000),
-        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,
-  }));
-
-  return new Response(JSON.stringify({ data: openaiModels, object: "list" }), {
-    headers: { "Content-Type": "application/json" },
-    status: 200,
-  });
-}
-
-// OpenAI Chat Completions endpoint handler
-async function handleChatCompletions(req: Request): Promise<Response> {
-  const julepApiKey = getJulepApiKey(req);
-  if (!julepApiKey) {
-    return new Response("Unauthorized: Missing or invalid Authorization header", { status: 401 });
-  }
-
-  const headers = {
-    "Authorization": `Bearer ${julepApiKey}`,
-    "Content-Type": "application/json",
-  };
-
-  let agentId: string | null = null; // Variable to store the created agent ID
-  let sessionId: string | null = null; // Variable to store the created session ID
-
-  try {
-    const requestBody = await req.json();
-    const { model, messages, stream, ...rest } = requestBody;
-
-    if (!model || !messages || !Array.isArray(messages) || messages.length === 0) {
-      return new Response("Invalid request body. 'model' and 'messages' are required.", { status: 400 });
+import { serve } from "https://deno.land/std@0.220.1/http/server.ts";
+
+// --- 配置常量 ---
+const AUTH_KEY = Deno.env.get("AUTH_KEY") ?? "default_api_key_value"; //API密钥在Environment Variables中添加，否则默认是default_api_key_value
+const TARGET_URL = 'https://assistant.on.adaptive.ai/api/sendMessage';
+const PROXY_MODEL_NAME = "gpt-4o"; // 代理服务返回的模型名称
+
+
+const TARGET_HEADERS = {
+    'content-type': 'application/json',
+    'x-channel-id': "0"
+};
+
+// --- 辅助函数：创建 SSE 数据块 ---
+function createSSEChunk(id: string, model: string, content: string | null, role: string | null, finish_reason: string | null): string {
+    const now = Math.floor(Date.now() / 1000);
+    const chunk: any = {
+        id: id,
+        object: "chat.completion.chunk",
+        created: now,
+        model: model,
+        choices: [
+            {
+                index: 0,
+                delta: {},
+                finish_reason: finish_reason,
+                logprobs: null,
+            }
+        ],
+        // system_fingerprint: null, // 可选
+    };
+    if (role) {
+        chunk.choices[0].delta.role = role;
     }
-
-    // Check if the requested model is in our hardcoded list
-    if (!HARDCODED_MODELS.includes(model)) {
-       return new Response(`Invalid model: ${model}. Please use one of the available models.`, { status: 400 });
+    if (content) {
+        chunk.choices[0].delta.content = content;
     }
-
-    // 1. Create a new Agent for this request
-    const createAgentUrl = `${JULEP_API_BASE}/agents`;
-    const createAgentBody = {
-      name: model, // Set agent name to the model value
-      model: model, // Use the requested OpenAI model as the Julep Agent's model
-      about: model, // Set agent about to the model value
-      instructions: ["Follow user instructions carefully."], // Keep some default instructions
-    };
-
-    const createAgentResponse = await fetch(createAgentUrl, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(createAgentBody),
-    });
-
-    if (!createAgentResponse.ok) {
-      const errorText = await createAgentResponse.text();
-      console.error(`Error creating Julep Agent: ${createAgentResponse.status} - ${errorText}`);
-      return new Response(`Error creating Julep Agent: ${createAgentResponse.statusText}`, { status: createAgentResponse.status });
+    // 如果 delta 为空且有 finish_reason，确保 delta 是空对象
+    if (!role && !content && finish_reason) {
+        chunk.choices[0].delta = {};
     }
 
-    const agentData = await createAgentResponse.json();
-    agentId = agentData.id; // Store the agent ID
+    return `data: ${JSON.stringify(chunk)}\n\n`;
+}
 
-    // 2. Create a Session using the new Agent ID
-    const createSessionUrl = `${JULEP_API_BASE}/sessions`;
-    const createSessionBody = {
-      agent: agentId, // Use the newly created Agent ID
-      // You can add other Session creation parameters here if needed
+/**
+ * 向 Adaptive AI 发送创建新聊天的请求。
+ * 成功时返回新聊天的 ID (字符串)。
+ * 如果在过程中发生任何错误，则捕获错误并返500。
+ *
+ * @returns {Promise<string | 500>} 返回成功创建的聊天的 ID (string)，或在失败时返回 500。
+ */
+async function createChatAndGetId(): Promise<string> {
+    const url = 'https://assistant.on.adaptive.ai/api/createChat';
+    // 定义请求头 (省略了 cookie 和 priority)
+    const headers = {
+        'content-type': 'application/json',
     };
-
-    const createSessionResponse = await fetch(createSessionUrl, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(createSessionBody),
-    });
-
-    if (!createSessionResponse.ok) {
-      const errorText = await createSessionResponse.text();
-      console.error(`Error creating Julep Session: ${createSessionResponse.status} - ${errorText}`);
-      // Attempt to clean up the temporary agent
-      if (agentId) {
-         fetch(`${JULEP_API_BASE}/agents/${agentId}`, { method: "DELETE", headers }).catch(console.error);
-      }
-      return new Response(`Error creating Julep Session: ${createSessionResponse.statusText}`, { status: createSessionResponse.status });
+    // 构建请求体，使用当前时间戳作为请求 ID
+    const payload = {
+        json: {
+            jsonrpc: "2.0",
+            id: Date.now(), // 使用动态 ID
+            method: "createChat",
+            params: []
+        }
+    };
+    console.log("正在发送创建聊天请求...");
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: headers,
+            body: JSON.stringify(payload) // 将 payload 对象转换为 JSON 字符串
+        });
+        // 检查 HTTP 响应状态码是否表示成功
+        if (!response.ok) {
+            let errorBody = "无法读取响应体";
+            try {
+                errorBody = await response.text(); // 尝试读取错误响应体
+            } catch (readError) {
+                console.warn("读取错误响应体失败:", readError);
+            }
+            throw new Error(`创建聊天请求失败，HTTP 状态码: ${response.status}. 响应: ${errorBody}`);
+        }
+        // 解析 JSON 响应体
+        let responseData: any;
+        try {
+            responseData = await response.json();
+        } catch (parseError) {
+            // 如果响应不是有效的 JSON，则抛出错误
+            console.error("解析创建聊天响应 JSON 时出错:", parseError);
+            throw new Error(`无法将响应解析为 JSON: ${parseError.message}`);
+        }
+        // 提取并验证 ID
+        // ID 预期在 responseData.json.result.id
+        // 使用可选链操作符 (?.) 来安全地访问嵌套属性，防止因中间属性不存在而报错
+        const chatId = responseData?.json?.result?.id;
+        // 检查提取到的 ID 是否是一个有效的、非空的字符串
+        if (typeof chatId === 'string' && chatId.length > 0) {
+            console.log(`成功创建聊天，获取到 ID: ${chatId}`);
+            return chatId; // 返回提取到的 ID
+        } else {
+            // 如果 ID 不存在或格式不正确，则抛出错误
+            console.error("从响应中未能提取有效的聊天 ID。响应数据:", JSON.stringify(responseData));
+            throw new Error("创建聊天的响应格式无效或缺少 'json.result.id' 字段。");
+        }
+    } catch (error) {
+        // 捕获 try 块中抛出的任何错误，或 fetch 本身的网络错误
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error("执行 createChatAndGetId 时发生错误:", errorMessage); // 记录详细错误信息
+        // 创建并返回一个 Response 对象
+        // 状态码为 500 (Internal Server Error)
+        // 响应体为 JSON 格式，包含错误信息
+        return new Response(
+            JSON.stringify({ error: `创建聊天会话失败: ${errorMessage}` }), // 将错误信息包装在 JSON 对象中
+            {
+                status: 500, // 设置 HTTP 状态码为 500
+                headers: {
+                    "Content-Type": "application/json", // 设置响应内容类型为 JSON
+                    "Access-Control-Allow-Origin": "*" // 如果需要跨域，添加此头
+                }
+            }
+        );
     }
 
-    const sessionData = await createSessionResponse.json();
-    sessionId = sessionData.id; // Store the session ID
-
-    // 3. Perform Chat Completion
-    const chatUrl = `${JULEP_API_BASE}/sessions/${sessionId}/chat`;
-    const chatBody = {
-      messages: messages.map((msg: any) => ({
-        role: msg.role,
-        content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content), // Handle potential object content
-        // Map other relevant fields if necessary
-      })),
-      stream: stream === true,
-      ...rest, // Forward any other parameters from the OpenAI request
-    };
+}
 
-    const chatResponse = await fetch(chatUrl, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(chatBody),
-    });
-
-    // 4. Handle Response and Clean Up
-    if (!chatResponse.ok) {
-      // If the chat request itself fails, read the error body and then clean up
-      const errorText = await chatResponse.text();
-      console.error(`Error during Julep Chat Completion: ${chatResponse.status} - ${errorText}`);
-      // Attempt to clean up the temporary agent and session
-      if (sessionId) {
-         fetch(`${JULEP_API_BASE}/sessions/${sessionId}`, { method: "DELETE", headers }).catch(console.error);
-      }
-      if (agentId) {
-         fetch(`${JULEP_API_BASE}/agents/${agentId}`, { method: "DELETE", headers }).catch(console.error);
-      }
-      return new Response(`Error during Julep Chat Completion: ${chatResponse.statusText} - ${errorText}`, { status: chatResponse.status });
+// --- 主处理函数 ---
+async function handler(req: Request): Promise<Response> {
+    const url = new URL(req.url);
+
+    // --- CORS 预检请求处理 ---
+    if (req.method === "OPTIONS") {
+        return new Response(null, {
+            status: 204,
+            headers: {
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Methods": "POST, OPTIONS",
+                "Access-Control-Allow-Headers": "Content-Type, Authorization",
+                "Access-Control-Max-Age": "86400",
+            },
+        });
     }
 
-    if (stream) {
-      // Handle streaming response (Server-Sent Events)
-      // Pipe the Julep response body directly to the client response body
-      // and add cleanup to the end of the stream.
-      const readableStream = chatResponse.body!.pipeThrough(new TextDecoderStream()).pipeThrough(new TransformStream({
-        transform(chunk, controller) {
-          // Parse Julep streaming chunks and format as OpenAI SSE
-          const lines = chunk.split('\n').filter(line => line.trim() !== '');
-          for (const line of lines) {
-            if (line.startsWith('data:')) {
-              const data = JSON.parse(line.substring(5).trim());
-              // Format the Julep chunk data into OpenAI SSE format
-              const openaiChunk = {
-                id: data.id,
-                object: "chat.completion.chunk",
-                created: Math.floor(new Date(data.created_at).getTime() / 1000),
-                model: model, // Use the requested model ID
-                choices: data.choices.map((choice: any) => ({
-                  index: choice.index,
-                  delta: {
-                    role: choice.delta.role,
-                    content: choice.delta.content,
-                    tool_calls: choice.delta.tool_calls ? toolCallDeltaToOpenAI(choice.delta.tool_calls) : undefined,
-                  },
-                  finish_reason: choice.finish_reason,
-                })),
-              };
-              controller.enqueue(`data: ${JSON.stringify(openaiChunk)}\n\n`);
-            } else {
-               // Pass through non-data lines like comments or empty lines if needed
-               controller.enqueue(`${line}\n`);
+
+    // 模型列表接口
+    if (url.pathname === "/v1/models" && req.method === "GET") {
+        return new Response(
+            JSON.stringify({
+                object: "list",
+                data: [
+                    {
+                        id: "gpt-4o",
+                        object: "model",
+                        created: 0,
+                        owned_by: "unlimitedai",
+                        permission: [{
+                            id: "modelperm-gpt-4o",
+                            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: "gpt-4o",
+                        parent: null,
+                    },
+                ],
+            }),
+            {
+                status: 200,
+                headers: {
+                    "Content-Type": "application/json",
+                    "Access-Control-Allow-Origin": "*",
+                },
             }
-          }
-        },
-      }));
-
-      // Attach cleanup to the end of the stream
-      // We need to duplicate the stream to be able to pipe it to the client response
-      // AND to a WritableStream for cleanup.
-      const [stream1, stream2] = readableStream.tee();
-
-      const cleanupPromise = new Promise<void>((resolve, reject) => {
-          stream2.pipeTo(new WritableStream({
-              close: () => {
-                  if (sessionId) {
-                     fetch(`${JULEP_API_BASE}/sessions/${sessionId}`, { method: "DELETE", headers }).catch(console.error);
-                  }
-                  if (agentId) {
-                     fetch(`${JULEP_API_BASE}/agents/${agentId}`, { method: "DELETE", headers }).catch(console.error);
-                  }
-                  resolve();
-              },
-              abort: (reason) => {
-                  console.error("Stream aborted:", reason);
-                   if (sessionId) {
-                     fetch(`${JULEP_API_BASE}/sessions/${sessionId}`, { method: "DELETE", headers }).catch(console.error);
-                  }
-                  if (agentId) {
-                     fetch(`${JULEP_API_BASE}/agents/${agentId}`, { method: "DELETE", headers }).catch(console.error);
-                  }
-                  reject(reason);
-              }
-          })).catch(reject);
-      });
-
-      // Return the response with the first stream.
-       return new Response(stream1, {
-        headers: {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          "Connection": "keep-alive",
-        },
-        status: 200,
-      });
-
-    } else {
-      // Handle non-streaming response
-      const julepChatData = await chatResponse.json();
-
-      const openaiCompletion = {
-        id: julepChatData.id,
-        object: "chat.completion",
-        created: Math.floor(new Date(julepChatData.created_at).getTime() / 1000),
-        model: model, // Use the requested model ID
-        choices: julepChatData.choices.map((choice: any) => ({
-          index: choice.index,
-          message: {
-            role: choice.message.role,
-            content: choice.message.content,
-            tool_calls: choice.message.tool_calls ? toolCallMessageToOpenAI(choice.message.tool_calls) : undefined,
-          },
-          finish_reason: choice.finish_reason,
-        })),
-        usage: julepChatData.usage ? {
-          prompt_tokens: julepChatData.usage.prompt_tokens,
-          completion_tokens: julepChatData.usage.completion_tokens,
-          total_tokens: julepChatData.usage.total_tokens,
-        } : undefined,
-      };
-
-      // Attempt to clean up the temporary agent and session (fire and forget)
-      if (sessionId) {
-         fetch(`${JULEP_API_BASE}/sessions/${sessionId}`, { method: "DELETE", headers }).catch(console.error);
-      }
-      if (agentId) {
-         fetch(`${JULEP_API_BASE}/agents/${agentId}`, { method: "DELETE", headers }).catch(console.error);
-      }
-
-      return new Response(JSON.stringify(openaiCompletion), {
-        headers: { "Content-Type": "application/json" },
-        status: 200,
-      });
+        );
     }
 
-  } catch (error) {
-    console.error("Error handling chat completions request:", error);
-    // Attempt to clean up in case of errors before session/agent creation
-     if (sessionId) {
-         fetch(`${JULEP_API_BASE}/sessions/${sessionId}`, { method: "DELETE", headers }).catch(console.error);
-      }
-      if (agentId) {
-         fetch(`${Julep_API_BASE}/agents/${agentId}`, { method: "DELETE", headers }).catch(console.error);
-      }
-    return new Response("Internal Server Error", { status: 500 });
-  }
-}
-
-// Helper to format Julep ToolCall delta to OpenAI format
-function toolCallDeltaToOpenAI(julepToolCalls: any[]): any[] {
-  return julepToolCalls.map(toolCall => {
-    // Assuming Julep's delta format for tool_calls is similar to the message format
-    // and contains function objects directly. Adjust if necessary.
-    return {
-      id: toolCall.id,
-      type: "function",
-      function: {
-        name: toolCall.function?.name,
-        arguments: toolCall.function?.arguments, // Arguments might be streamed as chunks
-      },
-    };
-  });
-}
+    // --- 路径和方法检查 ---
+    if (url.pathname !== "/v1/chat/completions" || req.method !== "POST") {
+        return new Response(JSON.stringify({ error: "Not Found or Method Not Allowed" }), {
+            status: 404,
+            headers: {
+                "Content-Type": "application/json",
+                "Access-Control-Allow-Origin": "*",
+            },
+        });
+    }
+    // --- 添加认证检查 ---
+    const authHeader = req.headers.get("Authorization");
+    let providedKey = "";
+    // 检查 Authorization header 是否存在且格式正确 (Bearer <key>)
+    if (!authHeader || !authHeader.toLowerCase().startsWith("bearer ")) {
+        console.warn(`认证失败: 缺少或格式错误的 Authorization header`);
+        return new Response(JSON.stringify({
+            error: {
+                message: "Unauthorized: Missing or invalid Authorization header. Use 'Bearer <YOUR_API_KEY>' format.",
+                type: "invalid_request_error",
+                param: null,
+                code: "missing_or_invalid_header"
+            }
+        }), {
+            status: 401, // Unauthorized
+            headers: {
+                "Content-Type": "application/json",
+                "Access-Control-Allow-Origin": "*",
+                "WWW-Authenticate": 'Bearer realm="API Access"'
+            }
+        });
+    }
+    // 提取 key 部分
+    providedKey = authHeader.substring(7); // "Bearer ".length is 7
+    console.log("providedKey：" + providedKey);
+    // 直接比较提供的 key 和硬编码的 key
+    if (providedKey !== AUTH_KEY) {
+        console.warn(`认证失败: 无效的 API Key 提供`);
+        return new Response(JSON.stringify({
+            error: {
+                message: "Unauthorized: Invalid API Key provided.",
+                type: "invalid_request_error",
+                param: null,
+                code: "inAUTH_KEY"
+            }
+        }), {
+            status: 401, // Unauthorized
+            headers: {
+                "Content-Type": "application/json",
+                "Access-Control-Allow-Origin": "*",
+                "WWW-Authenticate": 'Bearer realm="API Access"'
+            }
+        });
+    }
 
-// Helper to format Julep ToolCall message to OpenAI format
-function toolCallMessageToOpenAI(julepToolCalls: any[]): any[] {
-  return julepToolCalls.map(toolCall => {
-    return {
-      id: toolCall.id,
-      type: "function",
-      function: {
-        name: toolCall.function?.name,
-        arguments: toolCall.function?.arguments, // Arguments should be complete in non-streaming
-      },
-    };
-  });
+    // --- 处理 POST 请求 ---
+    try {
+
+        // 1. 解析入站请求体
+        let requestBody: any;
+        try {
+            requestBody = await req.json();
+            console.log(requestBody)
+        } catch (e) {
+            console.error("Failed to parse request JSON:", e);
+            return new Response(JSON.stringify({ error: "Invalid JSON in request body" }), {
+                status: 400, headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
+            });
+        }
+
+        // 2. 检查是否请求流式响应
+        const isStream = requestBody.stream === true;
+
+        // 3. 提取用户输入的内容 - 将 messages 数组转换为字符串
+        let userContent: string | undefined;
+        if (Array.isArray(requestBody.messages) && requestBody.messages.length > 0) {
+            try {
+                // 直接将整个 messages 数组转换为 JSON 字符串
+                userContent = JSON.stringify(requestBody.messages);
+            } catch (e) {
+                console.error("Failed to stringify 'messages' array:", e);
+                // 如果 JSON.stringify 失败 (虽然对数组不太可能，但以防万一)
+                return new Response(JSON.stringify({ error: "Failed to process 'messages' array." }), {
+                    status: 400, headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
+                });
+            }
+        }
+        // 检查 userContent 是否成功生成
+        // 如果 requestBody.messages 不存在、不是数组、为空，或者转换出错，userContent 会是 undefined
+        if (!userContent) {
+            console.error("Request body must contain a non-empty 'messages' array.");
+            return new Response(JSON.stringify({ error: "Request body must contain a non-empty 'messages' array." }), {
+                status: 400, headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
+            });
+        }
+
+        // 现在 userContent 包含了��个对话历史的字符串表示
+        console.log("Formatted user content:", userContent); // 可以取消注释来调试输出
+
+        const CHAT_ID = await createChatAndGetId();//获取新的聊天ID
+
+
+        // 4. 构建目标 API Payload
+        const payload = {
+            json: {
+                jsonrpc: "2.0", id: Date.now(), method: "sendMessage",
+                params: [{ chatId: CHAT_ID, content: userContent, fileId: null, fileIds: [] }]
+            },
+            meta: { values: { "params.0.fileId": ["undefined"] } }
+        };
+
+        // 5. 发送请求到目标 API (无论是否流式，都需要先获取完整响应)
+        console.log("Forwarding request to:", TARGET_URL);
+        const targetResponse = await fetch(TARGET_URL, {
+            method: 'POST', headers: TARGET_HEADERS, body: JSON.stringify(payload),
+        });
+
+        // 6. 处理目标 API 的响应
+        if (!targetResponse.ok) {
+            const errorBody = await targetResponse.text();
+            console.error(`Target API Error (${targetResponse.status}):`, errorBody);
+            // 即使是流式请求失败，也返回 JSON 错误
+            return new Response(JSON.stringify({ error: `Upstream API request failed with status ${targetResponse.status}`, details: errorBody }), {
+                status: 502, headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
+            });
+        }
+
+        // 7. 解析目标 API 的 JSON 响应
+        let targetData: any;
+        try {
+            targetData = await targetResponse.json();
+        } catch (e) {
+            console.error("Failed to parse target API response JSON:", e);
+            // 即使是流式请求失败，也返回 JSON 错误
+            return new Response(JSON.stringify({ error: "Failed to parse upstream API response" }), {
+                status: 500, headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
+            });
+        }
+
+        // 8. 从目标响应中提取内容
+        const assistantContent = targetData?.json?.result?.content;
+        if (typeof assistantContent !== 'string') {
+            console.error("Could not extract 'content' from target API response:", JSON.stringify(targetData));
+            // 即使是流式请求失败，也返回 JSON 错误
+            return new Response(JSON.stringify({ error: "Invalid response format from upstream API" }), {
+                status: 500, headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
+            });
+        }
+
+        // 9. 根据 isStream 决定返回格式
+        const chatCompletionId = `chatcmpl-${crypto.randomUUID()}`; // 为本次交互生成唯一 ID
+        const modelName = requestBody.model || PROXY_MODEL_NAME; // 确定模型名称
+
+        if (isStream) {
+            // --- 返回模拟的流式响应 ---
+            console.log("Simulating stream response...");
+            const encoder = new TextEncoder();
+            const stream = new ReadableStream({
+                async start(controller) {
+                    try {
+                        // 模拟发送块
+                        // 块 1: 发送角色信息
+                        controller.enqueue(encoder.encode(
+                            createSSEChunk(chatCompletionId, modelName, null, "assistant", null)
+                        ));
+                        await new Promise(resolve => setTimeout(resolve, 10)); // 短暂延迟，模拟处理
+
+                        // 块 2: 发送完整内容
+                        controller.enqueue(encoder.encode(
+                            createSSEChunk(chatCompletionId, modelName, assistantContent, null, null)
+                        ));
+                        await new Promise(resolve => setTimeout(resolve, 10)); // 短暂延迟
+
+                        // 块 3: 发送结束信号
+                        controller.enqueue(encoder.encode(
+                            createSSEChunk(chatCompletionId, modelName, null, null, "stop")
+                        ));
+
+                        // 发送 [DONE] 标记
+                        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+
+                        // 关闭流
+                        controller.close();
+                    } catch (error) {
+                        console.error("Error during stream simulation:", error);
+                        controller.error(error); // 通知流出错了
+                    }
+                }
+            });
+
+            return new Response(stream, {
+                status: 200,
+                headers: {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'keep-alive', // 建议 SSE 使用
+                    'Access-Control-Allow-Origin': '*'
+                },
+            });
+
+        } else {
+            // --- 返回完整的 JSON 响应 ---
+            console.log("Returning non-stream response.");
+            const finalResponse = {
+                id: chatCompletionId,
+                object: "chat.completion",
+                created: Math.floor(Date.now() / 1000),
+                model: modelName,
+                choices: [
+                    {
+                        index: 0,
+                        message: {
+                            role: "assistant",
+                            content: assistantContent,
+                        },
+                        finish_reason: "stop",
+                        logprobs: null,
+                    }
+                ],
+                usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+            };
+
+            return new Response(JSON.stringify(finalResponse), {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Access-Control-Allow-Origin': '*'
+                },
+            });
+        }
+
+    } catch (error) {
+        // --- 全局错误处理 ---
+        console.error("Unhandled error in handler:", error);
+        // 即使请求流式，也返回 JSON 错误
+        return new Response(JSON.stringify({ error: "Internal Server Error" }), {
+            status: 500,
+            headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
+        });
+    }
 }
 
-// Main request handler
-async function handler(req: Request): Promise<Response> {
-  const url = new URL(req.url);
-
-  if (url.pathname === "/v1/models" && req.method === "GET") {
-    return handleModels(req);
-  } else if (url.pathname === "/v1/chat/completions" && req.method === "POST") {
-    return handleChatCompletions(req);
-  } else {
-    return new Response("Not Found", { status: 404 });
-  }
-}
 
-console.log(`HTTP server running on http://localhost:8000`);
-serve(handler, { port: 7860 });
+serve(handler);