@fudrouter/fsrouter 0.6.63 → 0.6.64

package/open-sse/executors/copilot-web.js

@@ -1,580 +0,0 @@
-import { BaseExecutor } from "./base.ts";
-import { FETCH_TIMEOUT_MS } from "../config/constants.ts";
-import { createHash } from "node:crypto";
-import { sanitizeErrorMessage } from "../utils/error.js";
-const COPILOT_BASE = "https://copilot.microsoft.com";
-const COPILOT_START_URL = `${COPILOT_BASE}/c/api/start`;
-const COPILOT_WS_URL = "wss://copilot.microsoft.com/c/api/chat?api-version=2";
-const COPILOT_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36";
-const MODEL_MODE_MAP = {
-  copilot: "chat",
-  "copilot-chat": "chat",
-  "gpt-4o": "chat",
-  "gpt-4": "chat",
-  "copilot-think": "reasoning",
-  "copilot-think-deeper": "reasoning",
-  o1: "reasoning",
-  o3: "reasoning",
-  "copilot-smart": "smart",
-  "copilot-gpt5": "smart",
-  "gpt-5": "smart",
-  "copilot-study": "chat"
-};
-const DEFAULT_MODE = "chat";
-function getCopilotMode(model) {
-  if (!model) return DEFAULT_MODE;
-  const lower = model.toLowerCase();
-  return MODEL_MODE_MAP[lower] || DEFAULT_MODE;
-}
-const MAX_HASHCASH_DIFFICULTY = 8;
-function solveHashcash(parameter, difficulty) {
-  if (!Number.isInteger(difficulty) || difficulty < 1 || difficulty > MAX_HASHCASH_DIFFICULTY) {
-    return null;
-  }
-  const prefix = "0".repeat(difficulty);
-  for (let i = 0; i < 1e7; i++) {
-    const hash = createHash("sha256").update(`${parameter}:${i}`).digest("hex");
-    if (hash.startsWith(prefix)) return i;
-  }
-  return null;
-}
-function extractAccessToken(credential) {
-  if (!credential) return null;
-  if (credential.startsWith("ey") || credential.length > 100) return credential;
-  const match = credential.match(/access_token=([^;]+)/);
-  if (match) return match[1];
-  const bearerMatch = credential.match(/[Bb]earer\s+(.+)/);
-  if (bearerMatch) return bearerMatch[1];
-  return credential;
-}
-function sessionPoolKey(token) {
-  return token && token.length > 0 ? token : "anonymous";
-}
-const sessionPool = /* @__PURE__ */ new Map();
-let sessionRotationCount = 0;
-const MIN_REMAINING_TURNS = 5;
-const MAX_ROTATIONS = 1e3;
-const MAX_POOL_SIZE = 100;
-class CopilotWebExecutor extends BaseExecutor {
-  constructor() {
-    super("copilot-web", { id: "copilot-web", baseUrl: COPILOT_START_URL });
-  }
-  /**
-   * Get or create a session. Rotates when remainingTurns is low or blocked.
-   */
-  async getSession(accessToken, signal) {
-    const poolKey = sessionPoolKey(accessToken);
-    const existing = sessionPool.get(poolKey);
-    if (existing && !existing.isBlocked && existing.remainingTurns > MIN_REMAINING_TURNS && Date.now() - existing.createdAt < 36e5) {
-      return existing;
-    }
-    if (sessionRotationCount >= MAX_ROTATIONS) {
-      sessionRotationCount = 0;
-    }
-    const session = await this.createSession(accessToken, signal);
-    if (sessionPool.size >= MAX_POOL_SIZE) {
-      sessionPool.delete(sessionPool.keys().next().value);
-    }
-    sessionPool.set(poolKey, session);
-    sessionRotationCount++;
-    return session;
-  }
-  /**
-   * Create a fresh session with new cookies and conversationId.
-   */
-  async createSession(accessToken, signal) {
-    const headers = {
-      "Content-Type": "application/json",
-      "User-Agent": COPILOT_USER_AGENT,
-      Origin: COPILOT_BASE,
-      Referer: `${COPILOT_BASE}/`
-    };
-    if (accessToken) {
-      headers["Authorization"] = `Bearer ${accessToken}`;
-    }
-    const res = await fetch(COPILOT_START_URL, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({
-        timeZone: "America/New_York",
-        startNewConversation: true,
-        teenSupportEnabled: false
-      }),
-      signal
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`Copilot /c/api/start failed (${res.status}): ${text.slice(0, 200)}`);
-    }
-    const data = await res.json();
-    const convId = data.currentConversationId || data.conversationId;
-    if (!convId) {
-      throw new Error("Copilot /c/api/start returned no conversationId");
-    }
-    const setCookies = res.headers.getSetCookie();
-    const cookies = setCookies.map((c) => c.split(";")[0]).join("; ");
-    return {
-      conversationId: convId,
-      cookies,
-      remainingTurns: data.remainingTurns ?? 1e3,
-      isBlocked: data.isBlocked ?? false,
-      createdAt: Date.now()
-    };
-  }
-  /**
-   * Send a message via WebSocket and collect the streamed response.
-   */
-  async wsChat(conversationId, prompt, mode, accessToken, signal) {
-    const wsUrl = `${COPILOT_WS_URL}&clientSessionId=${crypto.randomUUID()}`;
-    return new ReadableStream(
-      {
-        start: async (controller) => {
-          const encoder = new TextEncoder();
-          let ws = null;
-          let settled = false;
-          const cleanup = () => {
-            if (ws) {
-              try {
-                ws.close();
-              } catch {
-              }
-              ws = null;
-            }
-          };
-          const finish = () => {
-            if (settled) return;
-            settled = true;
-            cleanup();
-            controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-            controller.close();
-          };
-          const abort = (reason) => {
-            if (settled) return;
-            settled = true;
-            cleanup();
-            if (reason) {
-              controller.enqueue(
-                encoder.encode(`data: ${JSON.stringify({ error: { message: reason } })}
-
-`)
-              );
-            }
-            controller.close();
-          };
-          signal?.addEventListener("abort", () => abort("Request aborted"), { once: true });
-          try {
-            let WS = globalThis.WebSocket;
-            if (!WS) {
-              WS = (await import("ws")).default;
-              if (accessToken) {
-                ws = new WS(wsUrl, {
-                  headers: { Authorization: `Bearer ${accessToken}` }
-                });
-              }
-            }
-            if (!ws) {
-              ws = new WS(wsUrl);
-            }
-            const timeout = setTimeout(() => abort("Copilot WebSocket timeout"), FETCH_TIMEOUT_MS);
-            let chatSent = false;
-            const sendChat = () => {
-              if (chatSent) return;
-              chatSent = true;
-              ws.send(
-                JSON.stringify({
-                  event: "send",
-                  conversationId,
-                  content: [{ type: "text", text: prompt }],
-                  mode
-                })
-              );
-            };
-            ws.onopen = () => {
-              sendChat();
-            };
-            ws.onmessage = (ev) => {
-              try {
-                const event = typeof ev.data === "string" ? JSON.parse(ev.data) : JSON.parse(String(ev.data));
-                switch (event.event) {
-                  case "challenge": {
-                    if (event.method === "hashcash" && event.parameter) {
-                      const parts = String(event.parameter).split(":");
-                      const param = parts[0];
-                      const difficulty = parseInt(parts[1] || "1", 10);
-                      const solution = solveHashcash(param, difficulty);
-                      ws.send(
-                        JSON.stringify({
-                          event: "challengeResponse",
-                          token: solution !== null ? String(solution) : "",
-                          method: "hashcash"
-                        })
-                      );
-                      chatSent = false;
-                      sendChat();
-                    } else if (event.method === "cloudflare") {
-                      abort(
-                        "Copilot requires Cloudflare Turnstile verification. Use an authenticated session (access_token) instead."
-                      );
-                    } else {
-                      abort(
-                        `Copilot challenge "${event.method}" not supported. Use an authenticated session.`
-                      );
-                    }
-                    break;
-                  }
-                  case "appendText": {
-                    if (event.text) {
-                      const chunk = {
-                        id: `chatcmpl-copilot-${Date.now()}`,
-                        object: "chat.completion.chunk",
-                        created: Math.floor(Date.now() / 1e3),
-                        model: "copilot",
-                        choices: [
-                          {
-                            index: 0,
-                            delta: { content: event.text },
-                            finish_reason: null
-                          }
-                        ]
-                      };
-                      controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}
-
-`));
-                    }
-                    break;
-                  }
-                  case "chainOfThought": {
-                    if (event.text) {
-                      const chunk = {
-                        id: `chatcmpl-copilot-${Date.now()}`,
-                        object: "chat.completion.chunk",
-                        created: Math.floor(Date.now() / 1e3),
-                        model: "copilot",
-                        choices: [
-                          {
-                            index: 0,
-                            delta: { reasoning_content: event.text },
-                            finish_reason: null
-                          }
-                        ]
-                      };
-                      controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}
-
-`));
-                    }
-                    break;
-                  }
-                  case "replaceText": {
-                    if (event.text) {
-                      const chunk = {
-                        id: `chatcmpl-copilot-${Date.now()}`,
-                        object: "chat.completion.chunk",
-                        created: Math.floor(Date.now() / 1e3),
-                        model: "copilot",
-                        choices: [
-                          {
-                            index: 0,
-                            delta: { content: event.text },
-                            finish_reason: null
-                          }
-                        ]
-                      };
-                      controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}
-
-`));
-                    }
-                    break;
-                  }
-                  case "imageGenerated": {
-                    if (event.url) {
-                      const chunk = {
-                        id: `chatcmpl-copilot-${Date.now()}`,
-                        object: "chat.completion.chunk",
-                        created: Math.floor(Date.now() / 1e3),
-                        model: "copilot",
-                        choices: [
-                          {
-                            index: 0,
-                            delta: {
-                              content: [
-                                {
-                                  type: "image_url",
-                                  image_url: { url: event.url, detail: "auto" }
-                                }
-                              ]
-                            },
-                            finish_reason: null
-                          }
-                        ]
-                      };
-                      controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}
-
-`));
-                    }
-                    break;
-                  }
-                  case "citation": {
-                    if (event.url) {
-                      const annotation = {
-                        type: "url_citation",
-                        url_citation: {
-                          url: event.url,
-                          title: event.title || event.url
-                        }
-                      };
-                      const chunk = {
-                        id: `chatcmpl-copilot-${Date.now()}`,
-                        object: "chat.completion.chunk",
-                        created: Math.floor(Date.now() / 1e3),
-                        model: "copilot",
-                        choices: [
-                          {
-                            index: 0,
-                            delta: { annotations: [annotation] },
-                            finish_reason: null
-                          }
-                        ]
-                      };
-                      controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}
-
-`));
-                    }
-                    break;
-                  }
-                  case "suggestedFollowups": {
-                    if (event.suggestions && Array.isArray(event.suggestions)) {
-                      const chunk = {
-                        id: `chatcmpl-copilot-${Date.now()}`,
-                        object: "chat.completion.chunk",
-                        created: Math.floor(Date.now() / 1e3),
-                        model: "copilot",
-                        choices: [
-                          {
-                            index: 0,
-                            delta: {
-                              content: `
-
-**Suggested follow-ups:**
-${event.suggestions.map((s) => `- ${s}`).join("\n")}`
-                            },
-                            finish_reason: null
-                          }
-                        ]
-                      };
-                      controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}
-
-`));
-                    }
-                    break;
-                  }
-                  case "done": {
-                    clearTimeout(timeout);
-                    const finalChunk = {
-                      id: `chatcmpl-copilot-${Date.now()}`,
-                      object: "chat.completion.chunk",
-                      created: Math.floor(Date.now() / 1e3),
-                      model: "copilot",
-                      choices: [
-                        {
-                          index: 0,
-                          delta: {},
-                          finish_reason: "stop"
-                        }
-                      ]
-                    };
-                    controller.enqueue(encoder.encode(`data: ${JSON.stringify(finalChunk)}
-
-`));
-                    finish();
-                    break;
-                  }
-                  case "error": {
-                    clearTimeout(timeout);
-                    abort(event.error || "Copilot stream error");
-                    break;
-                  }
-                  // Ignore other events: connected, received, citation, etc.
-                  default:
-                    break;
-                }
-              } catch {
-              }
-            };
-            ws.onerror = (err) => {
-              clearTimeout(timeout);
-              const msg = err.message || "Copilot WebSocket error";
-              abort(msg);
-            };
-            ws.onclose = () => {
-              clearTimeout(timeout);
-              finish();
-            };
-          } catch (err) {
-            abort(err instanceof Error ? err.message : "Failed to connect to Copilot");
-          }
-        }
-      },
-      { highWaterMark: 16384 }
-    );
-  }
-  /**
-   * Main execute method — translates OpenAI format to Copilot WebSocket protocol.
-   */
-  async execute(input) {
-    const { credentials, signal, model: inputModel, stream: inputStream } = input;
-    const body = input.body;
-    const model = inputModel || body?.model || "copilot";
-    const mode = getCopilotMode(model);
-    const stream = inputStream !== false;
-    const rawCred = credentials?.apiKey || credentials?.providerSpecificData?.cookie || "";
-    const accessToken = extractAccessToken(rawCred);
-    const messages = body?.messages || [];
-    const userMsg = messages.filter((m) => m.role === "user").pop();
-    const systemMsgs = messages.filter((m) => m.role === "system");
-    const prompt = userMsg?.content || "";
-    if (!prompt || typeof prompt === "string" && !prompt.trim()) {
-      return {
-        response: new Response(JSON.stringify({ error: { message: "No user message provided" } }), {
-          status: 400,
-          headers: { "Content-Type": "application/json" }
-        }),
-        url: COPILOT_START_URL,
-        headers: {},
-        transformedBody: null
-      };
-    }
-    let fullPrompt = "";
-    if (systemMsgs.length > 0) {
-      const sysText = systemMsgs.map((m) => typeof m.content === "string" ? m.content : "").filter(Boolean).join("\n");
-      if (sysText) fullPrompt += `[System Instructions]
-${sysText}
-
-`;
-    }
-    fullPrompt += typeof prompt === "string" ? prompt : JSON.stringify(prompt);
-    let conversationId;
-    let sessionCookies = "";
-    try {
-      const session = await this.getSession(accessToken || void 0, signal);
-      conversationId = session.conversationId;
-      sessionCookies = session.cookies;
-    } catch (err) {
-      const msg = sanitizeErrorMessage(
-        err instanceof Error ? err.message : "Failed to start Copilot conversation"
-      );
-      return {
-        response: new Response(JSON.stringify({ error: { message: msg } }), {
-          status: 502,
-          headers: { "Content-Type": "application/json" }
-        }),
-        url: COPILOT_START_URL,
-        headers: accessToken ? { Authorization: `Bearer ${accessToken.slice(0, 20)}...` } : {},
-        transformedBody: { conversationId: null, mode, prompt: fullPrompt.slice(0, 100) }
-      };
-    }
-    if (!stream) {
-      try {
-        const wsStream = await this.wsChat(
-          conversationId,
-          fullPrompt,
-          mode,
-          accessToken || void 0,
-          signal
-        );
-        const reader = wsStream.getReader();
-        const decoder = new TextDecoder();
-        let fullText = "";
-        let reasoningText = "";
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          const lines = decoder.decode(value, { stream: true }).split("\n");
-          for (const line of lines) {
-            if (!line.startsWith("data: ")) continue;
-            const data = line.slice(6).trim();
-            if (data === "[DONE]") continue;
-            try {
-              const parsed = JSON.parse(data);
-              const delta = parsed.choices?.[0]?.delta;
-              if (delta?.content) fullText += delta.content;
-              if (delta?.reasoning_content) reasoningText += delta.reasoning_content;
-            } catch {
-            }
-          }
-        }
-        const result = {
-          id: `chatcmpl-copilot-${Date.now()}`,
-          object: "chat.completion",
-          created: Math.floor(Date.now() / 1e3),
-          model,
-          choices: [
-            {
-              index: 0,
-              message: { role: "assistant", content: fullText || "(empty response)" },
-              finish_reason: "stop"
-            }
-          ],
-          usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
-        };
-        return {
-          response: new Response(JSON.stringify(result), {
-            headers: { "Content-Type": "application/json" }
-          }),
-          url: COPILOT_WS_URL,
-          headers: {},
-          transformedBody: { conversationId, mode, prompt: fullPrompt.slice(0, 100) }
-        };
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : "Copilot non-streaming error";
-        return {
-          response: new Response(JSON.stringify({ error: { message: msg } }), {
-            status: 502,
-            headers: { "Content-Type": "application/json" }
-          }),
-          url: COPILOT_WS_URL,
-          headers: {},
-          transformedBody: { conversationId, mode }
-        };
-      }
-    }
-    try {
-      const wsStream = await this.wsChat(
-        conversationId,
-        fullPrompt,
-        mode,
-        accessToken || void 0,
-        signal
-      );
-      return {
-        response: new Response(wsStream, {
-          headers: {
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache",
-            Connection: "keep-alive"
-          }
-        }),
-        url: COPILOT_WS_URL,
-        headers: {},
-        transformedBody: { conversationId, mode, prompt: fullPrompt.slice(0, 100) }
-      };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : "Copilot streaming error";
-      return {
-        response: new Response(JSON.stringify({ error: { message: msg } }), {
-          status: 502,
-          headers: { "Content-Type": "application/json" }
-        }),
-        url: COPILOT_WS_URL,
-        headers: {},
-        transformedBody: { conversationId, mode }
-      };
-    }
-  }
-}
-export {
-  CopilotWebExecutor,
-  extractAccessToken,
-  getCopilotMode,
-  sessionPoolKey,
-  solveHashcash
-};