@fudrouter/fsrouter 0.6.64 → 0.6.65

package/open-sse/executors/copilot-m365-connection.js

@@ -0,0 +1,176 @@
+import { randomUUID, randomBytes } from "node:crypto";
+const M365_INDIVIDUAL_DEFAULTS = {
+  host: "substrate.office.com",
+  source: "officeweb",
+  product: "Office",
+  agentHost: "Bizchat.FullScreen",
+  licenseType: "Starter",
+  agent: "web",
+  scenario: "OfficeWebPaidConsumerCopilot"
+};
+const M365_EDU_OVERRIDES = {
+  scenario: "OfficeWebIncludedCopilot",
+  isEdu: "true",
+  licenseType: "Starter"
+};
+const M365_ENTERPRISE_OVERRIDES = {
+  agent: "work",
+  scenario: "officeweb",
+  licenseType: "Premium"
+};
+const M365_DEFAULT_VARIANTS = [
+  "EnableMcpServerWidgets",
+  "feature.EnableMcpServerWidgets",
+  "feature.EnableLuForChatCIQ",
+  "feature.enableChatCIQPlugin",
+  "EnableRequestPlugins",
+  "feature.EnableSensitivityLabels",
+  "EnableUnsupportedUrlDetector",
+  "feature.IsCustomEngineCopilotEnabled",
+  "feature.bizchatfluxv3",
+  "feature.enablechatpages",
+  "feature.enableCodeCanvas",
+  "feature.turnOnDARecommendation",
+  "feature.IsStreamingModeInChatRequestEnabled",
+  "IncludeSourceAttributionsConcise",
+  "SkipPublishEmptyMessage",
+  "feature.EnableDeduplicatingSourceAttributions",
+  "Enable3PActionProgressMessages",
+  "feature.enableClientWebRtc",
+  "feature.EnableMeetingRecapOfSeriesMeetingWithCiq",
+  "feature.cwcfluxv3fe",
+  "feature.cwcfluxv3fem",
+  "feature.EnableReferencesListCompleteSignal",
+  "feature.StorageMessageSplitDisabled",
+  "feature.EnableCuaTakeControlApi",
+  "SingletonEnvOn",
+  "EnableComposeWidget",
+  "feature.cwcallowedos",
+  "feature.EnableMergingPureDeltas",
+  "feature.disabledisallowedmsgs",
+  "feature.enableCitationsForSynthesisData",
+  "feature.EnableConversationShareApis",
+  "feature.enableGenerateGraphicArtOptionsSet",
+  "cdximagen",
+  "feature.EnableUpdatedUXForConfirmationDialog",
+  "feature.EnableContentApiandDocTypeHtmlInRichAnswers",
+  "cdxgrounding_api_v2_rich_web_answers_reference_bottom_force",
+  "cdxenablerenderforisocomp",
+  "feature.EnableClientFileURLSupportForOfficeWebPaidCopilot",
+  "feature.EnableDesignEditorImageGrounding",
+  "feature.EnableDesignerEditor",
+  "feature.EnableSkipRehydrationForSpeCIdImages",
+  "feature.EnablePersonalizationForMSA",
+  "agt_bizchat_enableRichResponses",
+  "feature.EnableBase64DataInMessageAnnotations",
+  "feature.EnableSkipEmittingMessageOnFlush",
+  "feature.EnableRemoveEmptySourceAttributions",
+  "feature.EnableRemoveStreamingMode"
+];
+function newChatSessionId() {
+  return randomBytes(16).toString("hex");
+}
+function parsePastedCredential(raw) {
+  const value = raw.trim();
+  const parts = {};
+  for (const segment of value.split(/[;\n]/)) {
+    const separator = segment.indexOf("=");
+    if (separator <= 0) continue;
+    const key = segment.slice(0, separator).trim();
+    const partValue = segment.slice(separator + 1).trim();
+    if (key && partValue) parts[key] = partValue;
+  }
+  if (/^wss:\/\/substrate\.office\.com\/m365Copilot\/Chathub\//i.test(value)) {
+    try {
+      const url = new URL(value);
+      parts.access_token ||= url.searchParams.get("access_token") || "";
+      parts.chathubPath ||= decodeURIComponent(
+        url.pathname.split("/m365Copilot/Chathub/")[1] || ""
+      );
+    } catch {
+    }
+  }
+  return {
+    accessToken: parts.access_token || parts.accessToken,
+    chathubPath: parts.chathubPath || parts.userTenant
+  };
+}
+function resolveConnectionParams(credentials) {
+  const psd = credentials?.providerSpecificData ?? {};
+  const parsedApiKey = typeof credentials?.apiKey === "string" ? parsePastedCredential(credentials.apiKey) : {};
+  const accessToken = parsedApiKey.accessToken || typeof credentials?.apiKey === "string" && credentials.apiKey && !credentials.apiKey.includes("access_token=") && credentials.apiKey || typeof psd.accessToken === "string" && psd.accessToken || typeof psd.access_token === "string" && psd.access_token || "";
+  if (!accessToken) {
+    return { error: "Missing M365 Copilot access_token. Paste it as the provider credential." };
+  }
+  const chathubPath = parsedApiKey.chathubPath || typeof psd.chathubPath === "string" && psd.chathubPath || typeof psd.userTenant === "string" && psd.userTenant || "";
+  if (!chathubPath || !chathubPath.includes("@")) {
+    return {
+      error: "Missing M365 Chathub path. Paste the '<user-oid>@<tenant-id>' segment from the WebSocket URL."
+    };
+  }
+  const host = typeof psd.host === "string" && psd.host || M365_INDIVIDUAL_DEFAULTS.host;
+  const variants = typeof psd.variants === "string" && psd.variants ? psd.variants : void 0;
+  return { host, chathubPath, accessToken, variants, ...resolveTierOverrides(psd) };
+}
+function resolveTierOverrides(psd) {
+  const tier = typeof psd.tier === "string" ? psd.tier.toLowerCase() : "";
+  const isEduTier = tier === "edu" || tier === "included";
+  const isEnterpriseTier = tier === "enterprise" || tier === "work";
+  const psdIsEdu = typeof psd.isEdu === "string" && psd.isEdu || typeof psd.isEdu === "boolean" && String(psd.isEdu) || void 0;
+  return {
+    scenario: typeof psd.scenario === "string" && psd.scenario || (isEduTier ? M365_EDU_OVERRIDES.scenario : void 0) || (isEnterpriseTier ? M365_ENTERPRISE_OVERRIDES.scenario : void 0),
+    isEdu: psdIsEdu || (isEduTier ? M365_EDU_OVERRIDES.isEdu : void 0),
+    licenseType: typeof psd.licenseType === "string" && psd.licenseType || (isEduTier ? M365_EDU_OVERRIDES.licenseType : void 0) || (isEnterpriseTier ? M365_ENTERPRISE_OVERRIDES.licenseType : void 0),
+    agent: typeof psd.agent === "string" && psd.agent || (isEnterpriseTier ? M365_ENTERPRISE_OVERRIDES.agent : void 0)
+  };
+}
+function buildWsUrl(params) {
+  const sessionKey = newChatSessionId();
+  const query = new URLSearchParams({
+    chatsessionid: sessionKey,
+    XRoutingParameterSessionKey: sessionKey,
+    clientrequestid: sessionKey,
+    "X-SessionId": randomUUID(),
+    ConversationId: randomUUID(),
+    access_token: params.accessToken,
+    variants: params.variants ?? M365_DEFAULT_VARIANTS.join(","),
+    source: M365_INDIVIDUAL_DEFAULTS.source,
+    product: M365_INDIVIDUAL_DEFAULTS.product,
+    agentHost: M365_INDIVIDUAL_DEFAULTS.agentHost,
+    licenseType: params.licenseType ?? M365_INDIVIDUAL_DEFAULTS.licenseType,
+    isEdu: params.isEdu ?? "false",
+    agent: params.agent ?? M365_INDIVIDUAL_DEFAULTS.agent,
+    scenario: params.scenario ?? M365_INDIVIDUAL_DEFAULTS.scenario
+  });
+  return `wss://${params.host}/m365Copilot/Chathub/${params.chathubPath}?${query.toString()}`;
+}
+function redactWsUrl(wsUrl) {
+  return wsUrl.replace(/access_token=[^&]*/i, "access_token=REDACTED");
+}
+function buildPrompt(body) {
+  const messages = body?.messages || [];
+  const systemMsgs = messages.filter((m) => m.role === "system");
+  const userMsg = messages.filter((m) => m.role === "user").pop();
+  const userText = typeof userMsg?.content === "string" ? userMsg.content : JSON.stringify(userMsg?.content ?? "");
+  let prompt = "";
+  if (systemMsgs.length > 0) {
+    const sysText = systemMsgs.map((m) => typeof m.content === "string" ? m.content : "").filter(Boolean).join("\n");
+    if (sysText) prompt += `[System Instructions]
+${sysText}
+
+`;
+  }
+  prompt += userText;
+  return prompt;
+}
+export {
+  M365_DEFAULT_VARIANTS,
+  M365_EDU_OVERRIDES,
+  M365_ENTERPRISE_OVERRIDES,
+  M365_INDIVIDUAL_DEFAULTS,
+  buildPrompt,
+  buildWsUrl,
+  newChatSessionId,
+  redactWsUrl,
+  resolveConnectionParams
+};

