Update main.ts

main.ts

@@ -1,427 +1,795 @@
 import { serve } from "https://deno.land/[email protected]/http/server.ts";
 
 // 定义常量
-const API_URL = "https://mcp.scira.ai/api/chat";
-const FIXED_USER_ID = "2jFMDM1A1R_XxOTxPjhwe";
-const FIXED_CHAT_ID = "ZIWa36kd6MSqzw-ifXGzE";
-const DEFAULT_MODEL = "qwen-qwq";
+const SOPHNET_BASE_URL = "https://www.sophnet.com/api";
+const PROJECT_UUID = "Ar79PWUQUAhjJOja2orHs";
 const PORT = 7860;
+const TOKEN_KEY = "sophnet_anonymous_token";
+const MAX_RETRIES = 5; // 增加最大重试次数
+const INITIAL_RETRY_DELAY_MS = 100; // 初始重试延迟（毫秒）
+const MAX_RETRY_DELAY_MS = 5000; // 最大重试延迟（毫秒）
+
+// 初始化Deno KV
+const kv = await Deno.openKv();
 
 // 定义接口
+interface AnonymousTokenResponse {
+  status: number;
+  message: string;
+  result: {
+    anonymousToken: string;
+    expires: string;
+  };
+  timestamp: number;
+}
+
+interface SophNetModel {
+  id: number;
+  serviceUuid: string | null;
+  projectUuid: string;
+  displayName: string;
+  modelFamily: string;
+  available: boolean;
+  isBaseModel: boolean;
+  features: any;
+  supportedStream: boolean;
+  supportedImageInputs: boolean;
+  schema: Array<{
+    name: string;
+    displayName: string;
+    des: string;
+    type: string;
+    range: number[];
+    defaultValue: number;
+    required: boolean;
+  }>;
+}
+
+interface ModelsResponse {
+  status: number;
+  message: string;
+  result: SophNetModel[];
+  timestamp: number;
+}
+
+interface TokenInfo {
+  token: string;
+  expires: string;
+}
+
 interface Message {
   role: string;
   content: string;
-  parts?: Array<{
-    type: string;
-    text: string;
-  }>;
 }
 
