Create Cloudflare

Cloudflare

@@ -0,0 +1,894 @@
+// Cloudflare Workers 环境不需要像 Deno 那样通过 URL 导入模块
+// Web 标准 API (fetch, Request, Response, WebSocket, URL) 是全局可用的。
+// axios 和 qs 不需要了，我们将使用 fetch API。
+// express 不使用了，我们将手动进行路由或使用轻量级路由库。
+
+function uuidv4() {
+  // 生成16个随机字节（128位）
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes); // 在 Workers 中使用 Web Crypto API 获取更好的随机性
+
+  // 按照 UUID v4 标准格式设置特定位
+  bytes[6] = (bytes[6] & 0x0f) | 0x40; // 0100xxxx: version 4
+  bytes[8] = (bytes[8] & 0x3f) | 0x80; // 10xxxxxx: variant
+
+  // 转换成 8-4-4-4-12 的 hex 格式
+  const hex = [...bytes].map(b => b.toString(16).padStart(2, '0'));
+
+  return (
+      hex.slice(0, 4).join('') + '-' +
+      hex.slice(4, 6).join('') + '-' +
+      hex.slice(6, 8).join('') + '-' +
+      hex.slice(8, 10).join('') + '-' +
+      hex.slice(10, 16).join('')
+  );
+}
+
+
+async function fetchApi(url, options = {}) {
+  const response = await fetch(url, options);
+
+  if (!response.ok) {
+      // 尝试读取错误响应体
+      let errorBody = '未知错误';
+      try {
+          errorBody = await response.text(); // 使用 text() 因为响应体可能不是 JSON
+      } catch (e) {
+          console.error('读取错误响应体失败:', e);
+      }
+      throw new Error(`HTTP error! status: ${response.status}, url: ${url}, body: ${errorBody}`);
+  }
+
+  try {
+      // PromptLayer API 通常返回带有 'success' 标志的 JSON
+      const data = await response.json();
+      if (data.success === false) {
+           throw new Error(`PromptLayer API 错误: ${data.message || JSON.stringify(data)}`);
+      }
+      return data;
+  } catch (e) {
+       // 处理响应不是 JSON 或 JSON 解析失败的情况
+       if (e instanceof SyntaxError) {
+          console.error('解析 JSON 响应失败:', await response.text());
+          throw new Error(`从 ${url} 接收到无效的 JSON 响应`);
+       }
+       // 重新抛出 PromptLayer API 特定错误或其他错误
+       throw e;
+  }
+}
+
+
+async function fetchTokenDetails(authToken) {
+  const url = 'https://api.promptlayer.com/ws-token-request';
+  const headers = { Authorization: "Bearer " + authToken };
+
+  const data = await fetchApi(url, {
+      method: 'POST',
+      headers: headers,
+      // Promptlayer 可能期望有一个请求体，即使是 null。
+      // 根据原始 axios 代码发送 null 请求体。
+      body: null
+  });
+
+  const access_token = data.token_details.token;
+  const clientId = data.token_details.clientId;
+  return { access_token, clientId };
+}
+
+/**
+* 获取 workspace id
+*/
+async function fetchWorkspaceId(authToken) {
+  const url = 'https://api.promptlayer.com/workspaces';
+  const headers = { Authorization: "Bearer " + authToken };
+
+  const data = await fetchApi(url, { headers: headers });
+
+  if (data.workspaces && data.workspaces.length > 0) {
+      const workspaceId = data.workspaces[0].id;
+      return { workspaceId };
+  } else {
+      throw new Error('获取 workspace id 失败或未找到 workspaces');
+  }
+}
+
+
+function transformMessagesArray(messages) {
+  if (!Array.isArray(messages)) {
+      // 返回默认结构或抛出错误，取决于期望的行为
+      // 抛出错误更能指示输入无效
+      throw new Error("输入的消息必须是数组");
+  }
+
+  return messages.map(msg => {
+      // 确保内容被视为文本进行转换
+      const textContent = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+
+      return {
+          role: msg.role,
+          content: [
+              {
+                  type: "text",
+                  text: textContent // 确保是 text 类型
+              }
+          ],
+          tool_calls: [], // 根据原始代码，假设 tool_calls 应为空数组
+          template_format: "f-string" // 假设这是静态值
+      };
+  });
+}
+
+async function login(username, password) {
+  const url = 'https://api.promptlayer.com/login';
+  const headers = {
+      "Content-Type": "application/json", // fetch 需要为 JSON 请求体明确设置 Content-Type
+      "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36 Edg/136.0.0.0"
+  };
+  const body = JSON.stringify({ "email": username, "password": password });
+
+  try {
+      // 登录接口通常不返回 response.data 中包含 'success' 标志，
+      // 成功时（状态码 200）通常直接返回 token。
+      // 需要区别于 fetchApi 辅助函数进行处理。
+      const response = await fetch(url, {
+          method: 'POST',
+          headers: headers,
+          body: body
+      });
+
+      if (!response.ok) {
+           let errorBody = '未知登录错误';
+          try {
+              errorBody = await response.text();
+          } catch (e) {}
+          console.error(`登录失败: ${response.status}, body: ${errorBody}`);
+          return { access_token: null, error: `登录失败: ${response.status}` };
+      }
+
+      const data = await response.json(); // 期望返回 { access_token: "..." }
+      if (data.access_token) {
+          return { access_token: data.access_token };
+      } else {
+           // 登录状态码成功但缺少 token？不寻常，按失败处理。
+           console.error('登录响应缺少 access_token:', data);
+           return { access_token: null, error: '登录响应缺少 token' };
+      }
+
+  } catch (e) {
+      console.error('登录 fetch 错误:', e);
+      return { access_token: null, error: '登录 fetch 错误' };
+  }
+}
+
+// 刷新playseesion
+async function pysession(authToken, workspaceId, databody) {
+  const url = `https://api.promptlayer.com/api/dashboard/v2/workspaces/${workspaceId}/playground_sessions`;
+  const headers = {
+      Authorization: "Bearer " + authToken,
+      "Content-Type": "application/json"
+  };
+
+  let provider = "openai"
+  let model = "gpt-4o"
+  let parameters = {
+      "temperature": 1,
+      "seed": 0,
+      "response_format": null,
+      "top_p": 1,
+      "frequency_penalty": 0,
+      "presence_penalty": 0
+  }
+
+  // 模型映射逻辑保持不变
+  if (databody.model && typeof databody.model === 'string') {
+      const lowerModel = databody.model.toLowerCase();
+      if (lowerModel.includes("claude") && (lowerModel.includes("3.7") || lowerModel.includes("3-7"))) {
+          provider = "anthropic";
+          model = "claude-3-7-sonnet-latest";
+          parameters = {
+              "max_tokens": 64000,
+              "temperature": 1
+          };
+      } else if (lowerModel.includes("claude") && (lowerModel.includes("3.5") || lowerModel.includes("3-5"))) {
+          provider = "anthropic";
+          model = "claude-3-5-sonnet-latest";
+          parameters = {
+              "max_tokens": 256, // 注意：这个值很低，确认是否故意为之
+              "temperature": 1,
+              "top_k": 0,
+              "top_p": 0
+          };
+      } else if (lowerModel.includes("4.1")) {
+          model = "gpt-4.1"; // 假设这映射到特定的 PromptLayer 模型名
+      } else if (lowerModel.includes("4.5") || lowerModel.includes("4-5")) {
+          model = "gpt-4.5-preview"; // 假设这映射
+      } else if (lowerModel === "gpt-4o-search-preview") {
+          model = "gpt-4o-search-preview";
+          parameters = {
+              "response_format": null,
+              "web_search_options": {
+                  "search_context_size": "medium",
+                  "user_location": {
+                      "approximate": {
+                          "city": "New York", // 硬编码城市/国家 - 可能需要配置
+                          "country": "US",
+                          "region": "New York",
+                          "timezone": "America/New_York"
+                      },
+                      "type": "approximate"
+                  }
+              }
+          };
+      } else {
+          // 如果指定了模型但未明确映射，则使用请求的模型名
+           model = databody.model;
+      }
+  }
+   // 否则：保留默认的 openai/gpt-4o
+
+  const body = JSON.stringify({
+      "id": uuidv4(),
+      "name": "Not implemented", // 更改名称
+      "prompt_blueprint": {
+          "inference_client_name": null, // 保持 null
+          "metadata": {
+              "model": {
+                  "name": model,
+                  "provider": provider,
+                  "parameters": parameters
+              }
+          },
+          "prompt_template": {
+              "type": "chat",
+              "messages": transformMessagesArray(databody.messages),
+              "tools": null,
+              "input_variables": [],
+              "functions": []
+          },
+          "provider_base_url_name": null
+      },
+      "input_variables": []
+  });
+
+  const data = await fetchApi(url, {
+      method: 'PUT', // 原始代码使用 PUT
+      headers: headers,
+      body: body
+  });
+
+  return data.playground_session.id; // 该接口似乎返回 success 和 playground_session.id
+}
+
+
+async function postmessage(authToken, workspaceId, playground_sessions, databody) {
+  const url = `https://api.promptlayer.com/api/dashboard/v2/workspaces/${workspaceId}/run_groups`;
+  const headers = {
+      Authorization: "Bearer " + authToken,
+      "Content-Type": "application/json"
+  };
+
+  let provider = "openai"
+  let model = "gpt-4o"
+  let parameters = {
+      "temperature": 1,
+      "seed": 0,
+      "response_format": null,
+      "top_p": 1,
+      "frequency_penalty": 0,
+      "presence_penalty": 0
+  }
+
+  // 模型映射逻辑保持不变（与 pysession 重复，考虑重构）
+   if (databody.model && typeof databody.model === 'string') {
+      const lowerModel = databody.model.toLowerCase();
+      if (lowerModel.includes("claude") && (lowerModel.includes("3.7") || lowerModel.includes("3-7"))) {
+          provider = "anthropic";
+          model = "claude-3-7-sonnet-latest";
+          parameters = {
+              "max_tokens": 64000,
+              "temperature": 1
+          };
+      } else if (lowerModel.includes("claude") && (lowerModel.includes("3.5") || lowerModel.includes("3-5"))) {
+          provider = "anthropic";
+          model = "claude-3-5-sonnet-latest";
+          parameters = {
+              "max_tokens": 256, // 注意：这个值很低，确认是否故意为之
+              "temperature": 1,
+              "top_k": 0,
+              "top_p": 0
+          };
+      } else if (lowerModel.includes("4.1")) {
+          model = "gpt-4.1"; // 假设这映射到特定的 PromptLayer 模型名
+      } else if (lowerModel.includes("4.5") || lowerModel.includes("4-5")) {
+          model = "gpt-4.5-preview"; // 假设这映射
+      } else if (lowerModel === "gpt-4o-search-preview") {
+          model = "gpt-4o-search-preview";
+          parameters = {
+              "response_format": null,
+              "web_search_options": {
+                  "search_context_size": "medium",
+                  "user_location": {
+                      "approximate": {
+                          "city": "New York", // 硬编码城市/国家 - 可能需要配置
+                          "country": "US",
+                          "region": "New York",
+                          "timezone": "America/New_York"
+                      },
+                      "type": "approximate"
+                  }
+              }
+          };
+      } else {
+           model = databody.model; // 使用请求的模型名
+      }
+   }
+  // 否则：保留默认的 openai/gpt-4o
+
+  const body = JSON.stringify({
+      "id": uuidv4(),
+      "playground_session_id": playground_sessions,
+      "shared_prompt_blueprint": {
+          "inference_client_name": null,
+          "metadata": {
+              "model": {
+                  "name": model,
+                  "provider": provider,
+                  "parameters": parameters
+              }
+          },
+          "prompt_template": {
+              "type": "chat",
+              "messages": transformMessagesArray(databody.messages),
+              "tools": null,
+              "input_variables": [],
+              "functions": []
+          },
+          "provider_base_url_name": null
+      },
+      "individual_run_requests": [
+          {
+              "input_variables": {},
+              "run_group_position": 1
+          }
+      ]
+  });
+
+  const data = await fetchApi(url, {
+      method: 'POST',
+      headers: headers,
+      body: body
+  });
+
+  return data.run_group.individual_run_requests[0].id; // 接口返回 run_group 包含 requests
+}
+
+function isJsonString(str) {
+  try {
+      const parsed = JSON.parse(str);
+      return typeof parsed === 'object' && parsed !== null;
+  } catch (e) {
+      return false;
+  }
+}
+
+function findDifference(str1, str2) {
+  if (str2.startsWith(str1)) {
+      return str2.slice(str1.length);
+  } else {
+      // 这种情况可能表明块处理有问题，或者消息乱序。
+      // 如果 str2 不以 str1 开头，返回空字符串意味着跳过不匹配的块。
+      // 考虑在这里记录警告或错误。
+      console.warn("findDifference: str2 不以 str1 开头。潜在的块不匹配问题。");
+      return "";
+  }
+}
+
+function normalizeMessages(messages) {
+  if (!Array.isArray(messages)) {
+      // 优雅地处理非数组输入，可能返回空数组
+      console.warn("normalizeMessages 接收到非数组输入:", messages);
+      return [];
+  }
+
+  return messages.map((message) => {
+      // 确保消息结构符合预期或进行规范化
+      if (message && typeof message === 'object') {
+          if (Array.isArray(message.content)) {
+              // 如果 content 是数组，提取 type="text" 的文本部分
+              const textContent = message.content
+                  .filter((item) => item && typeof item === 'object' && item.type === "text")
+                  .map((item) => item.text)
+                  .join(" "); // 连接多个文本块（如果存在）
+
+              // 返回包含原始属性 + 扁平化 content 的对象
+              return {
+                  ...message,
+                  content: textContent || "" // 确保 content 是字符串，如果没有找到文本部分则默认为空字符串
+              };
+          }
+           // 如果 content 已经是字符串，或不是数组，则按原样返回（确保是字符串）
+           return {
+              ...message,
+              content: typeof message.content === 'string' ? message.content : JSON.stringify(message.content) // 确保 content 是字符串
+           };
+      }
+       // 处理输入数组中的非对象元素
+       console.warn("normalizeMessages 在数组中发现非对象项:", message);
+       return { // 为无效项返回默认结构
+           role: "user", // 默认角色，根据需要调整
+           content: typeof message === 'string' ? message : JSON.stringify(message) // 将项表示为字符串内容
+       };
+  });
+}
+
+
+// 新增的 /v1/models 接口处理函数
+async function handleModels(request, corsHeaders) {
+  
+    // const models = [
+    //     "claude-3-5-sonnet-20240620",
+    //     "claude-3-7-sonnet-20250219",
+    //     "claude-3-5-sonnet-20241022",
+    //     "gpt-4o",
+    //     "gpt-4.1", // Assuming this exists based on your original code
+    //     "gpt-4.1-2025-04-14", // Assuming this exists
+    //     "gpt-4.5-preview-2025-02-27", // Assuming this exists
+    //     "gpt-4o-search-preview"
+    // ];
+
+    // const result = models.map((id) => {
+    //     return {
+    //     id,
+    //     object: "model",
+    //     created: 1626777600, // Example timestamp, replace if needed
+    //     owned_by: "custom",
+    //     root: id.startsWith("claude") ? "anthropic" : "openai" // Determine provider based on ID
+    //     };
+    // });
+
+    // // Use Response.json() is convenient
+    // return Response.json({ data: result, success: true }, { headers: corsHeaders });
+
+  let access = await getAuthToken(request, corsHeaders);
+  if(typeof access != "string"){
+    return access;
+  }
+
+  if (access === "") {
+      // 使用 Workers 的 Response.json 构建错误响应
+      return Response.json(
+          { error: "Unauthorized: Missing or invalid Bearer token" },
+          { status: 401, headers: corsHeaders } // 包含 CORS 头
+      );
+  }
+
+  try {
+      // 使用已有的 fetchWorkspaceId 辅助函数
+      const { workspaceId } = await fetchWorkspaceId(access);
+
+      const url = `https://api.promptlayer.com/api/dashboard/v2/workspaces/${workspaceId}/model-configs`;
+      const headers = { Authorization: `Bearer ${access}` };
+
+      // 使用 fetchApi 辅助函数替代 axios.get
+      // fetchApi 已经处理了 response.ok 和 data.success 的检查
+      const promptLayerData = await fetchApi(url, { headers: headers });
+
+      // promptLayerData 已经是解析后的 JSON 数据，并且 success: true
+      const openAIModels = [];
+      // 检查 promptLayerData.results 是否存在且为数组
+      if (Array.isArray(promptLayerData.results)) {
+           promptLayerData.results.forEach(provider => {
+              // 检查 provider.model_configs 是否存在且为数组
+               if (provider && Array.isArray(provider.model_configs)) {
+                  provider.model_configs.forEach(modelConfig => {
+                      // 检查 modelConfig 是否有必需的字段
+                      if (modelConfig && typeof modelConfig.llm_model_name === 'string') {
+                          openAIModels.push({
+                              id: modelConfig.llm_model_name,
+                              object: "model",
+                              // 确保 created_at 存在且是有效日期字符串
+                              created: modelConfig.created_at ? Math.floor(new Date(modelConfig.created_at).getTime() / 1000) : 0, // 将毫秒转换为秒，无效日期返回 0
+                              owned_by: provider.provider_name || "unknown", // 提供商名称，如果没有则用 unknown
+                              // 可以根据需要添加其他字段
+                          });
+                      } else {
+                           console.warn("Skipping invalid modelConfig:", modelConfig);
+                      }
+                  });
+               } else {
+                   console.warn("Skipping provider with invalid model_configs:", provider);
+               }
+          });
+      } else {
+           console.warn("PromptLayer model-configs response missing or invalid 'results' array:", promptLayerData);
+           // 如果 results 格式不正确，仍视为成功但模型列表为空
+      }
+
+
+      // 使用 Workers 的 Response.json 构建成功响应
+      return Response.json(
+          {
+              object: "list",
+              data: openAIModels
+          },
+          { headers: corsHeaders } // 包含 CORS 头
+      );
+
+  } catch (error) {
+      console.error("获取模型列表错误:", error.message);
+
+      // 根据错误类型返回不同的状态码和信息
+      let status = 500;
+      let errorMessage = `Internal Server Error: ${error.message}`;
+
+      if (error.message.includes('Failed to get workspace id') || error.message.includes('Failed to get workspace id or no workspaces found')) {
+          status = 403; // 通常表示认证成功但无权访问工作区
+          errorMessage = `Forbidden: ${error.message}`;
+      } else if (error.message.includes('HTTP error! status: 401')) {
+           status = 401; // 如果 fetchApi 报告了 401
+           errorMessage = `Unauthorized: PromptLayer API returned 401`;
+      } else if (error.message.includes('HTTP error!')) {
+          status = parseInt(error.message.match(/status: (\d+)/)?.[1] || 500); // 尝试从错误消息提取状态码
+          errorMessage = `PromptLayer API Error: ${error.message}`;
+      } else if (error.message.includes('PromptLayer API error:')) {
+           status = 500; // PromptLayer API 报告的逻辑错误
+           errorMessage = error.message;
+      }
+
+      // 使用 Workers 的 Response.json 构建错误响应
+      return Response.json(
+          { error: errorMessage },
+          { status: status, headers: corsHeaders } // 包含 CORS 头
+      );
+  }
+}
+
+async function getAuthToken(request, corsHeaders){
+//   const username = env.PROMPTLAYER_USERNAME; // 确保在 Worker 设置中绑定 Secrets
+//   const password = env.PROMPTLAYER_PASSWORD;
+  let access = "";
+  let authHeader = request.headers.get('Authorization');
+  if (authHeader && authHeader.startsWith("Bearer")) {
+    access = authHeader.split("Bearer ")[1];
+  }
+  if(access == "") {
+    return
+  }
+  let username = access.split("-")[0];
+  let password = access.split("-")[1];
+  const loginResult = await login(username, password);
+  if (loginResult.access_token) {
+      access = loginResult.access_token;
+  } else {
+      console.error("登录失败:", loginResult.error);
+      return Response.json({ code: 1, msg: '登录失败', error: loginResult.error }, { status: 401, headers: corsHeaders });
+  }
+
+  if (!access) {
+       // 如果登录失败，应该已经在上面返回了，但这作为一个备用检查
+       return Response.json({ code: 1, msg: '认证失败', error: '认证失败' }, { status: 401, headers: corsHeaders });
+  }
+  return access;
+}
+
+
+async function handleChatCompletions(request, ctx, corsHeaders) {
+  let databody;
+  try {
+      // 限制请求体大小，Workers 默认有上限（如 128MB）
+      // 如果需要更大的上限，可能需要考虑不同的处理方式或升级计划
+      // 原始代码中的 limit: "50mb" 在 Workers 中通常由平台控制
+      databody = await request.json();
+       // 验证 databody 和 messages 的基本结构
+      if (!databody || !Array.isArray(databody.messages)) {
+           throw new Error("无效的请求体格式");
+      }
+      databody.messages = normalizeMessages(databody.messages);
+  } catch (e) {
+      console.error("解析请求体错误:", e);
+      return Response.json({ code: 1, msg: '无效的 JSON 或请求体格式', error: e.message }, { status: 400, headers: corsHeaders });
+  }
+
+  let access = await getAuthToken(request, corsHeaders);
+  if(typeof access != "string"){
+    return access;
+  }
+
+  let tokenResult, workspaceResult;
+  try {
+      [tokenResult, workspaceResult] = await Promise.all([
+          fetchTokenDetails(access),
+          fetchWorkspaceId(access)
+      ]);
+  } catch (e) {
+      console.error("获取 token/workspace 错误:", e);
+      return Response.json({ code: 2, msg: '初始化会话失败', error: e.message }, { status: 500, headers: corsHeaders });
+  }
+
+  const { access_token, clientId } = tokenResult;
+  const { workspaceId } = workspaceResult;
+
+  let playground_sessions;
+  try {
+     playground_sessions = await pysession(access, workspaceId, databody);
+      if (playground_sessions === -1) { // 检查 -1 返回值表示失败
+          throw new Error("调用 pysession 失败");
+      }
+  } catch (e) {
+       console.error("创建/刷新 playground session 错误:", e);
+       return Response.json({ code: 2, msg: '创建 playground session 失败', error: e.message }, { status: 500, headers: corsHeaders });
+  }
+
+
+  // --- WebSocket 处理和流式响应 ---
+
+  // 对于流式响应，我们需要创建一个流并将数据推入其中
+  const stream = new TransformStream();
+  const writer = stream.writable.getWriter();
+  const encoder = new TextEncoder();
+
+  // 构建 wss url
+  const wsUrl = `wss://realtime.ably.io/?access_token=${encodeURIComponent(access_token)}&clientId=${clientId}&format=json&heartbeats=true&v=3&agent=ably-js%2F2.0.2%20browser`;
+  // 创建 WebSocket 连接
+  const ws = new WebSocket(wsUrl);
+
+  let last = ""; // 跟踪上一个块用于计算差异
+  let nonstr = ""; // 为非流式响应累积内容
+  let requestId = null; // 存储请求 ID 用于过滤消息
+
+  // Promise，当 WebSocket 过程完成（关闭或出错）时 resolve
+  // 这是 event.waitUntil 所需要的
+  const wsComplete = new Promise((resolve, reject) => {
+
+      ws.onopen = async () => {
+          try {
+              // 在 WS 打开时发送初始 action
+              const sendAction = `{"action":10,"channel":"user:${clientId}","params":{"agent":"react-hooks/2.0.2"}}`;
+              ws.send(sendAction);
+
+              // 在 WS 打开后通过 HTTP 发送消息
+             requestId = await postmessage(access, workspaceId, playground_sessions, databody);
+             if (requestId === -1) { // 检查失败情况
+                throw new Error("调用 postmessage 失败");
+             }
+             // console.log("individual_run_request_id:" + requestId);
+
+          } catch (err) {
+              console.error("WS 打开或 postmessage 过程中发生错误:", err);
+              // reject promise 以指示失败，并让 waitUntil 完成
+              writer.abort(err).catch(() => {}); // 中止流写入器
+              ws.close(); // 尝试关闭 WS
+              reject(err); // reject promise
+          }
+      };
+
+      ws.onmessage = async (event) => {
+          try {
+              const data = event.data;
+              let msg;
+               // Ably 发送心跳消息是纯文本 'ping'，忽略它们
+               if (typeof data !== 'string' || data === 'ping') {
+                   return;
+               }
+
+              try {
+                 msg = JSON.parse(data);
+              } catch (e) {
+                 console.warn("接收到非 JSON 的 WS 消息:", data);
+                 return; // 忽略不是 JSON 的消息
+              }
+
+
+              let firstMsg = msg?.messages?.[0];
+
+              // 根据从 postmessage 获取的特定 requestId 过滤消息
+              const messageRequestId = firstMsg?.data && typeof firstMsg.data === 'string' && isJsonString(firstMsg.data)
+                                     ? JSON.parse(firstMsg.data).individual_run_request_id
+                                     : null;
+
+              // 只处理与当前请求相关的消息
+              if (requestId && messageRequestId !== requestId) {
+                  // console.log(`忽略针对请求 ID ${messageRequestId} 的 WS 消息，期望 ${requestId}`);
+                  return;
+              }
+               // 否则：如果 requestId 匹配或消息是 Ably 协议消息，继续处理
+
+
+              if (
+                      firstMsg?.name === "UPDATE_LAST_MESSAGE" &&
+                      typeof firstMsg.data === "string" &&
+                      isJsonString(firstMsg.data)
+                  ) {
+                  const messageData = JSON.parse(firstMsg.data);
+                  // 确保 payload 和消息结构存在
+                  if (messageData.payload?.message?.content?.[0]?.text !== undefined) {
+                      const currentContent = messageData.payload.message.content[0].text;
+                      const newChunk = findDifference(last, currentContent);
+                      last = currentContent;
+                      nonstr += newChunk; // 为非流式累积内容
+
+                      if (databody.stream === true && newChunk.length > 0) {
+                          // 将块以 Server-Sent Events 格式写入流
+                          const sseChunk = `data: {"id":"chatcmpl-${uuidv4()}","object":"chat.completion.chunk","created":${Math.floor(Date.now() / 1000)},"model":"${databody.model || 'unknown-model'}","choices":[{"index":0,"delta":{"content":${JSON.stringify(newChunk)}},"logprobs":null,"finish_reason":null}]} \n\n`;
+                           await writer.write(encoder.encode(sseChunk));
+                      }
+                  }
+
+              } else if (
+                  firstMsg?.name === "INDIVIDUAL_RUN_COMPLETE" &&
+                  typeof firstMsg.data === "string" &&
+                  isJsonString(firstMsg.data)
+                  ){
+                     // 确保这是针对我们特定请求的完成消息
+                     const messageData = JSON.parse(firstMsg.data);
+                     if (messageData.individual_run_request_id === requestId) {
+
+                          if (databody.stream === true) { // 只在流式模式下发送结束信号
+                              // 流式：发送最终块并结束流
+                               const sseEnd = `data: {"id":"chatcmpl-${uuidv4()}","object":"chat.completion.chunk","model":"${databody.model || 'unknown-model'}","created":${Math.floor(Date.now() / 1000)},"choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}\n\n`;
+                              await writer.write(encoder.encode(sseEnd));
+                              await writer.write(encoder.encode('data: [DONE]\n')); // SSE 结束信号
+                          }
+                           // 非流式模式下，内容已累积在 nonstr 中，将在 wsComplete Promise resolve 后返回最终 JSON 响应。
+
+                          // 关闭流和 WebSocket
+                          await writer.close(); // 关闭流写入器
+                          ws.close(); // 显式关闭 WebSocket
+                     }
+
+              } else if (msg.action === 0) {
+                  // Ably 协议消息指示连接关闭
+                  console.log("Ably WS 被服务器关闭 (action 0)");
+                  // 清理流和 WS
+                  await writer.close(); // 关闭流写入器
+                  ws.close(); // 确保我们也关闭 WS
+              }
+
+          } catch (err) {
+              console.error("处理 WS 消息错误:", err);
+               // 在任何消息处理错误时，尝试中止流写入器并关闭 WebSocket
+               writer.abort(err).catch(() => {});
+               ws.close();
+               reject(err); // 在错误时 reject 主 promise
+          }
+      };
+
+      ws.onerror = (event) => {
+          const errorMsg = event.message || '未知 WebSocket 错误';
+          console.error("WebSocket 错误:", errorMsg, event);
+          // 在 WebSocket 错误时，中止流写入器并 reject 主 promise
+          writer.abort(new Error(`WebSocket 错误: ${errorMsg}`)).catch(() => {});
+          // ws.close() 可能在 onerror 后自动发生，但调用它没有坏处
+          reject(new Error(`WebSocket 错误: ${errorMsg}`));
+      };
+
+      ws.onclose = (event) => {
+          console.log(`WebSocket 已关闭: Code=${event.code}, Reason=${event.reason}, WasClean=${event.wasClean}`);
+           // 确保写入器已关闭/中止（如果尚未完成）
+           // 这对于 waitUntil 了解任务何时完成非常重要
+           if (!event.wasClean) {
+               // 如果不是干净关闭，中止流
+               writer.abort(new Error(`WebSocket 非干净关闭: Code=${event.code}, Reason=${event.reason}`)).catch(() => {});
+               reject(new Error(`WebSocket 非干净关闭: Code=${event.code}`));
+           } else {
+               // 如果是干净关闭，确保写入器已关闭（如果在 INDIVIDUAL_RUN_COMPLETE 时关闭了）
+               // 如果在完成之前以某种方式干净关闭，可能会有问题。
+               // 我们在这里 resolve 是假设干净关闭意味着过程已成功完成（或优雅地取消了）。
+               writer.close().catch(() => {});
+               resolve(); // 在干净关闭时 resolve 主 promise
+           }
+      };
+  });
+
+
+  // 将 WebSocket 过程添加到 waitUntil 中，以保持 Worker 活跃
+  ctx.waitUntil(wsComplete);
+
+  // 立即返回响应。
+  // 对于流式响应，此响应包含可读流。
+  // 对于非流式响应，流将接收所有块，然后关闭，最终的 JSON 响应将在流完成后
+  // 根据累积的 'nonstr' 变量构建。
+  // 这是一种使用单个 WS 交互处理流式和非流式响应的模式。
+
+  if (databody.stream === true) {
+      // 流式响应
+      return new Response(stream.readable, {
+          headers: {
+              'Content-Type': 'text/event-stream', // Server-Sent Events MIME 类型
+              'Cache-Control': 'no-cache',
+              'Connection': 'keep-alive',
+              ...corsHeaders // 包含 CORS 头
+          },
+      });
+  } else {
+      // 非流式响应：累积数据，并在 WS 完成后发送最终 JSON
+      // 响应对象现在被创建并返回，但其响应体是异步填充的，
+      // 基于 'nonstr' 变量在 wsComplete promise resolve *之后*。这需要微调。
+
+      // 更好的非流式处理方法：在返回 Response 之前等待 wsComplete 完成，
+      // 然后构建并返回最终的 JSON 响应。
+      // 这简化了响应处理逻辑。
+
+      // 等待 WebSocket 过程完成
+      try {
+          await wsComplete;
+
+          // 构建最终的非流式 JSON 响应
+           return Response.json({
+              id: `chatcmpl-${uuidv4()}`, // 为最终完成生成新的 ID
+              object: "chat.completion",
+              created: Math.floor(Date.now() / 1000),
+              model: databody.model || 'unknown-model',
+              choices: [
+                  {
+                      index: 0,
+                      message: {
+                          role: "assistant",
+                          content: nonstr, // 使用累积的内容
+                      },
+                      finish_reason: "stop", // 假设完成时是 'stop'
+                  },
+              ],
+              usage: { // 在这种代理设置中通常未知 Usage
+                  prompt_tokens: 0,
+                  completion_tokens: 0,
+                  total_tokens: 0,
+              },
+              system_fingerprint: null, // 或尽可能派生
+          }, { headers: corsHeaders });
+
+      } catch (err) {
+          console.error("WebSocket 或非流式完成过程中发生错误:", err);
+          // 处理 WS 过程中的错误（对于非流式）
+          return Response.json({ code: 2, msg: '处理错误', error: err.message }, { status: 500, headers: corsHeaders });
+      }
+  }
+}
+
+
+export async function handleRequest(request, env, ctx) {
+    const url = new URL(request.url);
+    const { pathname } = url;
+    const method = request.method;
+  
+    // 为所有响应设置 CORS 头
+    const corsHeaders = {
+      'Access-Control-Allow-Origin': '*', // 在生产环境中应更严格
+      'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+      'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+    };
+  
+    // 处理 CORS 预检请求
+    if (method === 'OPTIONS') {
+        return new Response(null, {
+            headers: {
+                ...corsHeaders,
+                'Access-Control-Max-Age': '86400', // 缓存预检请求 24 小时
+            },
+        });
+    }
+  
+  
+    if (method === 'GET' && pathname === '/') {
+        // 简单的欢迎消息，等同于 app.get("/")
+        return new Response("https://linux.do/t/topic/663505", { headers: corsHeaders });
+    }
+  
+    if (method === 'GET' && pathname === '/v1/models') {
+        return handleModels(request, corsHeaders);
+    }
+  
+    if (method === 'POST' && pathname === '/v1/chat/completions') {
+        return handleChatCompletions(request, ctx, corsHeaders); // 传递 event 以使用 waitUntil
+    }
+  
+    // 处理其他路径或方法
+    return new Response('未找到', { status: 404, headers: corsHeaders });
+}
+
+
+export default {
+    async fetch(request, env, ctx) {
+      return handleRequest(request, env, ctx);
+    },
+ };