package/open-sse/executors/copilot-m365-frames.js

@@ -0,0 +1,192 @@
+const RECORD_SEPARATOR = String.fromCharCode(30);
+const HANDSHAKE_REQUEST = { protocol: "json", version: 1 };
+const KEEPALIVE_PING = { type: 6 };
+const ALLOWED_MESSAGE_TYPES = [
+  "Chat",
+  "Suggestion",
+  "InternalSearchQuery",
+  "Disengaged",
+  "InternalLoaderMessage",
+  "Progress",
+  "GeneratedCode",
+  "RenderCardRequest",
+  "AdsQuery",
+  "SemanticSerp",
+  "GenerateContentQuery"
+];
+const M365_DEFAULT_OPTION_SETS = [
+  "search_result_progress_messages_with_search_queries",
+  "update_textdoc_response_after_streaming",
+  "deepleo_networking_timeout_10minutes_canmore",
+  "cwc_flux_image",
+  "cwc_code_interpreter",
+  "cwc_code_interpreter_amsfix",
+  "enable_msa_user",
+  "cwcgptv",
+  "flux_v3_gptv_enable_upload_multi_image_in_turn_wo_ch",
+  "gptvnorm2048",
+  "pdnascan",
+  "cwc_code_interpreter_citation_fix",
+  "code_interpreter_interactive_charts",
+  "cwc_code_interpreter_interactive_charts_inline_image",
+  "code_interpreter_matplotlib_patching",
+  "cwc_fileupload_odb",
+  "update_memory_plugin",
+  "add_custom_instructions",
+  "cwc_flux_v3",
+  "flux_v3_progress_messages",
+  "enable_batch_token_processing",
+  "enable_gg_gpt",
+  "flux_v3_image_gen_enable_non_watermarked_storage",
+  "flux_v3_image_gen_enable_story",
+  "rich_responses"
+];
+function encodeFrame(obj) {
+  return JSON.stringify(obj) + RECORD_SEPARATOR;
+}
+function handshakeFrame() {
+  return encodeFrame(HANDSHAKE_REQUEST);
+}
+function keepaliveFrame() {
+  return encodeFrame(KEEPALIVE_PING);
+}
+function splitFrames(buffer) {
+  const parts = buffer.split(RECORD_SEPARATOR);
+  const rest = parts.pop() ?? "";
+  const frames = parts.filter((p) => p.length > 0);
+  return { frames, rest };
+}
+function parseFrame(frame) {
+  const trimmed = frame.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function handshakeError(frame) {
+  if (!frame) return null;
+  const err = frame.error;
+  return typeof err === "string" && err.length > 0 ? err : null;
+}
+function buildChatInvocation(opts) {
+  return {
+    type: 4,
+    target: "chat",
+    invocationId: "0",
+    arguments: [
+      {
+        source: "officeweb",
+        clientCorrelationId: opts.traceId,
+        sessionId: opts.sessionId,
+        optionsSets: opts.optionsSets ?? [...M365_DEFAULT_OPTION_SETS],
+        streamingMode: "ConciseWithPadding",
+        spokenTextMode: "None",
+        options: {},
+        extraExtensionParameters: {},
+        allowedMessageTypes: [...ALLOWED_MESSAGE_TYPES],
+        sliceIds: [],
+        threadLevelGptId: {},
+        traceId: opts.traceId,
+        isStartOfSession: opts.isStartOfSession ?? true,
+        clientInfo: {},
+        message: {
+          author: "user",
+          inputMethod: "Keyboard",
+          text: opts.text,
+          messageType: "Chat"
+        },
+        plugins: [],
+        isSbsSupported: false,
+        tone: opts.tone ?? "",
+        renderReferencesBehindEOS: true,
+        disconnectBehavior: ""
+      }
+    ]
+  };
+}
+function isUpdateFrame(frame) {
+  return !!frame && frame.type === 1 && frame.target === "update";
+}
+function isCompletionFrame(frame) {
+  return !!frame && frame.type === 3;
+}
+function isLastUpdate(frame) {
+  if (!isUpdateFrame(frame)) return false;
+  const args = frame.arguments;
+  const first = Array.isArray(args) ? args[0] : void 0;
+  return first?.isLastUpdate === true;
+}
+function extractBotText(frame) {
+  if (!isUpdateFrame(frame)) return null;
+  const args = frame.arguments;
+  const first = Array.isArray(args) ? args[0] : void 0;
+  const messages = first?.messages;
+  if (!Array.isArray(messages)) return null;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (!m) continue;
+    const author = m.author;
+    const text = m.text;
+    if (m.messageType === "Progress" || m.contentType === "EarlyProgress") continue;
+    if ((author === "bot" || author === void 0) && typeof text === "string" && text.length > 0) {
+      return text;
+    }
+  }
+  return null;
+}
+function incrementalDelta(previous, next) {
+  if (!next) return "";
+  if (next === previous) return "";
+  if (next.startsWith(previous)) return next.slice(previous.length);
+  return next;
+}
+function extractWriteAtCursor(frame) {
+  if (!isUpdateFrame(frame)) return null;
+  const args = frame.arguments;
+  const first = Array.isArray(args) ? args[0] : void 0;
+  const wac = first?.writeAtCursor;
+  return typeof wac === "string" && wac.length > 0 ? wac : null;
+}
+function extractFinalResultMessage(frame) {
+  if (!frame || frame.type !== 2) return null;
+  const item = frame.item;
+  const result = item?.result;
+  const message = result?.message;
+  return typeof message === "string" && message.length > 0 ? message : null;
+}
+function accumulateBotContent(previous, frame) {
+  const snapshot = extractBotText(frame);
+  if (snapshot) {
+    return { delta: incrementalDelta(previous, snapshot), next: snapshot };
+  }
+  const wac = extractWriteAtCursor(frame);
+  if (wac) {
+    return { delta: wac, next: previous + wac };
+  }
+  return { delta: "", next: previous };
+}
+export {
+  ALLOWED_MESSAGE_TYPES,
+  HANDSHAKE_REQUEST,
+  KEEPALIVE_PING,
+  M365_DEFAULT_OPTION_SETS,
+  RECORD_SEPARATOR,
+  accumulateBotContent,
+  buildChatInvocation,
+  encodeFrame,
+  extractBotText,
+  extractFinalResultMessage,
+  extractWriteAtCursor,
+  handshakeError,
+  handshakeFrame,
+  incrementalDelta,
+  isCompletionFrame,
+  isLastUpdate,
+  isUpdateFrame,
+  keepaliveFrame,
+  parseFrame,
+  splitFrames
+};

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