-interface SciraPayload {
+interface Reference {
+  content: string;
   id: string;
-  messages: Message[];
-  selectedModel: string;
-  mcpServers: any[];
-  chatId: string;
-  userId: string;
+  index: number;
+  title: string;
+  type: string;
+  url: string;
 }
 
-interface OpenAIModel {
-  id: string;
-  created: number;
-  object: string;
+// 随机生成一个用户代理字符串
+function getRandomUserAgent(): string {
+  const userAgents = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36 Edg/119.0.2151.44",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/119.0",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/119.0",
+    "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/119.0",
+  ];
+  return userAgents[Math.floor(Math.random() * userAgents.length)];
+}
+
+// 计算指数退避延迟
+function getExponentialBackoffDelay(retryCount: number): number {
+  const delay = INITIAL_RETRY_DELAY_MS * Math.pow(2, retryCount);
+  const jitter = Math.random() * INITIAL_RETRY_DELAY_MS; // 添加随机抖动
+  return Math.min(delay + jitter, MAX_RETRY_DELAY_MS);
+}
+
+// 延迟函数
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// 从KV获取token
+async function getTokenFromKV(): Promise<TokenInfo | null> {
+  const tokenEntry = await kv.get<TokenInfo>([TOKEN_KEY]);
+  return tokenEntry.value;
+}
+
+// 存储token到KV
+async function storeTokenToKV(token: string, expires: string): Promise<void> {
+  await kv.set([TOKEN_KEY], { token, expires });
 }
 
-// 可用模型列表
-const AVAILABLE_MODELS: OpenAIModel[] = [
-  {
-    id: "qwen-qwq",
-    created: Date.now(),
-    object: "model",
-  },
-  {
-    id: "gemini-2.5-flash",
-    created: Date.now(),
-    object: "model",
-  },
-  {
-    id: "gpt-4.1-mini",
-    created: Date.now(),
-    object: "model",
-  },
-  {
-    id: "claude-3-7-sonnet",
-    created: Date.now(),
-    object: "model",
-  },
-];
-
-// 格式化消息为Scira格式
-function formatMessagesForScira(messages: Message[]): Message[] {
-  return messages.map(msg => ({
-    role: msg.role,
-    content: msg.content,
-    parts: [{
-      type: "text",
-      text: msg.content
-    }]
-  }));
+// 获取匿名token
+async function getAnonymousToken(retryCount = 0): Promise<string> {
+  try {
+    const response = await fetch(`${SOPHNET_BASE_URL}/sys/login/anonymous`, {
+      method: "GET",
+      headers: {
+        "Accept": "application/json",
+        "User-Agent": getRandomUserAgent(), // 使用随机UA
+      },
+    });
+
+    // 如果是 429 或 500 错误，进行重试
+    if ((response.status === 429 || response.status >= 500) && retryCount < MAX_RETRIES) {
+      const delay = getExponentialBackoffDelay(retryCount);
+      console.warn(`Get token failed with status ${response.status}. Retrying in ${delay}ms... (${retryCount + 1}/${MAX_RETRIES})`);
+      await sleep(delay);
+      return getAnonymousToken(retryCount + 1);
+    }
+
+    if (!response.ok) {
+      throw new Error(`Failed to get token: ${response.status}`);
+    }
+
+    const data = await response.json() as AnonymousTokenResponse;
+    await storeTokenToKV(data.result.anonymousToken, data.result.expires);
+    return data.result.anonymousToken;
+  } catch (error) {
+    console.error("Error getting anonymous token:", error);
+    throw error;
+  }
+}
+
+// 获取有效token
+async function getValidToken(): Promise<string> {
+  // 先尝试从KV获取
+  const tokenInfo = await getTokenFromKV();
+
+  // 如果KV中有token且未过期，则使用该token
+  if (tokenInfo && new Date(tokenInfo.expires) > new Date()) {
+    return tokenInfo.token;
+  }
+
+  // 否则获取新token
+  return await getAnonymousToken();
+}
+
+// 获取模型列表
+async function getModels(token: string, retryCount = 0): Promise<SophNetModel[]> {
+  try {
+    const response = await fetch(
+      `${SOPHNET_BASE_URL}/public/playground/models?projectUuid=${PROJECT_UUID}`,
+      {
+        method: "GET",
+        headers: {
+          "Accept": "application/json",
+          "User-Agent": getRandomUserAgent(), // 使用随机UA
+          "Authorization": `Bearer anon-${token}`,
+        },
+      },
+    );
+
+    // 如果是401或403错误，尝试刷新token并重试
+    if ((response.status === 401 || response.status === 403) && retryCount < MAX_RETRIES) {
+      console.log(`Token expired, refreshing and retrying models request (${retryCount + 1}/${MAX_RETRIES})...`);
+      const newToken = await getAnonymousToken();
+      return await getModels(newToken, retryCount + 1);
+    }
+    
+    // 如果是 429 或 500 错误，进行重试
+    if ((response.status === 429 || response.status >= 500) && retryCount < MAX_RETRIES) {
+        const delay = getExponentialBackoffDelay(retryCount);
+        console.warn(`Get models failed with status ${response.status}. Retrying in ${delay}ms... (${retryCount + 1}/${MAX_RETRIES})`);
+        await sleep(delay);
+        return getModels(token, retryCount + 1); // 使用当前token重试，如果失败会在上面的逻辑中刷新
+    }
+
+    if (!response.ok) {
+      throw new Error(`Failed to get models: ${response.status}`);
+    }
+
+    const data = await response.json() as ModelsResponse;
+
+    // 请求成功后获取新token并存储 (后台刷新)
+    getAnonymousToken().catch(err => console.error("Background token refresh failed:", err));
+
+    return data.result;
+  } catch (error) {
+    console.error("Error getting models:", error);
+    throw error;
+  }
 }
 
-// 构建Scira请求负载
-function buildSciraPayload(messages: Message[], model = DEFAULT_MODEL): SciraPayload {
-  const formattedMessages = formatMessagesForScira(messages);
+// 将SophNet模型转换为OpenAI格式
+function transformModelsToOpenAIFormat(models: SophNetModel[]) {
+  const transformedModels = [];
+
+  // 为每个模型创建标准版本、搜索版本和全上下文版本
+  for (const model of models) {
+    // 添加标准模型
+    transformedModels.push({
+      id: model.modelFamily,
+      object: "model",
+      created: Date.now(),
+      owned_by: "sophnet",
+      permission: [{
+        id: `modelperm-${model.id}`,
+        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.modelFamily,
+      parent: null,
+    });
+
+    // 添加搜索版本模型
+    transformedModels.push({
+      id: `${model.modelFamily}-Search`,
+      object: "model",
+      created: Date.now(),
+      owned_by: "sophnet",
+      permission: [{
+        id: `modelperm-${model.id}-Search`,
+        object: "model_permission",
+        created: Date.now(),
+        allow_create_engine: false,
+        allow_sampling: true,
+        allow_logprobs: false,
+        allow_search_indices: true,
+        allow_view: true,
+        allow_fine_tuning: false,
+        organization: "*",
+        group: null,
+        is_blocking: false,
+      }],
+      root: model.modelFamily,
+      parent: null,
+    });
+
+    // 添加全上下文版本模型
+    transformedModels.push({
+      id: `${model.modelFamily}-Full-Context`,
+      object: "model",
+      created: Date.now(),
+      owned_by: "sophnet",
+      permission: [{
+        id: `modelperm-${model.id}-Full-Context`,
+        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.modelFamily,
+      parent: null,
+    });
+
+    // 添加全上下文+搜索版本模型
+    transformedModels.push({
+      id: `${model.modelFamily}-Full-Context-Search`,
+      object: "model",
+      created: Date.now(),
+      owned_by: "sophnet",
+      permission: [{
+        id: `modelperm-${model.id}-Full-Context-Search`,
+        object: "model_permission",
+        created: Date.now(),
+        allow_create_engine: false,
+        allow_sampling: true,
+        allow_logprobs: false,
+        allow_search_indices: true,
+        allow_view: true,
+        allow_fine_tuning: false,
+        organization: "*",
+        group: null,
+        is_blocking: false,
+      }],
+      root: model.modelFamily,
+      parent: null,
+    });
+  }
+
   return {
-    id: FIXED_CHAT_ID,
-    messages: formattedMessages,
-    selectedModel: model,
-    mcpServers: [],
-    chatId: FIXED_CHAT_ID,
-    userId: FIXED_USER_ID
+    object: "list",
+    data: transformedModels,
   };
 }
 
-// 处理模型列表请求
-async function handleModelsRequest(): Promise<Response> {
-  const response = {
-    object: "list",
-    data: AVAILABLE_MODELS,
+// 处理全上下文功能
+function processFullContext(messages: Message[]): Message[] {
+  // 复制消息数组，避免修改原数组
+  const messagesCopy = [...messages];
+
+  // 提取系统消息（如果存在）
+  const systemMessages = messagesCopy.filter(msg => msg.role === "system");
+
+  // 获取非系统消息
+  const nonSystemMessages = messagesCopy.filter(msg => msg.role !== "system");
+
+  // 如果消息总数少于或等于3对（6条消息），则不需要处理
+  if (nonSystemMessages.length <= 6) {
+    return messages;
+  }
+
+  // 提取最后3轮对话（最多6条消息）
+  const recentMessages = nonSystemMessages.slice(-6);
+
+  // 提取需要合并的历史消息
+  const historyMessages = nonSystemMessages.slice(0, -6);
+
+  // 创建历史消息的摘要
+  const historySummary = {
+    role: "user",
+    content: `这里是此前的对话上下文: ${JSON.stringify(historyMessages)}`
   };
-  return new Response(JSON.stringify(response), {
-    headers: {
-      "Content-Type": "application/json",
-      "Access-Control-Allow-Origin": "*"
-    },
-  });
+
+  // 组合新的消息数组：系统消息 + 历史摘要 + 最近消息
+  return [...systemMessages, historySummary, ...recentMessages];
 }
 
-// 处理聊天补全请求
-async function handleChatCompletionsRequest(req: Request): Promise<Response> {
-  const requestData = await req.json();
-  const { messages, model = DEFAULT_MODEL, stream = false } = requestData;
-  
-  const sciraPayload = buildSciraPayload(messages, model);
-  const response = await fetch(API_URL, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:137.0) Gecko/20100101 Firefox/137.0",
-      "Accept": "*/*",
-      "Referer": `https://mcp.scira.ai/chat/${FIXED_CHAT_ID}`,
-      "Origin": "https://mcp.scira.ai",
-    },
-    body: JSON.stringify(sciraPayload),
-  });
+// 将数字转换为上标形式
+function convertToSuperscript(num: number): string {
+  const normalDigits = '0123456789';
+  const superscriptDigits = '⁰¹²³⁴⁵⁶⁷⁸⁹';
+
+  return num.toString()
+    .split('')
+    .map(char => {
+      const index = normalDigits.indexOf(char);
+      return index !== -1 ? superscriptDigits[index] : char;
+    })
+    .join('');
+}
+
+// 处理聊天完成请求
+async function handleChatCompletions(
+  token: string,
+  requestBody: any,
+  stream: boolean,
+  retryCount = 0,
+): Promise<Response> {
+  // 检查模型名称的后缀
+  const modelId = requestBody.model;
+  const webSearchEnable = modelId.includes("-Search");
+  const fullContextEnable = modelId.includes("-Full-Context");
+
+  // 根据后缀确定实际模型ID
+  let actualModelId = modelId;
+  if (webSearchEnable) actualModelId = actualModelId.replace("-Search", "");
+  if (fullContextEnable) actualModelId = actualModelId.replace("-Full-Context", "");
+
+  // 处理消息
+  let processedMessages = requestBody.messages;
+  if (fullContextEnable) {
+    processedMessages = processFullContext(requestBody.messages);
+  }
+
+  const sophNetBody = {
+    temperature: requestBody.temperature || 0.7,
+    top_p: requestBody.top_p || 0.9,
+    frequency_penalty: requestBody.frequency_penalty || 0,
+    presence_penalty: requestBody.presence_penalty || 0,
+    max_tokens: requestBody.max_tokens || 2048,
+    webSearchEnable: webSearchEnable,
+    stop: requestBody.stop || [],
+    stream: stream.toString(),
+    model_id: actualModelId,
+    messages: processedMessages,
+  };
+
+  try {
+    const response = await fetch(
+      `${SOPHNET_BASE_URL}/open-apis/projects/${PROJECT_UUID}/chat/completions`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer anon-${token}`,
+          "Accept": stream ? "text/event-stream" : "application/json",
+          "User-Agent": getRandomUserAgent(), // 使用随机UA
+        },
+        body: JSON.stringify(sophNetBody),
+      },
+    );
 
-  if (stream) {
-    return handleStreamResponse(response, model);
-  } else {
-    return handleRegularResponse(response, model);
+    // 如果是401或403错误，尝试刷新token并重试
+    if ((response.status === 401 || response.status === 403) && retryCount < MAX_RETRIES) {
+      console.log(`Chat completion token expired, refreshing and retrying (${retryCount + 1}/${MAX_RETRIES})...`);
+      const newToken = await getAnonymousToken();
+      // 使用指数退避等待
+      const delay = getExponentialBackoffDelay(retryCount);
+      await sleep(delay);
+      return await handleChatCompletions(newToken, requestBody, stream, retryCount + 1);
+    }
+
+    // 如果是 429 或 500 错误，进行指数退避重试
+    if ((response.status === 429 || response.status >= 500) && retryCount < MAX_RETRIES) {
+        const delay = getExponentialBackoffDelay(retryCount);
+        console.warn(`Chat completion failed with status ${response.status}. Retrying in ${delay}ms... (${retryCount + 1}/${MAX_RETRIES})`);
+        await sleep(delay);
+        return handleChatCompletions(token, requestBody, stream, retryCount + 1); // 使用当前token重试，如果失败会在上面的逻辑中刷新
+    }
+
+    if (!response.ok) {
+      throw new Error(`Chat completion failed: ${response.status}`);
+    }
+
+    // 请求成功后获取新token并存储 (后台刷新)
+    getAnonymousToken().catch(err => console.error("Background token refresh failed:", err));
+
+    return response;
+
+  } catch (error) {
+    console.error("Error during chat completion fetch:", error);
+    // 如果是网络错误或其他非HTTP错误，也进行指数退避重试
+     if (retryCount < MAX_RETRIES) {
+        const delay = getExponentialBackoffDelay(retryCount);
+        console.warn(`Chat completion network error. Retrying in ${delay}ms... (${retryCount + 1}/${MAX_RETRIES})`);
+        await sleep(delay);
+        return handleChatCompletions(token, requestBody, stream, retryCount + 1);
+     }
+    throw error; // 达到最大重试次数后抛出错误
   }
 }
 
-// 处理流式响应
-async function handleStreamResponse(response: Response, model: string): Promise<Response> {
-  const reader = response.body!.getReader();
-  const encoder = new TextEncoder();
+// 转换流式响应
+async function* transformStreamResponse(
+  readableStream: ReadableStream<Uint8Array>,
+) {
+  const reader = readableStream.getReader();
   const decoder = new TextDecoder();
-  
-  const id = `chatcmpl-${Date.now().toString(36)}${Math.random().toString(36).substring(2, 10)}`;
-  const createdTime = Math.floor(Date.now() / 1000);
-  const systemFingerprint = `fp_${Math.random().toString(36).substring(2, 12)}`;
-  
-  const stream = new ReadableStream({
-    async start(controller) {
-      // 发送流式头部
-      const headerEvent = {
-        id: id,
-        object: "chat.completion.chunk",
-        created: createdTime,
-        model: model,
-        system_fingerprint: systemFingerprint,
-        choices: [{
-          index: 0,
-          delta: { role: "assistant" },
-          logprobs: null,
-          finish_reason: null
-        }]
-      };
-      controller.enqueue(encoder.encode(`data: ${JSON.stringify(headerEvent)}\n\n`));
-      
-      try {
-        let buffer = "";
-        
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          
-          // 解码当前数据块并添加到缓冲区
-          buffer += decoder.decode(value, { stream: true });
-          
-          // 处理完整的行
-          const lines = buffer.split('\n');
-          // 保留最后一个可能不完整的行
-          buffer = lines.pop() || "";
-          
-          // 处理并立即发送每一行
-          for (const line of lines) {
-            if (!line.trim()) continue;
-
-            if (line.startsWith('g:')) {
-              // 对于g开头的行，输出reasoning_content
-              let content = line.slice(2).replace(/^"/, "").replace(/"$/, "");
-              content = content.replace(/\\n/g, "\n");
-              
-              const event = {
-                id: id,
-                object: "chat.completion.chunk",
-                created: createdTime,
-                model: model,
-                system_fingerprint: systemFingerprint,
-                choices: [{
-                  index: 0,
-                  delta: { reasoning_content: content },
-                  logprobs: null,
-                  finish_reason: null
-                }]
-              };
-              controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
-            } else if (line.startsWith('0:')) {
-              // 对于0开头的行，输出content
-              let content = line.slice(2).replace(/^"/, "").replace(/"$/, "");
-              content = content.replace(/\\n/g, "\n");
-              
-              const event = {
-                id: id,
-                object: "chat.completion.chunk",
-                created: createdTime,
-                model: model,
-                system_fingerprint: systemFingerprint,
-                choices: [{
+  let buffer = "";
+
+  // 用于存储所有引用，以便在结束时生成参考资料部分
+  const references: Reference[] = [];
+  let referencesEmitted = false; // 标记是否已经发送过参考资料部分
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        // 如果有引用但尚未发送，在结束前发送参考资料部分
+        if (references.length > 0 && !referencesEmitted) {
+          const referencesSection = generateReferencesSection(references);
+          yield `data: ${JSON.stringify({
+            id: `chatcmpl-${Date.now()}`, // 生成一个唯一的ID
+            object: "chat.completion.chunk",
+            created: Math.floor(Date.now() / 1000),
+            model: "sophnet-model", // 可以使用 SophNet 返回的模型名，或者固定一个
+            choices: [
+              {
+                index: 0,
+                delta: {
+                  content: `\n\n${referencesSection}`,
+                },
+                finish_reason: null, // 在发送参考资料时，finish_reason通常为null
+              },
+            ],
+          })}\n\n`;
+          referencesEmitted = true;
+        }
+        break;
+      }
+
+      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]") {
+           // 如果有引用但尚未发送，在结束前发送参考资料部分
+          if (references.length > 0 && !referencesEmitted) {
+            const referencesSection = generateReferencesSection(references);
+            yield `data: ${JSON.stringify({
+              id: `chatcmpl-${Date.now()}`, // 生成一个唯一的ID
+              object: "chat.completion.chunk",
+              created: Math.floor(Date.now() / 1000),
+              model: "sophnet-model", // 可以使用 SophNet 返回的模型名，或者固定一个
+              choices: [
+                {
                   index: 0,
-                  delta: { content: content },
-                  logprobs: null,
-                  finish_reason: null
-                }]
-              };
-              controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
-            } else if (line.startsWith('e:')) {
-              // 完成消息
-              try {
-                const finishData = JSON.parse(line.slice(2));
-                const event = {
-                  id: id,
+                  delta: {
+                    content: `\n\n${referencesSection}`,
+                  },
+                  finish_reason: null, // 在发送参考资料时，finish_reason通常为null
+                },
+              ],
+            })}\n\n`;
+            referencesEmitted = true;
+          }
+
+          yield "data: [DONE]\n\n";
+          continue;
+        }
+
+        try {
+          const sophNetEvent = JSON.parse(data);
+
+          // 检查是否包含引用
+          if (sophNetEvent.choices?.[0]?.refs && sophNetEvent.choices[0].refs.length > 0) {
+            // 处理引用
+            for (const ref of sophNetEvent.choices[0].refs) {
+              // 检查是否已经存在相同URL的引用
+              const existingRefIndex = references.findIndex(r => r.url === ref.url);
+              if (existingRefIndex === -1) {
+                // 添加新引用
+                references.push(ref);
+
+                // 生成引用标记，使用上标数字
+                const refIndex = references.length;
+                const superscriptIndex = `⁽${convertToSuperscript(refIndex)}⁾`;
+
+                // 创建带引用标记的事件
+                yield `data: ${JSON.stringify({
+                  id: sophNetEvent.id || `chatcmpl-${Date.now()}`, // 使用SophNet ID或生成新ID
                   object: "chat.completion.chunk",
-                  created: createdTime,
-                  model: model,
-                  system_fingerprint: systemFingerprint,
-                  choices: [{
-                    index: 0,
-                    delta: {},
-                    logprobs: null,
-                    finish_reason: finishData.finishReason || "stop"
-                  }]
-                };
-                controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
-              } catch (error) {
-                console.error("Error parsing finish data:", error);
+                  created: Math.floor(Date.now() / 1000),
+                  model: sophNetEvent.model || "sophnet-model", // 使用SophNet模型名或固定
+                  choices: [
+                    {
+                      index: 0,
+                      delta: {
+                        // SophNet的引用信息通常不在content中，我们需要手动添加
+                        content: `[${superscriptIndex}](${ref.url})`,
+                      },
+                      finish_reason: null, // 引用事件通常没有finish_reason
+                    },
+                  ],
+                })}\n\n`;
               }
             }
-          }
-        }
-        
-        // 处理缓冲区中剩余的内容（如果有的话）
-        if (buffer.trim()) {
-          const line = buffer.trim();
-          if (line.startsWith('g:')) {
-            let content = line.slice(2).replace(/^"/, "").replace(/"$/, "");
-            content = content.replace(/\\n/g, "\n");
-            
-            const event = {
-              id: id,
-              object: "chat.completion.chunk",
-              created: createdTime,
-              model: model,
-              system_fingerprint: systemFingerprint,
-              choices: [{
-                index: 0,
-                delta: { reasoning_content: content },
-                logprobs: null,
-                finish_reason: null
-              }]
-            };
-            controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
-          } else if (line.startsWith('0:')) {
-            let content = line.slice(2).replace(/^"/, "").replace(/"$/, "");
-            content = content.replace(/\\n/g, "\n");
-            
-            const event = {
-              id: id,
+          } else {
+            // 转换为OpenAI格式的事件
+            const openAIEvent = {
+              id: sophNetEvent.id || `chatcmpl-${Date.now()}`, // 使用SophNet ID或生成新ID
               object: "chat.completion.chunk",
-              created: createdTime,
-              model: model,
-              system_fingerprint: systemFingerprint,
-              choices: [{
-                index: 0,
-                delta: { content: content },
-                logprobs: null,
-                finish_reason: null
-              }]
+              created: Math.floor(Date.now() / 1000),
+              model: sophNetEvent.model || "sophnet-model", // 使用SophNet模型名或固定
+              choices: [
+                {
+                  index: 0,
+                  delta: {
+                    // OpenAI通常将内容放在delta.content
+                    reasoning_content: sophNetEvent.choices?.[0]?.delta?.reasoning_content || "",
+                    content: sophNetEvent.choices?.[0]?.delta?.content || "",
+                  },
+                  finish_reason: sophNetEvent.choices?.[0]?.finish_reason || null,
+                },
+              ],
             };
-            controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+
+            yield `data: ${JSON.stringify(openAIEvent)}\n\n`;
           }
+        } catch (e) {
+          console.error("Error parsing event:", e, "Line:", line);
+          // 可以选择在这里发送一个错误事件给客户端
         }
-      } catch (error) {
-        console.error("Stream error:", error);
-      } finally {
-        // 确保发送 "data: [DONE]"
-        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-        controller.close();
       }
     }
-  });
+  } finally {
+    reader.releaseLock();
+  }
+}
 
-  return new Response(stream, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      "Connection": "keep-alive",
-      "Access-Control-Allow-Origin": "*",
-    },
+// 生成参考资料部分
+function generateReferencesSection(references: Reference[]): string {
+  if (references.length === 0) return "";
+
+  let section = "## 参考资料\n\n";
+  references.forEach((ref, index) => {
+    section += `${index + 1}. [${ref.title}](${ref.url})\n`;
   });
+
+  return section;
 }
 
-// 处理非流式响应
-async function handleRegularResponse(response: Response, model: string): Promise<Response> {
-  const text = await response.text();
-  const lines = text.split('\n');
-  
-  let content = "";
-  let reasoning_content = "";
-  let usage = { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
-  let finish_reason = "stop";
-  
-  for (const line of lines) {
-    if (!line.trim()) continue;
-    
-    if (line.startsWith('0:')) {
-      // 常规内容 - 处理转义的换行符
-      let lineContent = line.slice(2).replace(/^"/, "").replace(/"$/, "");
-      lineContent = lineContent.replace(/\\n/g, "\n");
-      content += lineContent;
-    } else if (line.startsWith('g:')) {
-      // 推理内容 - 处理转义的换行符
-      let lineContent = line.slice(2).replace(/^"/, "").replace(/"$/, "");
-      lineContent = lineContent.replace(/\\n/g, "\n");
-      reasoning_content += lineContent;
-    } else if (line.startsWith('e:')) {
-      try {
-        const finishData = JSON.parse(line.slice(2));
-        if (finishData.finishReason) {
-          finish_reason = finishData.finishReason;
-        }
-      } catch (error) {
-        console.error("Error parsing finish data:", error);
-      }
-    } else if (line.startsWith('d:')) {
-      try {
-        const finishData = JSON.parse(line.slice(2));
-        if (finishData.usage) {
-          usage.prompt_tokens = finishData.usage.promptTokens || 0;
-          usage.completion_tokens = finishData.usage.completionTokens || 0;
-          usage.total_tokens = usage.prompt_tokens + usage.completion_tokens;
-        }
-      } catch (error) {
-        console.error("Error parsing usage data:", error);
-      }
+// 转换非流式响应
+async function transformNonStreamResponse(response: Response) {
+  const sophNetResponse = await response.json();
+
+  // 处理引用
+  let content = sophNetResponse.choices?.[0]?.message?.content || "";
+  const references: Reference[] = [];
+
+  // 收集所有引用
+  if (sophNetResponse.choices?.[0]?.message?.refs && sophNetResponse.choices[0].message.refs.length > 0) {
+    for (const ref of sophNetResponse.choices[0].message.refs) {
+      references.push(ref);
+    }
+
+    // 为每个引用添加上标标记
+    references.forEach((ref, index) => {
+      const refIndex = index + 1;
+      const superscriptIndex = `⁽${convertToSuperscript(refIndex)}⁾`;
+      // 在内容末尾添加引用标记
+      content += ` [${superscriptIndex}](${ref.url})`;
+    });
+
+    // 添加参考资料部分
+    if (references.length > 0) {
+      content += "\n\n" + generateReferencesSection(references);
     }
   }
-  
-  const systemFingerprint = `fp_${Math.random().toString(36).substring(2, 12)}`;
-  const id = `chatcmpl-${Date.now().toString(36)}${Math.random().toString(36).substring(2, 10)}`;
 
-  const openAIResponse = {
-    id: id,
+  return {
+    id: sophNetResponse.id || `chatcmpl-${Date.now()}`, // 使用SophNet ID或生成新ID
     object: "chat.completion",
     created: Math.floor(Date.now() / 1000),
-    model: model,
-    system_fingerprint: systemFingerprint,
-    choices: [{
-      index: 0,
-      message: {
-        role: "assistant",
-        content: content
+    model: sophNetResponse.model || "sophnet-model", // 使用SophNet模型名或固定
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: "assistant",
+          reasoning_content: sophNetResponse.choices?.[0]?.message?.reasoning_content || "",
+          content: content,
+        },
+        finish_reason: sophNetResponse.choices?.[0]?.finish_reason || "stop",
       },
-      logprobs: null,
-      finish_reason: finish_reason
-    }],
-    usage: usage
-  };
-  
-  // 如果存在推理内容，添加到消息中
-  if (reasoning_content.trim()) {
-    openAIResponse.choices[0].message.reasoning_content = reasoning_content;
-  }
-  
-  return new Response(JSON.stringify(openAIResponse), {
-    headers: { 
-      "Content-Type": "application/json",
-      "Access-Control-Allow-Origin": "*"
+    ],
+    usage: sophNetResponse.usage || {
+      prompt_tokens: 0,
+      completion_tokens: 0,
+      total_tokens: 0,
     },
-  });
+  };
 }
 
-// 主请求处理函数
+// 主处理函数
 async function handler(req: Request): Promise<Response> {
   const url = new URL(req.url);
-  
-  // 设置CORS头
-  const headers = {
-    "Access-Control-Allow-Origin": "*",
-    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
-    "Access-Control-Allow-Headers": "Content-Type, Authorization",
-  };
-  
-  // 处理OPTIONS请求（CORS预检）
+  const path = url.pathname;
+
+  // CORS预检请求处理
   if (req.method === "OPTIONS") {
-    return new Response(null, { 
-      headers,
-      status: 204 
+    return new Response(null, {
+      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",
+      },
     });
   }
-  
+
+  // 获取有效token
+  let token;
   try {
-    // 处理模型列表接口
-    if (url.pathname === "/v1/models") {
-      return handleModelsRequest();
-    }
-    
-    // 处理聊天补全接口
-    if (url.pathname === "/v1/chat/completions") {
-      return handleChatCompletionsRequest(req);
-    }
-    
-    // 未找到的路由
+    token = await getValidToken();
+  } catch (error) {
+    console.error("Failed to get token in handler:", error);
     return new Response(
-      JSON.stringify({ error: "Not found" }), {
-        status: 404,
-        headers: { 
+      JSON.stringify({ error: "Failed to get token", details: error.message }),
+      {
+        status: 500,
+        headers: {
           "Content-Type": "application/json",
-          ...headers 
+          "Access-Control-Allow-Origin": "*",
         },
-      }
+      },
     );
+  }
+
+  try {
+    // 模型列表接口
+    if (path === "/v1/models" && req.method === "GET") {
+      const models = await getModels(token);
+      const openAIModels = transformModelsToOpenAIFormat(models);
+
+      return new Response(JSON.stringify(openAIModels), {
+        status: 200,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+        },
+      });
+    }
+
+    // 聊天完成接口
+    else if (path === "/v1/chat/completions" && req.method === "POST") {
+      const requestBody = await req.json();
+      const stream = requestBody.stream === true;
+
+      const sophNetResponse = await handleChatCompletions(token, requestBody, stream);
+
+      if (stream) {
+        const transformedStream = new ReadableStream({
+          async start(controller) {
+            try {
+              for await (const chunk of transformStreamResponse(sophNetResponse.body!)) {
+                controller.enqueue(new TextEncoder().encode(chunk));
+              }
+              controller.close();
+            } catch (error) {
+              console.error("Stream transformation error:", error);
+              // 在流中发送错误信息
+              const errorData = JSON.stringify({
+                error: {
+                  message: `Stream processing error: ${error.message}`,
+                  type: "stream_error",
+                  code: null,
+                }
+              });
+              controller.enqueue(new TextEncoder().encode(`data: ${errorData}\n\n`));
+              controller.enqueue(new TextEncoder().encode("data: [DONE]\n\n"));
+              controller.close();
+            }
+          },
+        });
+
+        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(sophNetResponse);
+
+        return new Response(JSON.stringify(transformedResponse), {
+          status: 200,
+          headers: {
+            "Content-Type": "application/json",
+            "Access-Control-Allow-Origin": "*",
+          },
+        });
+      }
+    }
+
+    // 未找到路由
+    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("Error processing request:", error);
+    console.error("Request handling error:", error);
+
+    // 返回统一的错误响应格式
     return new Response(
-      JSON.stringify({ error: error.message || "Internal server error" }),
+      JSON.stringify({
+        error: {
+          message: error.message,
+          type: "api_error", // 或者更具体的错误类型
+          code: error.status || null, // 如果是HTTP错误，包含状态码
+        }
+      }),
       {
-        status: 500,
-        headers: { 
+        status: error.status || 500, // 使用错误状态码或默认500
+        headers: {
           "Content-Type": "application/json",
-          ...headers 
+          "Access-Control-Allow-Origin": "*",
         },
-      }
+      },
     );
   }
 }