@nyte-ai/ai 0.0.0-stage → 0.0.18

package/dist/chunks/account-limits-cache-xz65wyd1.js

@@ -0,0 +1,428 @@
+import {
+  getProviderEnvValue2
+} from "./account-limits-cache-b23sbrke.js";
+import {
+  OAuthTokenResponseSchema2
+} from "./account-limits-cache-b0x2sfya.js";
+import {
+  parseAuthorizationInput2
+} from "./account-limits-cache-d1ypzqzp.js";
+import {
+  pollOAuthDeviceCodeFlow2
+} from "./account-limits-cache-4hptgd2h.js";
+import {
+  oauthSuccessHtml2,
+  oauthErrorHtml2
+} from "./account-limits-cache-8vzx8k6r.js";
+import {
+  registerOAuthFlow2
+} from "./account-limits-cache-v4n30az2.js";
+import {
+  generatePKCE2
+} from "./account-limits-cache-tc38g0ca.js";
+
+// src/auth/oauth/openai-codex.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+var AUTH_BASE_URL = "https://auth.openai.com";
+var AUTHORIZE_URL = `${AUTH_BASE_URL}/oauth/authorize`;
+var TOKEN_URL = `${AUTH_BASE_URL}/oauth/token`;
+var REDIRECT_URI = "http://localhost:1455/auth/callback";
+var DEVICE_USER_CODE_URL = `${AUTH_BASE_URL}/api/accounts/deviceauth/usercode`;
+var DEVICE_TOKEN_URL = `${AUTH_BASE_URL}/api/accounts/deviceauth/token`;
+var DEVICE_VERIFICATION_URI = `${AUTH_BASE_URL}/codex/device`;
+var DEVICE_REDIRECT_URI = `${AUTH_BASE_URL}/deviceauth/callback`;
+var DEVICE_CODE_TIMEOUT_SECONDS = 15 * 60;
+var OPENAI_CODEX_BROWSER_LOGIN_METHOD = "browser";
+var OPENAI_CODEX_DEVICE_CODE_LOGIN_METHOD = "device_code";
+var SCOPE = "openid profile email offline_access";
+var JWT_CLAIM_PATH = "https://api.openai.com/auth";
+var ORIGINATOR2 = "nyte";
+function getCallbackHost() {
+  return getProviderEnvValue2("NYTE_OAUTH_CALLBACK_HOST") || "127.0.0.1";
+}
+var DeviceCodeResponse = Type.Object({
+  device_auth_id: Type.String({ minLength: 1 }),
+  user_code: Type.String({ minLength: 1 }),
+  interval: Type.Union([Type.Number(), Type.String()])
+});
+var DeviceTokenResponse = Type.Object({
+  authorization_code: Type.String({ minLength: 1 }),
+  code_verifier: Type.String({ minLength: 1 })
+});
+var DeviceErrorCode = Type.Object({ error: Type.String() });
+var NestedDeviceErrorCode = Type.Object({ error: Type.Object({ code: Type.String() }) });
+var JwtClaims = Type.Object({
+  [JWT_CLAIM_PATH]: Type.Optional(Type.Object({ chatgpt_account_id: Type.Optional(Type.String()) }))
+});
+function assertNodeRuntime() {
+  if (typeof process === "undefined" || !(process.versions?.node || process.versions?.bun)) {
+    throw new Error("OpenAI Codex OAuth is only available in Node.js environments");
+  }
+}
+function createState() {
+  assertNodeRuntime();
+  return process.getBuiltinModule("node:crypto").randomBytes(16).toString("hex");
+}
+function decodeJwt(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3)
+      return null;
+    const payload = parts[1] ?? "";
+    const claims = JSON.parse(atob(payload));
+    return Value.Check(JwtClaims, claims) ? claims : null;
+  } catch {
+    return null;
+  }
+}
+async function fetchWithLoginCancellation(input, init) {
+  try {
+    return await fetch(input, init);
+  } catch (error) {
+    if (init.signal?.aborted) {
+      throw new Error("Login cancelled");
+    }
+    throw error;
+  }
+}
+async function readTokenResponse(response, operation) {
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`OpenAI Codex token ${operation} failed (${response.status}): ${text || response.statusText}`);
+  }
+  const json = await response.json();
+  if (!Value.Check(OAuthTokenResponseSchema2, json)) {
+    throw new Error(`OpenAI Codex token ${operation} response missing fields: ${JSON.stringify(json)}`);
+  }
+  return {
+    access: json.access_token,
+    refresh: json.refresh_token,
+    expires: Date.now() + json.expires_in * 1000
+  };
+}
+async function exchangeAuthorizationCode(code, verifier, redirectUri, signal) {
+  const response = await fetchWithLoginCancellation(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: CLIENT_ID,
+      code,
+      code_verifier: verifier,
+      redirect_uri: redirectUri
+    }),
+    signal
+  });
+  return readTokenResponse(response, "exchange");
+}
+async function refreshAccessToken(refreshToken, signal) {
+  let response;
+  try {
+    response = await fetch(TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: refreshToken,
+        client_id: CLIENT_ID
+      }),
+      signal
+    });
+  } catch (error) {
+    throw new Error(`OpenAI Codex token refresh error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return readTokenResponse(response, "refresh");
+}
+async function startOpenAICodexDeviceAuth(signal) {
+  const response = await fetchWithLoginCancellation(DEVICE_USER_CODE_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ client_id: CLIENT_ID }),
+    signal
+  });
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new Error("OpenAI Codex device code login is not enabled for this server. Use browser login or verify the server URL.");
+    }
+    const responseBody = await response.text().catch(() => "");
+    throw new Error(`OpenAI Codex device code request failed with status ${response.status}${responseBody ? `: ${responseBody}` : ""}`);
+  }
+  const json = await response.json();
+  const invalid = new Error(`Invalid OpenAI Codex device code response: ${JSON.stringify(json)}`);
+  if (!Value.Check(DeviceCodeResponse, json))
+    throw invalid;
+  const intervalSeconds = Number(json.interval);
+  if (!Number.isFinite(intervalSeconds) || intervalSeconds < 0)
+    throw invalid;
+  return {
+    deviceAuthId: json.device_auth_id,
+    userCode: json.user_code,
+    intervalSeconds
+  };
+}
+async function pollOpenAICodexDeviceAuth(device, signal) {
+  return pollOAuthDeviceCodeFlow2({
+    intervalSeconds: device.intervalSeconds,
+    expiresInSeconds: DEVICE_CODE_TIMEOUT_SECONDS,
+    signal,
+    poll: async () => {
+      const response = await fetchWithLoginCancellation(DEVICE_TOKEN_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          device_auth_id: device.deviceAuthId,
+          user_code: device.userCode
+        }),
+        signal
+      });
+      if (response.ok) {
+        const json = await response.json();
+        if (!Value.Check(DeviceTokenResponse, json)) {
+          return {
+            status: "failed",
+            message: `Invalid OpenAI Codex device auth token response: ${JSON.stringify(json)}`
+          };
+        }
+        return {
+          status: "complete",
+          value: { authorizationCode: json.authorization_code, codeVerifier: json.code_verifier }
+        };
+      }
+      if (response.status === 403 || response.status === 404) {
+        return { status: "pending" };
+      }
+      const responseBody = await response.text().catch(() => "");
+      let errorCode;
+      try {
+        const json = JSON.parse(responseBody);
+        if (Value.Check(DeviceErrorCode, json))
+          errorCode = json.error;
+        else if (Value.Check(NestedDeviceErrorCode, json))
+          errorCode = json.error.code;
+      } catch {}
+      if (errorCode === "deviceauth_authorization_pending") {
+        return { status: "pending" };
+      }
+      if (errorCode === "slow_down") {
+        return { status: "slow_down" };
+      }
+      return {
+        status: "failed",
+        message: `OpenAI Codex device auth failed with status ${response.status}${responseBody ? `: ${responseBody}` : ""}`
+      };
+    }
+  });
+}
+async function createAuthorizationFlow(originator = ORIGINATOR2) {
+  const { verifier, challenge } = await generatePKCE2();
+  const state = createState();
+  const url = new URL(AUTHORIZE_URL);
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("client_id", CLIENT_ID);
+  url.searchParams.set("redirect_uri", REDIRECT_URI);
+  url.searchParams.set("scope", SCOPE);
+  url.searchParams.set("code_challenge", challenge);
+  url.searchParams.set("code_challenge_method", "S256");
+  url.searchParams.set("state", state);
+  url.searchParams.set("id_token_add_organizations", "true");
+  url.searchParams.set("codex_cli_simplified_flow", "true");
+  url.searchParams.set("originator", originator);
+  return { verifier, state, url: url.toString() };
+}
+function startLocalOAuthServer(state) {
+  assertNodeRuntime();
+  let settleWait;
+  const waitForCodePromise = new Promise((resolve) => {
+    let settled = false;
+    settleWait = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      resolve(value);
+    };
+  });
+  const server = process.getBuiltinModule("node:http").createServer((req, res) => {
+    try {
+      const url = new URL(req.url || "", "http://localhost");
+      if (url.pathname !== "/auth/callback") {
+        res.statusCode = 404;
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        res.end(oauthErrorHtml2("Nyte is not listening on this path. Run the login command again to retry."));
+        return;
+      }
+      if (url.searchParams.get("state") !== state) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        res.end(oauthErrorHtml2("The callback's state did not match this login attempt, so Nyte ignored it."));
+        return;
+      }
+      const code = url.searchParams.get("code");
+      if (!code) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        res.end(oauthErrorHtml2("The callback arrived without an authorization code, so Nyte could not finish sign-in."));
+        return;
+      }
+      res.statusCode = 200;
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      res.end(oauthSuccessHtml2({ provider: "OpenAI" }));
+      settleWait?.({ code });
+    } catch {
+      res.statusCode = 500;
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      res.end(oauthErrorHtml2("Nyte hit an internal error while handling the callback. Run the login command again to retry."));
+    }
+  });
+  return new Promise((resolve) => {
+    server.listen(1455, getCallbackHost(), () => {
+      resolve({
+        close: () => server.close(),
+        cancelWait: () => {
+          settleWait?.(null);
+        },
+        waitForCode: () => waitForCodePromise
+      });
+    }).on("error", (_err) => {
+      settleWait?.(null);
+      resolve({
+        close: () => {
+          try {
+            server.close();
+          } catch {}
+        },
+        cancelWait: () => {},
+        waitForCode: async () => null
+      });
+    });
+  });
+}
+function getAccountId2(accessToken) {
+  return decodeJwt(accessToken)?.[JWT_CLAIM_PATH]?.chatgpt_account_id || null;
+}
+function credentialsFromToken(token) {
+  const accountId = getAccountId2(token.access);
+  if (!accountId) {
+    throw new Error("Failed to extract accountId from token");
+  }
+  return {
+    type: "oauth",
+    access: token.access,
+    refresh: token.refresh,
+    expires: token.expires,
+    accountId
+  };
+}
+async function exchangeAuthorizationCodeForCredentials(code, verifier, redirectUri, signal) {
+  return credentialsFromToken(await exchangeAuthorizationCode(code, verifier, redirectUri, signal));
+}
+async function loginOpenAICodexDeviceCode(interaction) {
+  const device = await startOpenAICodexDeviceAuth(interaction.signal);
+  interaction.notify({
+    type: "device_code",
+    userCode: device.userCode,
+    verificationUri: DEVICE_VERIFICATION_URI,
+    intervalSeconds: device.intervalSeconds,
+    expiresInSeconds: DEVICE_CODE_TIMEOUT_SECONDS
+  });
+  const code = await pollOpenAICodexDeviceAuth(device, interaction.signal);
+  return exchangeAuthorizationCodeForCredentials(code.authorizationCode, code.codeVerifier, DEVICE_REDIRECT_URI, interaction.signal);
+}
+async function loginOpenAICodex(interaction) {
+  const { verifier, state, url } = await createAuthorizationFlow();
+  const server = await startLocalOAuthServer(state);
+  const manualAbort = new AbortController;
+  const onAbort = () => server.cancelWait();
+  interaction.signal.addEventListener("abort", onAbort, { once: true });
+  if (interaction.signal.aborted)
+    onAbort();
+  let code;
+  let manualCode;
+  let manualError;
+  interaction.notify({
+    type: "auth_url",
+    url,
+    instructions: "A browser window should open. Complete login to finish."
+  });
+  try {
+    const manualPromise = interaction.prompt({
+      type: "manual_code",
+      message: "Complete login in your browser, or paste the authorization code / redirect URL here:",
+      placeholder: REDIRECT_URI,
+      signal: manualAbort.signal
+    }).then((input) => {
+      manualCode = input;
+      server.cancelWait();
+    }).catch((error) => {
+      manualError = error instanceof Error ? error : new Error(String(error));
+      server.cancelWait();
+    });
+    const result = await server.waitForCode();
+    if (manualError)
+      throw manualError;
+    if (result?.code) {
+      code = result.code;
+    } else if (manualCode) {
+      const parsed = parseAuthorizationInput2(manualCode);
+      if (parsed.state && parsed.state !== state)
+        throw new Error("State mismatch");
+      code = parsed.code;
+    }
+    if (!code) {
+      await manualPromise;
+      if (manualError)
+        throw manualError;
+      if (manualCode) {
+        const parsed = parseAuthorizationInput2(manualCode);
+        if (parsed.state && parsed.state !== state)
+          throw new Error("State mismatch");
+        code = parsed.code;
+      }
+    }
+    if (!code)
+      throw new Error("Missing authorization code");
+    return exchangeAuthorizationCodeForCredentials(code, verifier, REDIRECT_URI, interaction.signal);
+  } finally {
+    interaction.signal.removeEventListener("abort", onAbort);
+    manualAbort.abort();
+    server.close();
+  }
+}
+async function refreshOpenAICodexToken(refreshToken, signal) {
+  return credentialsFromToken(await refreshAccessToken(refreshToken, signal));
+}
+var openaiCodexOAuth2 = {
+  name: "OpenAI (ChatGPT Plus/Pro)",
+  isSubscription: true,
+  async login(interaction) {
+    const method = interaction.browser === "host" ? OPENAI_CODEX_BROWSER_LOGIN_METHOD : interaction.browser === "elsewhere" ? OPENAI_CODEX_DEVICE_CODE_LOGIN_METHOD : await interaction.prompt({
+      type: "select",
+      message: "Select OpenAI Codex login method:",
+      options: [
+        { id: OPENAI_CODEX_BROWSER_LOGIN_METHOD, label: "Browser login (default)" },
+        {
+          id: OPENAI_CODEX_DEVICE_CODE_LOGIN_METHOD,
+          label: "Device code login (headless)"
+        }
+      ]
+    });
+    if (method === OPENAI_CODEX_DEVICE_CODE_LOGIN_METHOD) {
+      return loginOpenAICodexDeviceCode(interaction);
+    }
+    if (method !== OPENAI_CODEX_BROWSER_LOGIN_METHOD) {
+      throw new Error(`Unknown OpenAI Codex login method: ${method}`);
+    }
+    return loginOpenAICodex(interaction);
+  },
+  refresh: (credential, signal) => refreshOpenAICodexToken(credential.refresh, signal),
+  async toAuth(credential) {
+    const accountId = getAccountId2(credential.access);
+    if (!accountId)
+      throw new Error("OpenAI Codex credential missing account id");
+    return { apiKey: credential.access, headers: { "chatgpt-account-id": accountId } };
+  }
+};
+registerOAuthFlow2("openaiCodex", openaiCodexOAuth2);
+
+export { ORIGINATOR2, getAccountId2, openaiCodexOAuth2 };

package/dist/chunks/account-limits-cache-ydq8p8qp.js

@@ -0,0 +1,39 @@
+import {
+  providerHeadersToRecord2
+} from "./account-limits-cache-ag5b8dja.js";
+
+// src/auth/verify.ts
+async function verifyWithRequest2(input) {
+  const response = await globalThis.fetch(input.url, {
+    headers: providerHeadersToRecord2(input.headers),
+    signal: input.signal,
+    redirect: "error"
+  });
+  if (response.status === 401 || response.status === 403) {
+    await response.body?.cancel();
+    return {
+      ok: false,
+      reason: "rejected",
+      message: `${input.provider} rejected the credential (HTTP ${String(response.status)})`
+    };
+  }
+  if (!response.ok) {
+    await response.body?.cancel();
+    return {
+      ok: false,
+      reason: "unreachable",
+      message: `${input.provider} could not verify the credential (HTTP ${String(response.status)})`
+    };
+  }
+  if (!input.detail) {
+    await response.body?.cancel();
+    return { ok: true };
+  }
+  const body = await response.json().catch(() => {
+    return;
+  });
+  const detail = input.detail(body);
+  return detail === undefined ? { ok: true } : { ok: true, detail };
+}
+
+export { verifyWithRequest2 };

package/dist/chunks/account-limits-cache-ykbqsvv6.js

@@ -0,0 +1,134 @@
+import {
+  lazyStream2
+} from "./account-limits-cache-90c9c2eb.js";
+import {
+  ModelsError2
+} from "./account-limits-cache-7z9s8j16.js";
+
+// src/provider.ts
+import { ModelSchema } from "@nyte-ai/schema/model";
+import { Value } from "typebox/value";
+var CATALOG_FRESHNESS_WINDOW_MS = 4 * 60 * 60 * 1000;
+function createProvider2(input) {
+  let catalogModels = [];
+  const api = input.api;
+  const single = "streamSimple" in api ? api : undefined;
+  const byApi = new Map("streamSimple" in api ? [] : Object.entries(api));
+  const apiFor = (model) => single ?? byApi.get(model.api);
+  const usableModels = (catalog) => catalog.filter((model) => Value.Check(ModelSchema, model) && model.provider === input.id && apiFor(model) !== undefined);
+  const dispatch = (model, run) => {
+    const streams = apiFor(model);
+    if (!streams) {
+      return lazyStream2(model, async () => {
+        throw new ModelsError2("stream", `Provider ${input.id} has no API implementation for "${model.api}"`);
+      });
+    }
+    return run(streams);
+  };
+  const provider = {
+    id: input.id,
+    name: input.name ?? input.id,
+    baseUrl: input.baseUrl,
+    headers: input.headers,
+    promptCache: input.promptCache,
+    auth: input.auth,
+    fetchAccountLimits: input.fetchAccountLimits,
+    getModels: () => catalogModels,
+    refreshModels: async (context) => {
+      if (context.stored) {
+        const restored = usableModels(context.stored.models);
+        if (!await context.publish({
+          update: () => {
+            catalogModels = restored;
+          }
+        })) {
+          return;
+        }
+      }
+      if (!context.allowNetwork || context.signal.aborted)
+        return;
+      if (context.force !== true && context.stored?.checkedAt !== undefined && Date.now() - context.stored.checkedAt < CATALOG_FRESHNESS_WINDOW_MS) {
+        return;
+      }
+      const headers = new Headers({ Accept: "application/json" });
+      if (context.stored?.etag !== undefined) {
+        headers.set("If-None-Match", context.stored.etag);
+      }
+      let response;
+      try {
+        response = await context.catalog.fetch(`${context.catalog.url.replace(/\/+$/u, "")}/${input.id}.json`, {
+          headers,
+          signal: context.signal,
+          redirect: "error"
+        });
+      } catch (error) {
+        context.signal.throwIfAborted();
+        throw new ModelsError2("model_source", `Model catalog request failed for ${input.id}`, {
+          cause: error
+        });
+      }
+      const checkedAt = Date.now();
+      if (response.status === 304) {
+        if (!context.stored) {
+          throw new ModelsError2("model_source", `Model catalog request failed for ${input.id} (HTTP 304 without cached models)`);
+        }
+        await context.publish({ persist: { ...context.stored, checkedAt } });
+        return;
+      }
+      if (response.status !== 200) {
+        throw new ModelsError2("model_source", `Model catalog request failed for ${input.id} (HTTP ${String(response.status)})`);
+      }
+      let value;
+      try {
+        value = await response.json();
+      } catch {
+        throw new ModelsError2("model_source", `Model catalog request failed for ${input.id} (HTTP 200, invalid JSON)`);
+      }
+      if (!Array.isArray(value)) {
+        throw new ModelsError2("model_source", `Model catalog request failed for ${input.id} (HTTP 200, expected an array)`);
+      }
+      const refreshed = usableModels(value);
+      const lastModifiedHeader = response.headers.get("Last-Modified");
+      const parsedLastModified = lastModifiedHeader === null ? undefined : Date.parse(lastModifiedHeader);
+      const lastModified = parsedLastModified === undefined || Number.isNaN(parsedLastModified) ? undefined : parsedLastModified;
+      if (context.signal.aborted)
+        return;
+      await context.publish({
+        persist: {
+          models: value,
+          etag: response.headers.get("ETag") ?? undefined,
+          lastModified,
+          checkedAt
+        },
+        update: () => {
+          catalogModels = refreshed;
+        }
+      });
+    },
+    filterModels: input.filterModels,
+    stream: (model, context, options) => dispatch(model, (streams) => streams.stream(model, context, options)),
+    streamSimple: (model, context, options) => dispatch(model, (streams) => streams.streamSimple(model, context, options))
+  };
+  const streams = single ? [single] : [...byApi.values()].filter((entry) => entry !== undefined);
+  if (streams.some((entry) => entry.fetchDeferred !== undefined)) {
+    provider.fetchDeferred = (model, handle, options) => lazyStream2(model, async () => {
+      const implementation = apiFor(model);
+      if (!implementation?.fetchDeferred) {
+        throw new ModelsError2("provider", `Provider ${input.id} does not support deferred responses for "${model.api}"`);
+      }
+      return implementation.fetchDeferred(model, handle, options);
+    });
+  }
+  if (streams.some((entry) => entry.cancelDeferred !== undefined)) {
+    provider.cancelDeferred = async (model, handle, options) => {
+      const implementation = apiFor(model);
+      if (!implementation?.cancelDeferred) {
+        throw new ModelsError2("provider", `Provider ${input.id} cannot cancel deferred responses for "${model.api}"`);
+      }
+      await implementation.cancelDeferred(model, handle, options);
+    };
+  }
+  return provider;
+}
+
+export { createProvider2 };

package/dist/chunks/account-limits-cache-za42x8a3.js

@@ -0,0 +1,25 @@
+// src/api/github-copilot-headers.ts
+var GITHUB_COPILOT_API_VERSION2 = "2026-06-01";
+var GITHUB_COPILOT_DEFAULT_ORIGIN2 = "https://api.individual.githubcopilot.com";
+var GITHUB_COPILOT_HEADERS2 = {
+  "User-Agent": "GitHubCopilotChat/0.35.0",
+  "Editor-Version": "vscode/1.107.0",
+  "Editor-Plugin-Version": "copilot-chat/0.35.0",
+  "Copilot-Integration-Id": "vscode-chat"
+};
+function buildCopilotDynamicHeaders2(input) {
+  const last = input.messages.at(-1);
+  const headers = {
+    "X-GitHub-Api-Version": GITHUB_COPILOT_API_VERSION2,
+    "X-Initiator": last && last.role !== "user" ? "agent" : "user",
+    "Openai-Intent": "conversation-edits",
+    "X-Interaction-Type": "conversation-agent"
+  };
+  if (input.sessionId)
+    headers["X-Interaction-Id"] = input.sessionId;
+  if (input.messages.some((message) => (message.role === "user" || message.role === "toolResult") && Array.isArray(message.content) && message.content.some((part) => part.type === "image")))
+    headers["Copilot-Vision-Request"] = "true";
+  return headers;
+}
+
+export { GITHUB_COPILOT_API_VERSION2, GITHUB_COPILOT_DEFAULT_ORIGIN2, GITHUB_COPILOT_HEADERS2, buildCopilotDynamicHeaders2 };