@omnicross/subscriptions 0.3.1 → 0.4.1

package/dist/chunk-L77HJY6V.js

@@ -0,0 +1,1109 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/oauth/flows/copilot.ts
+var copilot_exports = {};
+__export(copilot_exports, {
+  COPILOT_API_HEADERS: () => COPILOT_API_HEADERS,
+  COPILOT_FAR_FUTURE_MS: () => COPILOT_FAR_FUTURE_MS,
+  COPILOT_GITHUB_HEADERS: () => COPILOT_GITHUB_HEADERS,
+  COPILOT_OAUTH_CONFIG: () => COPILOT_OAUTH_CONFIG,
+  COPILOT_POLL_INITIAL_MULTIPLIER: () => COPILOT_POLL_INITIAL_MULTIPLIER,
+  COPILOT_POLL_SLOW_DOWN_MULTIPLIER: () => COPILOT_POLL_SLOW_DOWN_MULTIPLIER,
+  awaitCopilotDeviceToken: () => awaitCopilotDeviceToken,
+  copilotOAuthUrls: () => copilotOAuthUrls,
+  discoverCopilotApiEndpoint: () => discoverCopilotApiEndpoint,
+  enableAllCopilotModels: () => enableAllCopilotModels,
+  enableCopilotModel: () => enableCopilotModel,
+  fetchCopilotIdentity: () => fetchCopilotIdentity,
+  normalizeCopilotEnterpriseDomain: () => normalizeCopilotEnterpriseDomain,
+  pollCopilotDeviceToken: () => pollCopilotDeviceToken,
+  refreshCopilotToken: () => refreshCopilotToken,
+  requestCopilotDeviceAuthorization: () => requestCopilotDeviceAuthorization
+});
+
+// src/copilot/models.ts
+var WIRES = {
+  anthropic: /* @__PURE__ */ new Set([
+    "claude-haiku-4.5",
+    "claude-sonnet-4",
+    "claude-sonnet-4.5",
+    "claude-sonnet-4.6",
+    "claude-sonnet-5",
+    "claude-opus-4.5",
+    "claude-opus-4.6",
+    "claude-opus-4.7",
+    "claude-opus-4.8",
+    "claude-opus-5",
+    "claude-fable-5"
+  ]),
+  chat: /* @__PURE__ */ new Set([
+    "gpt-4o",
+    "gpt-4.1",
+    "grok-code-fast-1",
+    "gemini-2.5-pro",
+    "gemini-3.5-flash",
+    "gemini-3-flash-preview",
+    "gemini-3-pro-preview",
+    "gemini-3.6-flash",
+    "gemini-3.7-flash",
+    "gemini-3.1-pro-preview",
+    "raptor-mini",
+    "kimi-k2.7-code",
+    "kimi-k3"
+  ]),
+  responses: /* @__PURE__ */ new Set([
+    "gpt-5",
+    "gpt-5-mini",
+    "gpt-5.1",
+    "gpt-5.1-codex",
+    "gpt-5.1-codex-max",
+    "gpt-5.1-codex-mini",
+    "gpt-5.2",
+    "gpt-5.2-codex",
+    "gpt-5.3-codex",
+    "gpt-5.4",
+    "gpt-5.4-mini",
+    "gpt-5.4-nano",
+    "gpt-5.5",
+    "gpt-5.6-luna",
+    "gpt-5.6-sol",
+    "gpt-5.6-terra",
+    "grok-4.5",
+    "grok-4.6",
+    "mai-code-1-flash-picker",
+    "mai-code-1.1-flash"
+  ])
+};
+function copilotWireFor(modelId) {
+  if (WIRES.anthropic.has(modelId)) return "anthropic";
+  if (WIRES.chat.has(modelId)) return "chat";
+  return "responses";
+}
+function copilotPathFor(wire) {
+  if (wire === "anthropic") return "/v1/messages";
+  if (wire === "chat") return "/v1/chat/completions";
+  return "/v1/responses";
+}
+function copilotTransformerNamesForWire(wire) {
+  if (wire === "anthropic") return ["anthropic"];
+  if (wire === "chat") return ["openai"];
+  return ["openai-response"];
+}
+function copilotWireModelIds() {
+  return [...WIRES.anthropic, ...WIRES.chat, ...WIRES.responses];
+}
+function copilotBaseUrl(config) {
+  const endpoint = config?.apiEndpoint?.trim();
+  if (endpoint) return endpoint.replace(/\/+$/, "");
+  const enterprise = config?.enterpriseUrl?.trim().toLowerCase();
+  if (enterprise) {
+    const host = enterprise.startsWith("copilot-api.") ? enterprise : `copilot-api.${enterprise}`;
+    return `https://${host}`;
+  }
+  return "https://api.githubcopilot.com";
+}
+function copilotGitHubApiBase(enterpriseUrl) {
+  const enterprise = enterpriseUrl?.trim().toLowerCase();
+  if (!enterprise) return "https://api.github.com";
+  if (enterprise.startsWith("http://") || enterprise.startsWith("https://")) {
+    return enterprise.replace(/\/+$/, "");
+  }
+  if (enterprise.startsWith("api.")) return `https://${enterprise}`;
+  return `https://api.${enterprise}`;
+}
+
+// src/oauth/flows/copilot.ts
+var COPILOT_OAUTH_CONFIG = {
+  clientId: "Ov23ctDVkRmgkPke0Mmm",
+  scope: "read:user",
+  deviceEndpoint: "https://github.com/login/device/code",
+  tokenEndpoint: "https://github.com/login/oauth/access_token"
+};
+var PUBLIC_GITHUB_HOSTS = /* @__PURE__ */ new Set([
+  "github.com",
+  "www.github.com",
+  "api.github.com"
+]);
+function normalizeCopilotEnterpriseDomain(input) {
+  const trimmed = input?.trim();
+  if (!trimmed) return void 0;
+  let hostname2 = null;
+  try {
+    hostname2 = new URL(trimmed.includes("://") ? trimmed : `https://${trimmed}`).hostname;
+  } catch {
+    hostname2 = null;
+  }
+  const host = (hostname2 ?? trimmed).toLowerCase();
+  if (!host || PUBLIC_GITHUB_HOSTS.has(host)) return void 0;
+  if (!/^[a-z0-9][a-z0-9.-]*$/.test(host)) {
+    throw new Error(`invalid GitHub Enterprise domain '${trimmed}'`);
+  }
+  return host;
+}
+function copilotOAuthUrls(enterpriseUrl) {
+  const host = normalizeCopilotEnterpriseDomain(enterpriseUrl) ?? "github.com";
+  return {
+    deviceEndpoint: `https://${host}/login/device/code`,
+    tokenEndpoint: `https://${host}/login/oauth/access_token`
+  };
+}
+var COPILOT_POLL_INITIAL_MULTIPLIER = 1.2;
+var COPILOT_POLL_SLOW_DOWN_MULTIPLIER = 1.4;
+var COPILOT_CLI_VERSION = "1.0.82";
+var COPILOT_CLI_USER_AGENT = `copilot/${COPILOT_CLI_VERSION}`;
+var OAUTH_HEADERS = {
+  Accept: "application/json",
+  "Content-Type": "application/x-www-form-urlencoded",
+  "User-Agent": "copilot-developer-action/0.0.1"
+};
+var COPILOT_GITHUB_HEADERS = {
+  "User-Agent": COPILOT_CLI_USER_AGENT
+};
+var COPILOT_API_HEADERS = {
+  ...COPILOT_GITHUB_HEADERS,
+  "Editor-Version": COPILOT_CLI_USER_AGENT,
+  "Copilot-Integration-Id": "copilot-developer-cli",
+  "Copilot-Harness-Id": "copilot-sdk",
+  "Openai-Intent": "conversation-agent",
+  "X-GitHub-Api-Version": "2026-08-01",
+  // Agent-initiated CLI traffic — the official CLI's own classification and
+  // the 0-premium-multiplier billing tier GitHub defines for it.
+  "X-Initiator": "agent",
+  "X-Interaction-Type": "conversation-agent"
+};
+var COPILOT_FAR_FUTURE_MS = 10 * 365.25 * 24 * 60 * 60 * 1e3;
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+async function postForm(fetchImpl, url, params, timeoutMs = 3e4) {
+  const response = await fetchImpl(url, {
+    method: "POST",
+    headers: OAUTH_HEADERS,
+    body: params.toString(),
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  const text = await response.text();
+  let body;
+  try {
+    const parsed = JSON.parse(text);
+    body = isRecord(parsed) ? parsed : {};
+  } catch {
+    body = {};
+  }
+  return { status: response.status, body };
+}
+async function requestCopilotDeviceAuthorization(fetchImpl, enterpriseUrl) {
+  const { status, body } = await postForm(fetchImpl, copilotOAuthUrls(enterpriseUrl).deviceEndpoint, new URLSearchParams({
+    client_id: COPILOT_OAUTH_CONFIG.clientId,
+    scope: COPILOT_OAUTH_CONFIG.scope
+  }));
+  const userCode = typeof body["user_code"] === "string" ? body["user_code"] : void 0;
+  const deviceCode = typeof body["device_code"] === "string" ? body["device_code"] : void 0;
+  const verificationUri = typeof body["verification_uri"] === "string" ? body["verification_uri"] : void 0;
+  const interval = typeof body["interval"] === "number" ? body["interval"] : void 0;
+  const expiresIn = typeof body["expires_in"] === "number" ? body["expires_in"] : void 0;
+  if (status >= 400 || !userCode || !deviceCode || !verificationUri || !interval || !expiresIn) {
+    throw new Error(
+      typeof body["error_description"] === "string" && body["error_description"] ? body["error_description"] : `device authorization failed (HTTP ${status})`
+    );
+  }
+  return { userCode, deviceCode, verificationUri, interval, expiresIn };
+}
+async function pollCopilotDeviceToken(deviceCode, fetchImpl, enterpriseUrl) {
+  const { status, body } = await postForm(fetchImpl, copilotOAuthUrls(enterpriseUrl).tokenEndpoint, new URLSearchParams({
+    client_id: COPILOT_OAUTH_CONFIG.clientId,
+    device_code: deviceCode,
+    grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+  }));
+  const accessToken = typeof body["access_token"] === "string" ? body["access_token"] : void 0;
+  if (accessToken) return { state: "done", accessToken };
+  const error = typeof body["error"] === "string" ? body["error"] : void 0;
+  if (error === "authorization_pending") return { state: "pending" };
+  if (error === "slow_down") {
+    const interval = typeof body["interval"] === "number" && body["interval"] > 0 ? body["interval"] : void 0;
+    return { state: "slowDown", ...interval !== void 0 ? { intervalSeconds: interval } : {} };
+  }
+  if (status < 400 && !error) return { state: "pending" };
+  const message = typeof body["error_description"] === "string" && body["error_description"] ? body["error_description"] : error ?? `device token poll failed (HTTP ${status})`;
+  return { state: "failed", message };
+}
+async function awaitCopilotDeviceToken(authorization, fetchImpl, options = {}) {
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const deadline = Date.now() + (options.deadlineMs ?? 15 * 6e4);
+  let intervalMs = Math.max(1e3, authorization.interval * 1e3);
+  let multiplier = COPILOT_POLL_INITIAL_MULTIPLIER;
+  for (; ; ) {
+    const result = await pollCopilotDeviceToken(
+      authorization.deviceCode,
+      fetchImpl,
+      options.enterpriseUrl
+    );
+    if (result.state === "done") return { accessToken: result.accessToken };
+    if (result.state === "failed") throw new Error(result.message);
+    if (result.state === "slowDown") {
+      if (result.intervalSeconds) intervalMs = Math.max(1e3, result.intervalSeconds * 1e3);
+      else intervalMs += 5e3;
+      multiplier = COPILOT_POLL_SLOW_DOWN_MULTIPLIER;
+    }
+    options.onPending?.();
+    const waitMs = Math.ceil(intervalMs * multiplier);
+    if (Date.now() + waitMs > deadline) throw new Error("device authorization timed out");
+    await sleep(waitMs);
+  }
+}
+async function fetchCopilotIdentity(accessToken, fetchImpl, enterpriseUrl) {
+  try {
+    const response = await fetchImpl(`${copilotGitHubApiBase(enterpriseUrl)}/user`, {
+      method: "GET",
+      headers: {
+        Accept: "application/vnd.github+json",
+        Authorization: `Bearer ${accessToken}`,
+        ...COPILOT_GITHUB_HEADERS
+      },
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!response.ok) return {};
+    const payload = await response.json();
+    if (!isRecord(payload)) return {};
+    const accountId = typeof payload["login"] === "string" && payload["login"].trim() ? payload["login"].trim() : void 0;
+    const email = typeof payload["email"] === "string" && payload["email"].trim() ? payload["email"].trim().toLowerCase() : void 0;
+    return { ...accountId ? { accountId } : {}, ...email ? { email } : {} };
+  } catch {
+    return {};
+  }
+}
+async function discoverCopilotApiEndpoint(accessToken, fetchImpl, enterpriseUrl) {
+  try {
+    const response = await fetchImpl(`${copilotGitHubApiBase(enterpriseUrl)}/copilot_internal/user`, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        Authorization: `token ${accessToken}`,
+        ...COPILOT_GITHUB_HEADERS
+      },
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!response.ok) return void 0;
+    const payload = await response.json();
+    if (!isRecord(payload) || !isRecord(payload["endpoints"])) return void 0;
+    const endpoint = payload["endpoints"]["api"];
+    if (typeof endpoint !== "string" || !endpoint.startsWith("https://")) return void 0;
+    return endpoint.replace(/\/+$/, "");
+  } catch {
+    return void 0;
+  }
+}
+async function enableCopilotModel(accessToken, modelId, baseUrl, fetchImpl) {
+  try {
+    const response = await fetchImpl(`${baseUrl}/models/${encodeURIComponent(modelId)}/policy`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${accessToken}`,
+        ...COPILOT_API_HEADERS,
+        "Openai-Intent": "chat-policy",
+        "X-Initiator": "user",
+        "X-Interaction-Type": "chat-policy"
+      },
+      body: JSON.stringify({ state: "enabled" }),
+      signal: AbortSignal.timeout(15e3)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function enableAllCopilotModels(accessToken, config, fetchImpl, onProgress) {
+  const baseUrl = copilotBaseUrl(config);
+  const ids = copilotWireModelIds();
+  const BATCH = 5;
+  for (let i = 0; i < ids.length; i += BATCH) {
+    await Promise.all(
+      ids.slice(i, i + BATCH).map(async (modelId) => {
+        const ok = await enableCopilotModel(accessToken, modelId, baseUrl, fetchImpl);
+        onProgress?.(modelId, ok);
+      })
+    );
+  }
+}
+function refreshCopilotToken(accessToken) {
+  return {
+    accessToken,
+    refreshToken: accessToken,
+    expiresIn: Math.floor(COPILOT_FAR_FUTURE_MS / 1e3)
+  };
+}
+
+// src/oauth/flows/kimi.ts
+var kimi_exports = {};
+__export(kimi_exports, {
+  KIMI_CLI_VERSION: () => KIMI_CLI_VERSION,
+  KIMI_OAUTH_CONFIG: () => KIMI_OAUTH_CONFIG,
+  awaitDeviceToken: () => awaitDeviceToken,
+  generateKimiDeviceId: () => generateKimiDeviceId,
+  kimiAccountIdFromAccessToken: () => kimiAccountIdFromAccessToken,
+  kimiFingerprintHeaders: () => kimiFingerprintHeaders,
+  pollDeviceToken: () => pollDeviceToken,
+  refreshAccessToken: () => refreshAccessToken,
+  requestDeviceAuthorization: () => requestDeviceAuthorization
+});
+import crypto from "crypto";
+import * as os from "os";
+var KIMI_OAUTH_CONFIG = {
+  clientId: "17e5f671-d194-4dfb-9706-5516cb48c098",
+  deviceAuthorizationEndpoint: "https://auth.kimi.com/api/oauth/device_authorization",
+  tokenEndpoint: "https://auth.kimi.com/api/oauth/token"
+};
+var KIMI_CLI_VERSION = process.env["KIMI_CLI_VERSION"] ?? "1.0.0";
+function sanitizeHeaderValue(value, fallback = "") {
+  const sanitized = value.replace(/[^\x20-\x7E]/g, "").trim();
+  return sanitized || fallback;
+}
+function deviceModel() {
+  const platform2 = os.platform();
+  const label = platform2 === "darwin" ? "macOS" : platform2 === "win32" ? "Windows" : platform2 === "linux" ? "Linux" : platform2;
+  return [label, os.release(), os.arch()].filter(Boolean).join(" ").trim();
+}
+function kimiFingerprintHeaders(deviceId) {
+  return {
+    "User-Agent": `KimiCLI/${KIMI_CLI_VERSION}`,
+    "X-Msh-Platform": "kimi_cli",
+    "X-Msh-Version": KIMI_CLI_VERSION,
+    "X-Msh-Device-Name": sanitizeHeaderValue(os.hostname(), "unknown"),
+    "X-Msh-Device-Model": sanitizeHeaderValue(deviceModel(), "unknown"),
+    "X-Msh-Os-Version": sanitizeHeaderValue(os.version(), "unknown"),
+    ...deviceId ? { "X-Msh-Device-Id": sanitizeHeaderValue(deviceId) } : {}
+  };
+}
+function generateKimiDeviceId() {
+  return crypto.randomUUID().replace(/-/g, "");
+}
+async function postFormRaw(fetchImpl, url, params, headers, timeoutMs = 3e4) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetchImpl(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json", ...headers },
+      body: params.toString(),
+      signal: controller.signal
+    });
+  } catch (error) {
+    if (controller.signal.aborted) throw new Error("token endpoint timed out");
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+  const text = await response.text();
+  let body;
+  try {
+    const parsed = JSON.parse(text);
+    body = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    body = {};
+  }
+  return { status: response.status, body };
+}
+async function requestDeviceAuthorization(fetchImpl, fingerprint) {
+  const { status, body } = await postFormRaw(
+    fetchImpl,
+    KIMI_OAUTH_CONFIG.deviceAuthorizationEndpoint,
+    new URLSearchParams({ client_id: KIMI_OAUTH_CONFIG.clientId }),
+    fingerprint ?? {}
+  );
+  const userCode = typeof body["user_code"] === "string" ? body["user_code"] : void 0;
+  const deviceCode = typeof body["device_code"] === "string" ? body["device_code"] : void 0;
+  const verificationUri = typeof body["verification_uri"] === "string" ? body["verification_uri"] : void 0;
+  if (status >= 400 || !userCode || !deviceCode || !verificationUri) {
+    const message = typeof body["error_description"] === "string" ? body["error_description"] : typeof body["msg"] === "string" ? body["msg"] : `device authorization failed (HTTP ${status})`;
+    throw new Error(message);
+  }
+  return {
+    userCode,
+    deviceCode,
+    verificationUri,
+    ...typeof body["verification_uri_complete"] === "string" ? { verificationUriComplete: body["verification_uri_complete"] } : {},
+    ...typeof body["interval"] === "number" ? { interval: body["interval"] } : {},
+    ...typeof body["expires_in"] === "number" ? { expiresIn: body["expires_in"] } : {}
+  };
+}
+async function pollDeviceToken(deviceCode, fetchImpl, fingerprint) {
+  const { status, body } = await postFormRaw(
+    fetchImpl,
+    KIMI_OAUTH_CONFIG.tokenEndpoint,
+    new URLSearchParams({
+      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      client_id: KIMI_OAUTH_CONFIG.clientId,
+      device_code: deviceCode
+    }),
+    fingerprint ?? {}
+  );
+  const accessToken = typeof body["access_token"] === "string" ? body["access_token"] : void 0;
+  const refreshToken = typeof body["refresh_token"] === "string" ? body["refresh_token"] : void 0;
+  if (accessToken && refreshToken) {
+    const expiresIn = typeof body["expires_in"] === "number" && body["expires_in"] > 0 ? body["expires_in"] : 3600;
+    return { state: "done", accessToken, refreshToken, expiresIn };
+  }
+  const error = typeof body["error"] === "string" ? body["error"] : void 0;
+  if (error === "authorization_pending") return { state: "pending" };
+  if (error === "slow_down") return { state: "pending", intervalSeconds: 5 };
+  if (status < 400 && !error) return { state: "pending" };
+  const message = typeof body["error_description"] === "string" && body["error_description"] ? body["error_description"] : error ?? `device token poll failed (HTTP ${status})`;
+  return { state: "failed", message };
+}
+async function awaitDeviceToken(authorization, fetchImpl, options = {}) {
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const deadline = Date.now() + (options.deadlineMs ?? 15 * 6e4);
+  const baseIntervalMs = options.intervalMs ?? (authorization.interval ?? 5) * 1e3;
+  let intervalMs = Math.max(1e3, baseIntervalMs);
+  for (; ; ) {
+    const result = await pollDeviceToken(authorization.deviceCode, fetchImpl, options.fingerprint);
+    if (result.state === "done") return result;
+    if (result.state === "failed") throw new Error(result.message);
+    if (result.state === "pending" && result.intervalSeconds) intervalMs += result.intervalSeconds * 1e3;
+    options.onPending?.();
+    if (Date.now() + intervalMs > deadline) throw new Error("device authorization timed out");
+    await sleep(intervalMs);
+  }
+}
+async function refreshAccessToken(refreshToken, fetchImpl, fingerprint) {
+  const { status, body } = await postFormRaw(
+    fetchImpl,
+    KIMI_OAUTH_CONFIG.tokenEndpoint,
+    new URLSearchParams({
+      grant_type: "refresh_token",
+      client_id: KIMI_OAUTH_CONFIG.clientId,
+      refresh_token: refreshToken
+    }),
+    fingerprint ?? {}
+  );
+  const accessToken = typeof body["access_token"] === "string" ? body["access_token"] : void 0;
+  if (status >= 400 || !accessToken) {
+    const message = typeof body["error_description"] === "string" && body["error_description"] ? body["error_description"] : typeof body["error"] === "string" ? body["error"] : `refresh failed (HTTP ${status})`;
+    throw new Error(message);
+  }
+  return {
+    accessToken,
+    // Kimi rotates the refresh token; keep the old one when the response omits it.
+    refreshToken: typeof body["refresh_token"] === "string" && body["refresh_token"] ? body["refresh_token"] : refreshToken,
+    expiresIn: typeof body["expires_in"] === "number" && body["expires_in"] > 0 ? body["expires_in"] : 3600
+  };
+}
+function kimiAccountIdFromAccessToken(accessToken) {
+  const parts = accessToken.split(".");
+  if (parts.length !== 3) return void 0;
+  try {
+    const json = Buffer.from(parts[1], "base64url").toString("utf8");
+    const claims = JSON.parse(json);
+    if (!claims || typeof claims !== "object" || Array.isArray(claims)) return void 0;
+    const record = claims;
+    for (const key of ["user_id", "sub"]) {
+      const value = record[key];
+      if (typeof value === "string" && value.trim()) return value.trim();
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/oauth/flows/claude.ts
+var claude_exports = {};
+__export(claude_exports, {
+  exchangeCodeForTokens: () => exchangeCodeForTokens,
+  exchangeSetupTokenCode: () => exchangeSetupTokenCode,
+  generateAuthParams: () => generateAuthParams,
+  generateSetupTokenParams: () => generateSetupTokenParams,
+  refreshAccessToken: () => refreshAccessToken2
+});
+import crypto2 from "crypto";
+
+// src/oauth/fetchPort.ts
+function errorMessage(error, errorDescription) {
+  if (errorDescription) return errorDescription;
+  if (typeof error === "string") return error;
+  if (error && typeof error === "object") {
+    const e = error;
+    if (typeof e.message === "string" && e.message) return e.message;
+    if (typeof e.error_description === "string" && e.error_description) {
+      return e.error_description;
+    }
+    return JSON.stringify(error);
+  }
+  return String(error);
+}
+function withStatus(message, response) {
+  return response.ok ? message : `${message} (HTTP ${response.status})`;
+}
+var DEFAULT_TOKEN_TIMEOUT_MS = 3e4;
+async function fetchWithTimeout(fetchImpl, url, init, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetchImpl(url, { ...init, signal: controller.signal });
+  } catch (e) {
+    if (controller.signal.aborted) {
+      throw new Error(`token endpoint timed out after ${Math.round(timeoutMs / 1e3)}s`);
+    }
+    throw e;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function postForm2(fetchImpl, url, params, parseErrorMessage, timeoutMs = DEFAULT_TOKEN_TIMEOUT_MS) {
+  const response = await fetchWithTimeout(
+    fetchImpl,
+    url,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: params.toString()
+    },
+    timeoutMs
+  );
+  const responseData = await response.text();
+  let data;
+  try {
+    data = JSON.parse(responseData);
+  } catch {
+    throw new Error(withStatus(parseErrorMessage, response));
+  }
+  if (data.error) {
+    throw new Error(withStatus(errorMessage(data.error, data.error_description), response));
+  }
+  return data;
+}
+async function postJson(fetchImpl, url, body, parseErrorMessage, extraHeaders = {}, timeoutMs = DEFAULT_TOKEN_TIMEOUT_MS) {
+  const response = await fetchWithTimeout(
+    fetchImpl,
+    url,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...extraHeaders },
+      body: JSON.stringify(body)
+    },
+    timeoutMs
+  );
+  const responseData = await response.text();
+  let data;
+  try {
+    data = JSON.parse(responseData);
+  } catch {
+    throw new Error(withStatus(parseErrorMessage, response));
+  }
+  if (data.error) {
+    throw new Error(withStatus(errorMessage(data.error, data.error_description), response));
+  }
+  if (!response.ok) {
+    throw new Error(withStatus("token endpoint rejected the request", response));
+  }
+  return data;
+}
+
+// src/oauth/flows/claude.ts
+var CLAUDE_TOKEN_HEADERS = {
+  "User-Agent": "claude-cli/1.0.56 (external, cli)",
+  Accept: "application/json, text/plain, */*",
+  "Accept-Language": "en-US,en;q=0.9",
+  Referer: "https://claude.ai/",
+  Origin: "https://claude.ai"
+};
+var CLAUDE_OAUTH_CONFIG = {
+  clientId: "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
+  authorizationEndpoint: "https://claude.ai/oauth/authorize",
+  // The token endpoint moved to platform.claude.com alongside the OAuth
+  // callback (the old console.anthropic.com/v1/oauth/token now returns
+  // Anthropic's standard 404 `{"error":{"type":"not_found_error","message":
+  // "Not found"}}` — observed 2026-06). The redirect_uri MUST match what the
+  // client is registered for AND match between authorize + token exchange.
+  // Scopes mirror the live Claude Code authorize URL.
+  tokenEndpoint: "https://platform.claude.com/v1/oauth/token",
+  redirectUri: "https://platform.claude.com/oauth/code/callback",
+  scopes: [
+    "org:create_api_key",
+    "user:profile",
+    "user:inference",
+    "user:sessions:claude_code",
+    "user:mcp_servers",
+    "user:file_upload"
+  ]
+};
+var SETUP_TOKEN_CONFIG = {
+  scopes: ["user:inference"]
+  // Only inference permission, no API key creation
+};
+function generatePkce() {
+  const codeVerifier = crypto2.randomBytes(32).toString("base64url");
+  const codeChallenge = crypto2.createHash("sha256").update(codeVerifier).digest("base64url");
+  const state = crypto2.randomBytes(16).toString("hex");
+  return { codeVerifier, codeChallenge, state };
+}
+function generateAuthParams() {
+  const { codeVerifier, codeChallenge, state } = generatePkce();
+  const params = new URLSearchParams({
+    code: "true",
+    client_id: CLAUDE_OAUTH_CONFIG.clientId,
+    response_type: "code",
+    redirect_uri: CLAUDE_OAUTH_CONFIG.redirectUri,
+    scope: CLAUDE_OAUTH_CONFIG.scopes.join(" "),
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256",
+    state
+  });
+  const authUrl = `${CLAUDE_OAUTH_CONFIG.authorizationEndpoint}?${params.toString()}`;
+  return { authUrl, codeVerifier, state };
+}
+function generateSetupTokenParams() {
+  const { codeVerifier, codeChallenge, state } = generatePkce();
+  const params = new URLSearchParams({
+    code: "true",
+    client_id: CLAUDE_OAUTH_CONFIG.clientId,
+    response_type: "code",
+    redirect_uri: CLAUDE_OAUTH_CONFIG.redirectUri,
+    scope: SETUP_TOKEN_CONFIG.scopes.join(" "),
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256",
+    state
+  });
+  const authUrl = `${CLAUDE_OAUTH_CONFIG.authorizationEndpoint}?${params.toString()}`;
+  return { authUrl, codeVerifier, state };
+}
+async function exchangeCodeForTokens(request, fetchImpl) {
+  const { authorizationCode, codeVerifier, state } = request;
+  const code = authorizationCode.split("#")[0]?.split("&")[0] ?? authorizationCode;
+  const data = await postJson(
+    fetchImpl,
+    CLAUDE_OAUTH_CONFIG.tokenEndpoint,
+    {
+      grant_type: "authorization_code",
+      client_id: CLAUDE_OAUTH_CONFIG.clientId,
+      code,
+      code_verifier: codeVerifier,
+      redirect_uri: CLAUDE_OAUTH_CONFIG.redirectUri,
+      state
+    },
+    "Failed to parse token response",
+    CLAUDE_TOKEN_HEADERS
+  );
+  return {
+    accessToken: data.access_token,
+    // The authorization_code grant always returns a refresh_token; the original
+    // helper read it from an untyped `data` and declared the field `string`.
+    refreshToken: data.refresh_token,
+    expiresIn: data.expires_in,
+    scopes: data.scope?.split(" ") || CLAUDE_OAUTH_CONFIG.scopes
+  };
+}
+async function exchangeSetupTokenCode(request, fetchImpl) {
+  const { authorizationCode, codeVerifier, state } = request;
+  const code = authorizationCode.split("#")[0]?.split("&")[0] ?? authorizationCode;
+  const data = await postJson(
+    fetchImpl,
+    CLAUDE_OAUTH_CONFIG.tokenEndpoint,
+    {
+      grant_type: "authorization_code",
+      client_id: CLAUDE_OAUTH_CONFIG.clientId,
+      code,
+      code_verifier: codeVerifier,
+      redirect_uri: CLAUDE_OAUTH_CONFIG.redirectUri,
+      state
+    },
+    "Failed to parse setup token response",
+    CLAUDE_TOKEN_HEADERS
+  );
+  return {
+    accessToken: data.access_token,
+    expiresIn: data.expires_in,
+    scopes: data.scope?.split(" ") || SETUP_TOKEN_CONFIG.scopes
+  };
+}
+async function refreshAccessToken2(refreshToken, fetchImpl) {
+  const data = await postJson(
+    fetchImpl,
+    CLAUDE_OAUTH_CONFIG.tokenEndpoint,
+    {
+      grant_type: "refresh_token",
+      client_id: CLAUDE_OAUTH_CONFIG.clientId,
+      refresh_token: refreshToken
+    },
+    "Failed to parse refresh response",
+    CLAUDE_TOKEN_HEADERS
+  );
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token || refreshToken,
+    expiresIn: data.expires_in
+  };
+}
+
+// src/oauth/flows/codex.ts
+var codex_exports = {};
+__export(codex_exports, {
+  exchangeCodeForTokens: () => exchangeCodeForTokens2,
+  generateAuthParams: () => generateAuthParams2,
+  refreshAccessToken: () => refreshAccessToken3
+});
+import crypto3 from "crypto";
+var CODEX_OAUTH_CONFIG = {
+  clientId: "app_EMoamEEZ73f0CkXaXp7hrann",
+  authorizationEndpoint: "https://auth.openai.com/oauth/authorize",
+  tokenEndpoint: "https://auth.openai.com/oauth/token",
+  redirectUri: "http://localhost:1455/auth/callback",
+  scopes: ["openid", "profile", "email", "offline_access"]
+};
+function generateAuthParams2() {
+  const codeVerifier = crypto3.randomBytes(64).toString("hex");
+  const codeChallenge = crypto3.createHash("sha256").update(codeVerifier).digest("base64url");
+  const state = crypto3.randomBytes(16).toString("hex");
+  const params = new URLSearchParams({
+    response_type: "code",
+    client_id: CODEX_OAUTH_CONFIG.clientId,
+    redirect_uri: CODEX_OAUTH_CONFIG.redirectUri,
+    scope: CODEX_OAUTH_CONFIG.scopes.join(" "),
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256",
+    state
+  });
+  const authUrl = `${CODEX_OAUTH_CONFIG.authorizationEndpoint}?${params.toString()}`;
+  return { authUrl, codeVerifier, state };
+}
+async function exchangeCodeForTokens2(request, fetchImpl) {
+  const { authorizationCode, codeVerifier } = request;
+  const params = new URLSearchParams({
+    grant_type: "authorization_code",
+    client_id: CODEX_OAUTH_CONFIG.clientId,
+    code: authorizationCode,
+    code_verifier: codeVerifier,
+    redirect_uri: CODEX_OAUTH_CONFIG.redirectUri
+  });
+  const data = await postForm2(
+    fetchImpl,
+    CODEX_OAUTH_CONFIG.tokenEndpoint,
+    params,
+    "Failed to parse token response"
+  );
+  return {
+    accessToken: data.access_token,
+    // authorization_code grant returns both; the original helper read them from
+    // an untyped `data` and declared the fields `string`.
+    refreshToken: data.refresh_token,
+    idToken: data.id_token,
+    expiresIn: data.expires_in
+  };
+}
+async function refreshAccessToken3(refreshToken, fetchImpl) {
+  const params = new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: CODEX_OAUTH_CONFIG.clientId,
+    refresh_token: refreshToken,
+    scope: "openid profile email"
+  });
+  const data = await postForm2(
+    fetchImpl,
+    CODEX_OAUTH_CONFIG.tokenEndpoint,
+    params,
+    "Failed to parse refresh response"
+  );
+  return {
+    accessToken: data.access_token,
+    idToken: data.id_token,
+    refreshToken: data.refresh_token || refreshToken,
+    expiresIn: data.expires_in || 3600
+  };
+}
+
+// src/oauth/flows/gemini.ts
+var gemini_exports = {};
+__export(gemini_exports, {
+  exchangeCodeForTokens: () => exchangeCodeForTokens3,
+  generateAuthParams: () => generateAuthParams3,
+  refreshAccessToken: () => refreshAccessToken4
+});
+import crypto4 from "crypto";
+var GEMINI_OAUTH_CONFIG = {
+  clientId: "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com",
+  // The Gemini CLI's *public* installed-app OAuth client secret (mirrors the
+  // upstream CLI). Per Google's OAuth docs, native-app client secrets are not
+  // treated as confidential — not a leaked key.
+  clientSecret: "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",
+  // allowlist-secret
+  authorizationEndpoint: "https://accounts.google.com/o/oauth2/v2/auth",
+  tokenEndpoint: "https://oauth2.googleapis.com/token",
+  redirectUri: "urn:ietf:wg:oauth:2.0:oob",
+  scopes: ["https://www.googleapis.com/auth/cloud-platform"]
+};
+function generateAuthParams3() {
+  const codeVerifier = crypto4.randomBytes(32).toString("base64url");
+  const codeChallenge = crypto4.createHash("sha256").update(codeVerifier).digest("base64url");
+  const state = crypto4.randomBytes(16).toString("hex");
+  const params = new URLSearchParams({
+    client_id: GEMINI_OAUTH_CONFIG.clientId,
+    redirect_uri: GEMINI_OAUTH_CONFIG.redirectUri,
+    scope: GEMINI_OAUTH_CONFIG.scopes.join(" "),
+    response_type: "code",
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256",
+    state,
+    access_type: "offline",
+    prompt: "consent"
+  });
+  const authUrl = `${GEMINI_OAUTH_CONFIG.authorizationEndpoint}?${params.toString()}`;
+  return { authUrl, codeVerifier, state };
+}
+async function exchangeCodeForTokens3(authorizationCode, codeVerifier, fetchImpl) {
+  const params = new URLSearchParams({
+    grant_type: "authorization_code",
+    client_id: GEMINI_OAUTH_CONFIG.clientId,
+    client_secret: GEMINI_OAUTH_CONFIG.clientSecret,
+    code: authorizationCode,
+    code_verifier: codeVerifier,
+    redirect_uri: GEMINI_OAUTH_CONFIG.redirectUri
+  });
+  const data = await postForm2(
+    fetchImpl,
+    GEMINI_OAUTH_CONFIG.tokenEndpoint,
+    params,
+    "Failed to parse token response"
+  );
+  return {
+    accessToken: data.access_token,
+    // authorization_code grant returns a refresh_token; the original helper read
+    // it from an untyped `data` and declared the field `string`.
+    refreshToken: data.refresh_token,
+    expiresIn: data.expires_in
+  };
+}
+async function refreshAccessToken4(refreshToken, fetchImpl) {
+  const params = new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: GEMINI_OAUTH_CONFIG.clientId,
+    client_secret: GEMINI_OAUTH_CONFIG.clientSecret,
+    refresh_token: refreshToken
+  });
+  const data = await postForm2(
+    fetchImpl,
+    GEMINI_OAUTH_CONFIG.tokenEndpoint,
+    params,
+    "Failed to parse refresh response"
+  );
+  return {
+    accessToken: data.access_token,
+    expiresIn: data.expires_in
+  };
+}
+
+// src/oauth/flows/grok.ts
+var grok_exports = {};
+__export(grok_exports, {
+  GROK_OAUTH_CONFIG: () => GROK_OAUTH_CONFIG,
+  awaitGrokDeviceToken: () => awaitGrokDeviceToken,
+  grokAccountIdFromAccessToken: () => grokAccountIdFromAccessToken,
+  isGrokAuthHostname: () => isGrokAuthHostname,
+  pollGrokDeviceToken: () => pollGrokDeviceToken,
+  refreshGrokAccessToken: () => refreshGrokAccessToken,
+  requestGrokDeviceAuthorization: () => requestGrokDeviceAuthorization,
+  resetGrokDiscoveryCache: () => resetGrokDiscoveryCache,
+  resolveGrokTokenEndpoint: () => resolveGrokTokenEndpoint,
+  validateGrokAuthEndpoint: () => validateGrokAuthEndpoint
+});
+var GROK_OAUTH_CONFIG = {
+  clientId: "b1a00492-073a-47ea-816f-4c329264a828",
+  deviceAuthorizationEndpoint: process.env["GROK_OAUTH_DEVICE_ENDPOINT"] ?? "https://auth.x.ai/oauth2/device/code",
+  discoveryUrl: process.env["GROK_OAUTH_DISCOVERY_URL"] ?? "https://auth.x.ai/.well-known/openid-configuration",
+  /** The CLI's full scope set — the token must carry `grok-cli:access` for inference. */
+  scopes: ["openid", "profile", "email", "offline_access", "grok-cli:access", "api:access"]
+};
+var DISCOVERY_CACHE_MS = 60 * 60 * 1e3;
+function isRecord2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isGrokAuthHostname(host) {
+  return host === "x.ai" || host.endsWith(".x.ai");
+}
+function validateGrokAuthEndpoint(url, field) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`Invalid Grok ${field}: ${url}`);
+  }
+  if (parsed.protocol !== "https:" || !isGrokAuthHostname(parsed.hostname.toLowerCase())) {
+    throw new Error(`Invalid Grok ${field}: ${url}`);
+  }
+  return url;
+}
+var cachedDiscovery;
+function resetGrokDiscoveryCache() {
+  cachedDiscovery = void 0;
+}
+async function resolveGrokTokenEndpoint(fetchImpl, timeoutMs = 15e3) {
+  if (cachedDiscovery && Date.now() - cachedDiscovery.resolvedAt < DISCOVERY_CACHE_MS) {
+    return cachedDiscovery.tokenEndpoint;
+  }
+  let response;
+  try {
+    response = await fetchImpl(GROK_OAUTH_CONFIG.discoveryUrl, {
+      method: "GET",
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (error) {
+    throw new Error(
+      `Grok OIDC discovery failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!response.ok) throw new Error(`Grok OIDC discovery returned HTTP ${response.status}`);
+  let payload;
+  try {
+    payload = await response.json();
+  } catch {
+    throw new Error("Grok OIDC discovery returned invalid JSON");
+  }
+  const tokenEndpoint = isRecord2(payload) && typeof payload["token_endpoint"] === "string" ? payload["token_endpoint"].trim() : "";
+  if (!tokenEndpoint) throw new Error("Grok OIDC discovery response missing token_endpoint");
+  validateGrokAuthEndpoint(tokenEndpoint, "token_endpoint");
+  cachedDiscovery = { tokenEndpoint, resolvedAt: Date.now() };
+  return tokenEndpoint;
+}
+async function postFormRaw2(fetchImpl, url, params, timeoutMs = 3e4) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetchImpl(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json"
+      },
+      body: params.toString(),
+      signal: controller.signal
+    });
+  } catch (error) {
+    if (controller.signal.aborted) throw new Error("token endpoint timed out");
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+  const text = await response.text();
+  let body;
+  try {
+    const parsed = JSON.parse(text);
+    body = isRecord2(parsed) ? parsed : {};
+  } catch {
+    body = {};
+  }
+  return { status: response.status, body };
+}
+async function requestGrokDeviceAuthorization(fetchImpl) {
+  const { status, body } = await postFormRaw2(
+    fetchImpl,
+    GROK_OAUTH_CONFIG.deviceAuthorizationEndpoint,
+    new URLSearchParams({
+      client_id: GROK_OAUTH_CONFIG.clientId,
+      scope: GROK_OAUTH_CONFIG.scopes.join(" ")
+    })
+  );
+  const userCode = typeof body["user_code"] === "string" ? body["user_code"] : void 0;
+  const deviceCode = typeof body["device_code"] === "string" ? body["device_code"] : void 0;
+  const verificationUri = typeof body["verification_uri"] === "string" ? body["verification_uri"] : void 0;
+  if (status >= 400 || !userCode || !deviceCode || !verificationUri) {
+    const message = typeof body["error_description"] === "string" && body["error_description"] ? body["error_description"] : typeof body["error"] === "string" ? body["error"] : `device authorization failed (HTTP ${status})`;
+    throw new Error(message);
+  }
+  return {
+    userCode,
+    deviceCode,
+    verificationUri,
+    ...typeof body["verification_uri_complete"] === "string" ? { verificationUriComplete: body["verification_uri_complete"] } : {},
+    ...typeof body["interval"] === "number" ? { interval: body["interval"] } : {},
+    ...typeof body["expires_in"] === "number" ? { expiresIn: body["expires_in"] } : {}
+  };
+}
+async function pollGrokDeviceToken(deviceCode, tokenEndpoint, fetchImpl) {
+  const { status, body } = await postFormRaw2(fetchImpl, tokenEndpoint, new URLSearchParams({
+    grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+    client_id: GROK_OAUTH_CONFIG.clientId,
+    device_code: deviceCode
+  }));
+  const accessToken = typeof body["access_token"] === "string" ? body["access_token"] : void 0;
+  const refreshToken = typeof body["refresh_token"] === "string" ? body["refresh_token"] : void 0;
+  if (accessToken && refreshToken) {
+    const expiresIn = typeof body["expires_in"] === "number" && body["expires_in"] > 0 ? body["expires_in"] : 3600;
+    return { state: "done", accessToken, refreshToken, expiresIn };
+  }
+  const error = typeof body["error"] === "string" ? body["error"] : void 0;
+  if (error === "authorization_pending") return { state: "pending" };
+  if (error === "slow_down") return { state: "pending", intervalSeconds: 5 };
+  if (status < 400 && !error) return { state: "pending" };
+  const message = typeof body["error_description"] === "string" && body["error_description"] ? body["error_description"] : error ?? `device token poll failed (HTTP ${status})`;
+  return { state: "failed", message };
+}
+async function awaitGrokDeviceToken(authorization, tokenEndpoint, fetchImpl, options = {}) {
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const deadline = Date.now() + (options.deadlineMs ?? 15 * 6e4);
+  const baseIntervalMs = options.intervalMs ?? (authorization.interval ?? 5) * 1e3;
+  let intervalMs = Math.max(1e3, baseIntervalMs);
+  for (; ; ) {
+    const result = await pollGrokDeviceToken(authorization.deviceCode, tokenEndpoint, fetchImpl);
+    if (result.state === "done") return result;
+    if (result.state === "failed") throw new Error(result.message);
+    if (result.state === "pending" && result.intervalSeconds) {
+      intervalMs += result.intervalSeconds * 1e3;
+    }
+    options.onPending?.();
+    if (Date.now() + intervalMs > deadline) throw new Error("device authorization timed out");
+    await sleep(intervalMs);
+  }
+}
+async function refreshGrokAccessToken(refreshToken, tokenEndpoint, fetchImpl) {
+  const { status, body } = await postFormRaw2(fetchImpl, tokenEndpoint, new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: GROK_OAUTH_CONFIG.clientId,
+    refresh_token: refreshToken
+  }));
+  const accessToken = typeof body["access_token"] === "string" ? body["access_token"] : void 0;
+  if (status >= 400 || !accessToken) {
+    const message = typeof body["error_description"] === "string" && body["error_description"] ? body["error_description"] : typeof body["error"] === "string" ? body["error"] : `refresh failed (HTTP ${status})`;
+    throw new Error(message);
+  }
+  return {
+    accessToken,
+    // Keep the old refresh token when the response omits one (no proven rotation).
+    refreshToken: typeof body["refresh_token"] === "string" && body["refresh_token"] ? body["refresh_token"] : refreshToken,
+    expiresIn: typeof body["expires_in"] === "number" && body["expires_in"] > 0 ? body["expires_in"] : 3600
+  };
+}
+function grokAccountIdFromAccessToken(accessToken) {
+  const parts = accessToken.split(".");
+  if (parts.length !== 3) return void 0;
+  try {
+    const json = Buffer.from(parts[1], "base64url").toString("utf8");
+    const claims = JSON.parse(json);
+    if (!isRecord2(claims)) return void 0;
+    const sub = claims["sub"];
+    return typeof sub === "string" && sub.trim() ? sub.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  copilotWireFor,
+  copilotPathFor,
+  copilotTransformerNamesForWire,
+  copilotBaseUrl,
+  copilotGitHubApiBase,
+  COPILOT_GITHUB_HEADERS,
+  COPILOT_API_HEADERS,
+  copilot_exports,
+  kimiFingerprintHeaders,
+  kimi_exports,
+  claude_exports,
+  codex_exports,
+  gemini_exports,
+  grok_exports
+};