@@ -0,0 +1,299 @@
+import WebSocket from "ws";
+import { FETCH_TIMEOUT_MS } from "../config/constants.ts";
+import { sanitizeErrorMessage } from "../utils/error.js";
+import { BaseExecutor } from "./base.ts";
+import {
+  buildPrompt,
+  buildWsUrl,
+  redactWsUrl,
+  resolveConnectionParams
+} from "./copilot-m365-connection.ts";
+import {
+  accumulateBotContent,
+  buildChatInvocation,
+  encodeFrame,
+  extractFinalResultMessage,
+  handshakeError,
+  handshakeFrame,
+  isCompletionFrame,
+  keepaliveFrame,
+  parseFrame,
+  splitFrames
+} from "./copilot-m365-frames.ts";
+let WebSocketCtor = WebSocket;
+function __setCopilotM365WebSocketForTesting(ctor) {
+  const previous = WebSocketCtor;
+  WebSocketCtor = ctor;
+  return () => {
+    WebSocketCtor = previous;
+  };
+}
+function sseChunk(model, delta, finishReason = null) {
+  return `data: ${JSON.stringify({
+    id: `chatcmpl-copilot-m365-${Date.now()}`,
+    object: "chat.completion.chunk",
+    created: Math.floor(Date.now() / 1e3),
+    model,
+    choices: [{ index: 0, delta, finish_reason: finishReason }]
+  })}
+
+`;
+}
+function errorResponse(message, status = 502) {
+  return new Response(JSON.stringify({ error: { message } }), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+class CopilotM365WebExecutor extends BaseExecutor {
+  constructor() {
+    super("copilot-m365-web", { id: "copilot-m365-web", baseUrl: "wss://substrate.office.com" });
+  }
+  async wsChat(input) {
+    const log = input.log ?? null;
+    return new ReadableStream(
+      {
+        start: async (controller) => {
+          const encoder = new TextEncoder();
+          let ws = null;
+          let settled = false;
+          let buffer = "";
+          let previousText = "";
+          let finalResultMessage = "";
+          let handshakeComplete = false;
+          const cleanup = () => {
+            if (ws) {
+              try {
+                ws.close();
+              } catch {
+              }
+              ws = null;
+            }
+          };
+          const finish = () => {
+            if (settled) return;
+            settled = true;
+            cleanup();
+            if (!previousText && finalResultMessage) {
+              controller.enqueue(
+                encoder.encode(sseChunk(input.model, { content: finalResultMessage }))
+              );
+            }
+            controller.enqueue(encoder.encode(sseChunk(input.model, {}, "stop")));
+            controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+            controller.close();
+          };
+          const abort = (reason) => {
+            if (settled) return;
+            settled = true;
+            cleanup();
+            const message = sanitizeErrorMessage(reason);
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ error: { message } })}
+
+`));
+            controller.close();
+          };
+          input.signal?.addEventListener("abort", () => abort("Request aborted"), { once: true });
+          const timeout = setTimeout(
+            () => abort("Microsoft 365 Copilot WebSocket timeout"),
+            FETCH_TIMEOUT_MS
+          );
+          try {
+            const wsUrlParts = new URL(input.wsUrl);
+            const traceId = wsUrlParts.searchParams.get("clientrequestid") ?? crypto.randomUUID().replace(/-/g, "");
+            const sessionId = wsUrlParts.searchParams.get("X-SessionId") ?? crypto.randomUUID();
+            log?.debug?.("M365_WS", `connecting \u2192 ${redactWsUrl(input.wsUrl)}`);
+            ws = new WebSocketCtor(input.wsUrl, {
+              headers: {
+                Origin: "https://m365.cloud.microsoft",
+                "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36"
+              }
+            });
+            const sendChat = () => {
+              ws?.send(keepaliveFrame());
+              ws?.send(
+                encodeFrame(
+                  buildChatInvocation({
+                    text: input.prompt,
+                    traceId,
+                    sessionId,
+                    isStartOfSession: true
+                  })
+                )
+              );
+            };
+            ws.on("open", () => {
+              log?.debug?.("M365_WS", "socket open \u2014 sending handshake");
+              ws?.send(handshakeFrame());
+            });
+            ws.on("message", (data) => {
+              if (settled) return;
+              buffer += data.toString();
+              const split = splitFrames(buffer);
+              buffer = split.rest;
+              for (const rawFrame of split.frames) {
+                const frame = parseFrame(rawFrame);
+                log?.debug?.(
+                  "M365_WS",
+                  `frame type=${String(frame?.type)} target=${String(frame?.target)}`
+                );
+                if (!handshakeComplete) {
+                  const err = handshakeError(frame);
+                  if (err) {
+                    clearTimeout(timeout);
+                    log?.debug?.("M365_WS", `handshake failed: ${err}`);
+                    abort(`Microsoft 365 Copilot handshake failed: ${err}`);
+                    return;
+                  }
+                  handshakeComplete = true;
+                  log?.debug?.("M365_WS", "handshake complete \u2014 sending chat invocation");
+                  sendChat();
+                  continue;
+                }
+                const { delta, next } = accumulateBotContent(previousText, frame);
+                previousText = next;
+                if (delta) {
+                  controller.enqueue(encoder.encode(sseChunk(input.model, { content: delta })));
+                }
+                const finalMsg = extractFinalResultMessage(frame);
+                if (finalMsg) {
+                  finalResultMessage = finalMsg;
+                }
+                if (isCompletionFrame(frame)) {
+                  clearTimeout(timeout);
+                  finish();
+                  return;
+                }
+              }
+            });
+            ws.on("error", (err) => {
+              clearTimeout(timeout);
+              log?.debug?.(
+                "M365_WS",
+                `socket error: ${err instanceof Error ? err.message : String(err)}`
+              );
+              abort(
+                sanitizeErrorMessage(
+                  err instanceof Error ? err.message : "Microsoft 365 Copilot WebSocket error"
+                )
+              );
+            });
+            ws.on("close", () => {
+              clearTimeout(timeout);
+              finish();
+            });
+          } catch (err) {
+            clearTimeout(timeout);
+            abort(
+              sanitizeErrorMessage(
+                err instanceof Error ? err.message : "Failed to connect to Microsoft 365 Copilot"
+              )
+            );
+          }
+        }
+      },
+      { highWaterMark: 16384 }
+    );
+  }
+  async execute(input) {
+    const body = input.body;
+    const model = input.model || body?.model || "copilot-m365";
+    const stream = input.stream !== false;
+    const prompt = buildPrompt(body).trim();
+    if (!prompt) {
+      return {
+        response: errorResponse("No user message provided", 400),
+        url: "wss://substrate.office.com/m365Copilot/Chathub",
+        headers: {},
+        transformedBody: null
+      };
+    }
+    const connectionParams = resolveConnectionParams(input.credentials);
+    if ("error" in connectionParams) {
+      return {
+        response: errorResponse(connectionParams.error, 400),
+        url: "wss://substrate.office.com/m365Copilot/Chathub",
+        headers: {},
+        transformedBody: { model, prompt: prompt.slice(0, 100) }
+      };
+    }
+    const wsUrl = buildWsUrl(connectionParams);
+    try {
+      const wsStream = await this.wsChat({
+        wsUrl,
+        prompt,
+        model,
+        signal: input.signal ?? void 0,
+        log: input.log
+      });
+      if (stream) {
+        return {
+          response: new Response(wsStream, {
+            headers: {
+              "Content-Type": "text/event-stream",
+              "Cache-Control": "no-cache",
+              Connection: "keep-alive"
+            }
+          }),
+          url: redactWsUrl(wsUrl),
+          headers: {},
+          transformedBody: { model, prompt: prompt.slice(0, 100) }
+        };
+      }
+      const reader = wsStream.getReader();
+      const decoder = new TextDecoder();
+      let fullText = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        for (const line of decoder.decode(value, { stream: true }).split("\n")) {
+          if (!line.startsWith("data: ")) continue;
+          const data = line.slice(6).trim();
+          if (!data || data === "[DONE]") continue;
+          try {
+            const parsed = JSON.parse(data);
+            const content = parsed.choices?.[0]?.delta?.content;
+            if (typeof content === "string") fullText += content;
+          } catch {
+          }
+        }
+      }
+      return {
+        response: new Response(
+          JSON.stringify({
+            id: `chatcmpl-copilot-m365-${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 }
+          }),
+          { headers: { "Content-Type": "application/json" } }
+        ),
+        url: redactWsUrl(wsUrl),
+        headers: {},
+        transformedBody: { model, prompt: prompt.slice(0, 100) }
+      };
+    } catch (err) {
+      const message = sanitizeErrorMessage(
+        err instanceof Error ? err.message : "Microsoft 365 Copilot executor error"
+      );
+      return {
+        response: errorResponse(message),
+        url: redactWsUrl(wsUrl),
+        headers: {},
+        transformedBody: { model, prompt: prompt.slice(0, 100) }
+      };
+    }
+  }
+}
+export {
+  CopilotM365WebExecutor,
+  __setCopilotM365WebSocketForTesting
+};