@fudrouter/fsrouter 0.6.61 → 0.6.63

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

@@ -0,0 +1,580 @@
+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
+};