@nyte-ai/ai 0.0.0-stage → 0.0.19

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

@@ -0,0 +1,209 @@
+// src/utils/failure.ts
+var CONTEXT_WINDOW_PATTERNS = [
+  /prompt (?:is )?too long/i,
+  /prompt exceeds max length/i,
+  /request_too_large/i,
+  /input is too long for requested model/i,
+  /exceeds the context window/i,
+  /exceeds (?:the )?(?:model'?s )?maximum context length(?: of [\d,]+ tokens?|\s*\([\d,]+\))/i,
+  /input token count.*exceeds the maximum/i,
+  /maximum prompt length is \d+/i,
+  /reduce the length of the messages/i,
+  /maximum context length is \d+ tokens/i,
+  /exceeds (?:the )?maximum allowed input length of [\d,]+ tokens?/i,
+  /input \(\d+ tokens\) is longer than the model'?s context length \(\d+ tokens\)/i,
+  /exceeds the limit of \d+/i,
+  /exceeds the available context size/i,
+  /greater than the context length/i,
+  /context window exceeds limit/i,
+  /exceeded model token limit/i,
+  /too large for model with \d+ maximum context length/i,
+  /prompt has [\d,]+ tokens?, but the configured context size is [\d,]+ tokens?/i,
+  /model_context_window_exceeded/i,
+  /prompt too long; exceeded (?:max )?context length/i,
+  /range of input length should be/i,
+  /context[_ ]length[_ ]exceeded/i,
+  /too many tokens/i,
+  /token limit exceeded/i
+];
+var CEREBRAS_BODYLESS_CONTEXT_WINDOW_PATTERN = /^4(?:00|13)\s*(?:status code)?\s*\(no body\)/i;
+var NOT_CONTEXT_WINDOW_PATTERN = /^(Throttling error|Service unavailable):|rate limit|too many requests/i;
+function pattern(parts) {
+  return new RegExp(parts.join("|"), "i");
+}
+var QUOTA_PATTERN = pattern([
+  "GoUsageLimitError",
+  "FreeUsageLimitError",
+  "Monthly usage limit reached",
+  "available balance",
+  "insufficient[_ -]?quota",
+  "out[_ ]of[_ ]credits",
+  "out of budget",
+  "quota exceeded",
+  "billing"
+]);
+function reportsQuotaExhaustion2(text) {
+  return QUOTA_PATTERN.test(text);
+}
+var AUTH_PATTERN = pattern([
+  "\\b401\\b",
+  "unauthori[sz]ed",
+  "invalid (?:x-)?api[ _-]?key",
+  "authentication"
+]);
+var RATE_LIMIT_PATTERN = pattern([
+  "rate[_ .-]?limit",
+  "too many requests",
+  "throttl",
+  "ResourceExhausted",
+  "retry delay"
+]);
+var OVERLOADED_PATTERN = pattern([
+  "\\b529\\b",
+  "\\b5(?:00|02|03|04|20|24)\\b",
+  "overload",
+  "currently experiencing high demand",
+  "model is at capacity",
+  "service.?unavailable",
+  "temporarily unavailable",
+  "server.?error",
+  "internal.?error",
+  "provider.?returned.?error",
+  "exceeded request buffer limit while retrying upstream",
+  "you can retry your request",
+  "try your request again",
+  "please retry your request"
+]);
+var NETWORK_PATTERN = pattern([
+  "network",
+  "fetch failed",
+  "ECONN",
+  "connection.?(?:lost|refused|reset|error)",
+  "other side closed",
+  "getaddrinfo",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "upstream.?connect",
+  "reset before headers",
+  "socket hang up",
+  "socket connection was closed",
+  "timed? out",
+  "timeout",
+  "terminated",
+  "websocket.?(?:closed|error)",
+  "ended without",
+  "stream ended before message_stop",
+  "stream ended before a terminal response event",
+  "http2 request did not get a response"
+]);
+var RETRY_DELAY_PATTERN = /server requested ([0-9]+(?:\.[0-9]+)?)s retry delay(?: \(max: ([0-9]+(?:\.[0-9]+)?)s\))?/i;
+function classForStatus(status) {
+  if (status === 429)
+    return "rate_limit";
+  if (status === 401 || status === 403)
+    return "auth";
+  if (status === 402)
+    return "quota";
+  if (status === 413)
+    return "context_window";
+  if (status >= 500 && status <= 599)
+    return "overloaded";
+  return;
+}
+function structuredClass(message) {
+  for (const diagnostic of message.diagnostics ?? []) {
+    for (const value of [
+      diagnostic.details?.status,
+      diagnostic.details?.statusCode,
+      diagnostic.error?.code
+    ]) {
+      const status = typeof value === "number" ? value : typeof value === "string" && /^\d{3}$/u.test(value) ? Number(value) : Number.NaN;
+      if (!Number.isInteger(status))
+        continue;
+      const failureClass = classForStatus(status);
+      if (failureClass !== undefined)
+        return failureClass;
+    }
+  }
+  return;
+}
+function classifyText(text, provider) {
+  if (!NOT_CONTEXT_WINDOW_PATTERN.test(text) && (CONTEXT_WINDOW_PATTERNS.some((p) => p.test(text)) || provider === "cerebras" && CEREBRAS_BODYLESS_CONTEXT_WINDOW_PATTERN.test(text))) {
+    return "context_window";
+  }
+  if (reportsQuotaExhaustion2(text))
+    return "quota";
+  if (RATE_LIMIT_PATTERN.test(text))
+    return "rate_limit";
+  if (OVERLOADED_PATTERN.test(text))
+    return "overloaded";
+  if (NETWORK_PATTERN.test(text))
+    return "network";
+  if (AUTH_PATTERN.test(text))
+    return "auth";
+  if (/\b429\b/u.test(text))
+    return "rate_limit";
+  return "provider";
+}
+function retryAfterMs(message) {
+  for (const diagnostic of message.diagnostics ?? []) {
+    for (const key of ["retryAfterMs", "retryDelayMs"]) {
+      const value = diagnostic.details?.[key];
+      if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+        return value;
+    }
+  }
+  const match = message.errorMessage?.match(RETRY_DELAY_PATTERN);
+  const seconds = match === null || match === undefined ? Number.NaN : Number(match[1]);
+  const maximum = match === null || match === undefined ? Number.NaN : Number(match[2]);
+  if (!Number.isFinite(seconds) || seconds < 0)
+    return;
+  return Number.isFinite(maximum) && maximum > 0 && seconds > maximum ? undefined : seconds * 1000;
+}
+function silentOverflow(message, contextWindow) {
+  if (contextWindow === undefined || contextWindow === 0)
+    return false;
+  const inputTokens = message.usage.input + message.usage.cacheRead;
+  if (message.stopReason === "stop")
+    return inputTokens > contextWindow;
+  return message.stopReason === "length" && message.usage.output === 0 && inputTokens >= contextWindow * 0.99;
+}
+function classifyAssistantFailure2(message, model) {
+  if (message.stopReason === "aborted") {
+    return { class: "aborted", message: message.errorMessage ?? "Aborted" };
+  }
+  if (message.stopReason !== "error") {
+    return {
+      class: silentOverflow(message, model?.contextWindow) ? "context_window" : "provider",
+      message: message.errorMessage ?? ""
+    };
+  }
+  const text = message.errorMessage ?? "Unknown error";
+  const failure = {
+    class: reportsQuotaExhaustion2(text) ? "quota" : structuredClass(message) ?? classifyText(text, message.provider),
+    message: text
+  };
+  const delay = retryAfterMs(message);
+  return delay === undefined ? failure : { ...failure, retryAfterMs: delay };
+}
+function retryCanHelp2(failureClass) {
+  switch (failureClass) {
+    case "rate_limit":
+    case "overloaded":
+    case "network":
+      return true;
+    case "auth":
+    case "quota":
+    case "context_window":
+    case "aborted":
+    case "provider":
+    case "runner":
+      return false;
+    default: {
+      const _exhaustive = failureClass;
+      return _exhaustive;
+    }
+  }
+}
+
+export { reportsQuotaExhaustion2, classifyAssistantFailure2, retryCanHelp2 };

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 };