@nyte-ai/ai 0.0.0-stage → 0.0.19

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

@@ -0,0 +1,32 @@
+import {
+  GITHUB_COPILOT_DEFAULT_ORIGIN2
+} from "./account-limits-cache-za42x8a3.js";
+
+// src/providers/github-copilot-catalog.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var CatalogResponse = Type.Object({ data: Type.Array(Type.Unknown()) });
+var CatalogModel = Type.Object({
+  id: Type.String({ minLength: 1 }),
+  model_picker_enabled: Type.Optional(Type.Boolean()),
+  policy: Type.Optional(Type.Object({ state: Type.Optional(Type.String()) })),
+  capabilities: Type.Optional(Type.Object({
+    supports: Type.Optional(Type.Object({ tool_calls: Type.Optional(Type.Boolean()) }))
+  }))
+});
+function parseGitHubCopilotCatalog2(value, origin, knownModelIds) {
+  if (!Value.Check(CatalogResponse, value)) {
+    throw new Error("GitHub Copilot catalog response is not a model list");
+  }
+  const models = value.data.filter((entry) => Value.Check(CatalogModel, entry)).filter((model) => model.capabilities?.supports?.tool_calls !== false && model.policy?.state !== "disabled");
+  const individualFallback = origin === GITHUB_COPILOT_DEFAULT_ORIGIN2 && !models.some((model) => model.model_picker_enabled);
+  const visible = models.filter((model) => individualFallback || model.model_picker_enabled);
+  return {
+    availableModelIds: [
+      ...new Set(visible.filter((model) => individualFallback ? model.policy?.state === "enabled" : model.policy?.state !== "unconfigured").map((model) => model.id))
+    ],
+    needsApproval: visible.some((model) => model.policy?.state === "unconfigured" && knownModelIds.has(model.id))
+  };
+}
+
+export { parseGitHubCopilotCatalog2 };

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

@@ -0,0 +1,37 @@
+import {
+  openAIResponsesApi2
+} from "./account-limits-cache-q1ebtvet.js";
+import {
+  envApiKeyAuth2
+} from "./account-limits-cache-6x05n06z.js";
+import {
+  verifyWithRequest2
+} from "./account-limits-cache-ydq8p8qp.js";
+import {
+  createProvider2
+} from "./account-limits-cache-ykbqsvv6.js";
+
+// src/providers/openai.ts
+var OPENAI_BASE_URL = "https://api.openai.com/v1";
+function openaiProvider2() {
+  return createProvider2({
+    id: "openai",
+    name: "OpenAI",
+    baseUrl: OPENAI_BASE_URL,
+    promptCache: {
+      minimumRetentionMs: { short: 5 * 60000, long: 24 * 60 * 60000 }
+    },
+    auth: {
+      apiKey: envApiKeyAuth2("OpenAI API key", ["OPENAI_API_KEY"]),
+      verify: ({ auth, signal }) => verifyWithRequest2({
+        provider: "OpenAI",
+        url: `${auth.baseUrl ?? OPENAI_BASE_URL}/models`,
+        headers: { ...auth.headers, Authorization: `Bearer ${auth.apiKey ?? ""}` },
+        signal
+      })
+    },
+    api: { "openai-responses": openAIResponsesApi2() }
+  });
+}
+
+export { openaiProvider2 };

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

@@ -0,0 +1,235 @@
+// src/api/constrained-sampling.ts
+import { Type } from "typebox";
+import {
+  IsAdditionalProperties,
+  IsAnyOf,
+  IsConst,
+  IsEnum,
+  IsItems,
+  IsProperties,
+  IsRequired,
+  IsSchemaObject,
+  IsType
+} from "typebox/schema";
+import { Value } from "typebox/value";
+
+class UnsupportedStrictJsonSchemaError extends Error {
+}
+var UNSUPPORTED_STRICT_SCHEMA_KEYS = [
+  "$ref",
+  "$defs",
+  "definitions",
+  "allOf",
+  "oneOf",
+  "patternProperties",
+  "dependentSchemas",
+  "dependencies",
+  "unevaluatedProperties",
+  "propertyNames",
+  "contains",
+  "prefixItems",
+  "not",
+  "if",
+  "then",
+  "else"
+];
+function schemaTypes(schema) {
+  return IsType(schema) ? [schema.type].flat() : [];
+}
+function describesObjectOrArray(schema) {
+  if (!IsSchemaObject(schema))
+    return false;
+  const types = schemaTypes(schema);
+  return types.includes("object") || types.includes("array") || "properties" in schema || "items" in schema;
+}
+function schemaAllowsNull(schema) {
+  if (!IsSchemaObject(schema))
+    return false;
+  if (schemaTypes(schema).includes("null"))
+    return true;
+  if (IsConst(schema) && schema.const === null || IsEnum(schema) && schema.enum.includes(null))
+    return true;
+  return IsAnyOf(schema) && schema.anyOf.some((variant) => schemaAllowsNull(variant));
+}
+function makeJsonSchemaNodeStrict(schema, isUnsupportedKeyword) {
+  if (!IsSchemaObject(schema)) {
+    throw new UnsupportedStrictJsonSchemaError("boolean schemas are unsupported");
+  }
+  for (const key of UNSUPPORTED_STRICT_SCHEMA_KEYS) {
+    if (key in schema) {
+      throw new UnsupportedStrictJsonSchemaError(`${key} schemas are unsupported`);
+    }
+  }
+  if (isUnsupportedKeyword) {
+    for (const [key, value] of Object.entries(schema)) {
+      if (isUnsupportedKeyword(key, value)) {
+        throw new UnsupportedStrictJsonSchemaError(`${key}: ${JSON.stringify(value)} is unsupported`);
+      }
+    }
+  }
+  if ("anyOf" in schema) {
+    if (!IsAnyOf(schema) || schema.anyOf.length === 0) {
+      throw new UnsupportedStrictJsonSchemaError("anyOf must contain at least one schema");
+    }
+    for (const variant of schema.anyOf) {
+      if (describesObjectOrArray(variant)) {
+        throw new UnsupportedStrictJsonSchemaError("object and array unions are unsupported");
+      }
+      makeJsonSchemaNodeStrict(variant, isUnsupportedKeyword);
+    }
+  }
+  if ("items" in schema) {
+    if (!IsItems(schema)) {
+      throw new UnsupportedStrictJsonSchemaError("items must be a schema");
+    }
+    if (Array.isArray(schema.items)) {
+      throw new UnsupportedStrictJsonSchemaError("tuple schemas are unsupported");
+    }
+    makeJsonSchemaNodeStrict(schema.items, isUnsupportedKeyword);
+  }
+  const isObjectSchema = IsType(schema) && schema.type === "object";
+  if ("properties" in schema && !isObjectSchema) {
+    throw new UnsupportedStrictJsonSchemaError("properties require type object");
+  }
+  if (!isObjectSchema)
+    return;
+  if ("additionalProperties" in schema && !(IsAdditionalProperties(schema) && schema.additionalProperties === false)) {
+    throw new UnsupportedStrictJsonSchemaError("schema-valued or true additionalProperties is unsupported");
+  }
+  if ("properties" in schema && !IsProperties(schema)) {
+    throw new UnsupportedStrictJsonSchemaError("object properties must be a schema map");
+  }
+  if ("required" in schema && !IsRequired(schema)) {
+    throw new UnsupportedStrictJsonSchemaError("object required must be a string array");
+  }
+  const properties = IsProperties(schema) ? schema.properties : {};
+  const propertyNames = Object.keys(properties);
+  const required = new Set(IsRequired(schema) ? schema.required : []);
+  if ([...required].some((key) => !propertyNames.includes(key))) {
+    throw new UnsupportedStrictJsonSchemaError("required contains an unknown property");
+  }
+  for (const [key, property] of Object.entries(properties)) {
+    makeJsonSchemaNodeStrict(property, isUnsupportedKeyword);
+    if (!required.has(key) && !schemaAllowsNull(property)) {
+      properties[key] = { anyOf: [property, { type: "null" }] };
+    }
+  }
+  Object.assign(schema, { required: propertyNames, additionalProperties: false });
+}
+function makeStrictJsonSchema(schema, isUnsupportedKeyword) {
+  const cloned = structuredClone(schema);
+  if (!IsSchemaObject(cloned)) {
+    throw new UnsupportedStrictJsonSchemaError("root schema must have type object");
+  }
+  makeJsonSchemaNodeStrict(cloned, isUnsupportedKeyword);
+  if (!IsType(cloned) || cloned.type !== "object") {
+    throw new UnsupportedStrictJsonSchemaError("root schema must have type object");
+  }
+  return cloned;
+}
+function getJsonSchemaToolParameters2(tool, strict) {
+  return { ...strict === true ? makeStrictJsonSchema(tool.parameters) : tool.parameters };
+}
+function getGrammarToolInput2(toolName, arguments_, inputProperty) {
+  if (!Value.Check(Type.Object({ [inputProperty]: Type.String() }), arguments_)) {
+    throw new Error(`Grammar tool call "${toolName}" requires argument "${inputProperty}" to be a string.`);
+  }
+  return arguments_[inputProperty];
+}
+function appendGrammarToolInputJsonDelta2(buffer, inputProperty, nextInput, close) {
+  if (buffer.closed) {
+    if (close && nextInput === buffer.input)
+      return;
+    throw new Error(`grammar tool input for property "${inputProperty}" changed after it was closed`);
+  }
+  if (!nextInput.startsWith(buffer.input)) {
+    throw new Error(`grammar tool input for property "${inputProperty}" changed non-monotonically`);
+  }
+  const inputDelta = nextInput.slice(buffer.input.length);
+  if (!close && inputDelta.length === 0)
+    return;
+  let delta = "";
+  if (!buffer.started) {
+    delta += `{${JSON.stringify(inputProperty)}:"`;
+    buffer.started = true;
+  }
+  delta += JSON.stringify(inputDelta).slice(1, -1);
+  buffer.input = nextInput;
+  if (close) {
+    delta += '"}';
+    buffer.closed = true;
+  }
+  return delta;
+}
+function inferGrammarInputProperty(tool) {
+  const schema = tool.parameters;
+  if (!IsSchemaObject(schema) || !IsType(schema) || schema.type !== "object") {
+    throw new Error("grammar constrained sampling requires an object parameter schema");
+  }
+  if (!IsRequired(schema) || schema.required.length !== 1) {
+    throw new Error("grammar constrained sampling requires exactly one required string property");
+  }
+  const [inputProperty] = schema.required;
+  const property = IsProperties(schema) ? schema.properties[inputProperty] : undefined;
+  if (!property) {
+    throw new Error(`grammar constrained sampling requires a properties entry for ${inputProperty}`);
+  }
+  if (!IsSchemaObject(property) || !IsType(property) || property.type !== "string") {
+    throw new Error(`grammar constrained sampling property ${inputProperty} must have type string`);
+  }
+  return inputProperty;
+}
+function resolveJsonSchemaStrictSampling2(tool, supportsStrictMode, isUnsupportedKeyword) {
+  const config = tool.constrainedSampling;
+  if (!config || config.type !== "json_schema")
+    return;
+  if (supportsStrictMode) {
+    try {
+      makeStrictJsonSchema(tool.parameters, isUnsupportedKeyword);
+      return true;
+    } catch (error) {
+      if (!(error instanceof UnsupportedStrictJsonSchemaError))
+        throw error;
+      if (config.strict !== "require")
+        return;
+      throw new Error(`Tool "${tool.name}" requires JSON-schema constrained sampling, but ${error.message}.`);
+    }
+  }
+  if (config.strict === "require") {
+    throw new Error(`Tool "${tool.name}" requires JSON-schema constrained sampling, but strict tools are unsupported.`);
+  }
+  return;
+}
+function resolveGrammarConstrainedSampling2(tool, supportsOpenAIGrammarTools) {
+  const config = tool.constrainedSampling;
+  if (!config || config.type !== "grammar") {
+    return;
+  }
+  if (!supportsOpenAIGrammarTools) {
+    return;
+  }
+  const larkDefinition = config.variants.openai_lark;
+  const regexDefinition = config.variants.openai_regex;
+  const variant = larkDefinition?.trim() ? { format: "lark", definition: larkDefinition } : regexDefinition?.trim() ? { format: "regex", definition: regexDefinition } : undefined;
+  if (!variant) {
+    throw new Error(`Tool "${tool.name}" cannot use grammar constrained sampling: no supported grammar variant was provided.`);
+  }
+  try {
+    return { ...variant, inputProperty: inferGrammarInputProperty(tool) };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Tool "${tool.name}" cannot use grammar constrained sampling: ${message}.`);
+  }
+}
+function createGrammarToolInputProperties2(tools, supportsOpenAIGrammarTools) {
+  const properties = new Map;
+  for (const tool of tools ?? []) {
+    const grammar = resolveGrammarConstrainedSampling2(tool, supportsOpenAIGrammarTools);
+    if (grammar) {
+      properties.set(tool.name, grammar.inputProperty);
+    }
+  }
+  return properties;
+}
+
+export { getJsonSchemaToolParameters2, getGrammarToolInput2, appendGrammarToolInputJsonDelta2, resolveJsonSchemaStrictSampling2, resolveGrammarConstrainedSampling2, createGrammarToolInputProperties2 };

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

@@ -0,0 +1,142 @@
+import {
+  operationSignal2,
+  raceWithAbortSignal2
+} from "./account-limits-cache-j2bt392s.js";
+
+// src/account-limits-cache.ts
+var FRESHNESS_MS = 60000;
+var RETRY_MS = 15000;
+var TIMEOUT_MS = 15000;
+function mergeLimits(entry, next, requestRevision = entry.revision) {
+  const previous = entry.limits;
+  const windows = new Map(previous?.windows.map((window) => [window.id, window]));
+  entry.revision += 1;
+  for (const window of next.windows) {
+    const observed = entry.observed.get(window.id);
+    if (observed !== undefined && (observed.at > next.observedAt || observed.revision > requestRevision))
+      continue;
+    windows.set(window.id, window);
+    entry.observed.set(window.id, { at: next.observedAt, revision: entry.revision });
+  }
+  entry.limits = {
+    ...previous,
+    ...next,
+    windows: [...windows.values()],
+    observedAt: Math.max(previous?.observedAt ?? 0, next.observedAt)
+  };
+}
+function snapshot(entry) {
+  if (entry.limits === undefined)
+    return entry.unavailable ?? { kind: "unavailable", reason: "failed", message: "No usage available." };
+  return {
+    kind: "ready",
+    limits: entry.limits,
+    stale: entry.fetchedAt === null || Date.now() - entry.fetchedAt >= FRESHNESS_MS,
+    error: entry.error
+  };
+}
+function changedAccount() {
+  return { kind: "unavailable", reason: "failed", message: "The active account changed." };
+}
+
+class AccountLimitsCache2 {
+  providers = new Map;
+  get(providerId, accountId) {
+    const provider = this.providers.get(providerId);
+    return provider?.accounts.get(accountId === undefined ? provider.lastAccount : accountId)?.limits;
+  }
+  invalidate(providerId) {
+    const provider = this.providers.get(providerId);
+    if (provider === undefined)
+      return;
+    provider.generation += 1;
+    for (const entry of provider.accounts.values())
+      entry.flight?.abort.abort();
+    provider.accounts.clear();
+  }
+  scope(providerId) {
+    let provider = this.providers.get(providerId);
+    if (provider === undefined) {
+      provider = { generation: 0, lastAccount: null, accounts: new Map };
+      this.providers.set(providerId, provider);
+    }
+    const state = provider;
+    const generation = state.generation;
+    const accountEntry = (accountId) => {
+      const key = accountId ?? null;
+      state.lastAccount = key;
+      const existing = state.accounts.get(key);
+      if (existing !== undefined)
+        return existing;
+      const entry = {
+        limits: undefined,
+        revision: 0,
+        observed: new Map,
+        fetchedAt: null,
+        retryAt: 0,
+        error: null,
+        unavailable: null,
+        flight: null
+      };
+      state.accounts.set(key, entry);
+      return entry;
+    };
+    return {
+      observe(accountId, limits) {
+        if (state.generation !== generation)
+          return;
+        const entry = accountEntry(accountId);
+        mergeLimits(entry, limits);
+      },
+      async fetch(accountId, load, options) {
+        options?.signal?.throwIfAborted();
+        if (state.generation !== generation)
+          return changedAccount();
+        const entry = accountEntry(accountId);
+        if (entry.flight !== null)
+          return raceWithAbortSignal2(entry.flight.result, operationSignal2(options?.signal));
+        if (Date.now() < entry.retryAt)
+          return snapshot(entry);
+        const abort = new AbortController;
+        const signal = AbortSignal.any([abort.signal, AbortSignal.timeout(TIMEOUT_MS)]);
+        const requestRevision = entry.revision;
+        const result = (async () => {
+          try {
+            const limits = await raceWithAbortSignal2(Promise.resolve().then(() => load(signal)), signal);
+            if (state.generation !== generation)
+              return changedAccount();
+            if (limits === undefined) {
+              entry.unavailable = {
+                kind: "unavailable",
+                reason: "unsupported",
+                message: "This account does not provide subscription usage."
+              };
+              entry.retryAt = Date.now() + RETRY_MS;
+              return snapshot(entry);
+            }
+            mergeLimits(entry, limits, requestRevision);
+            entry.fetchedAt = Date.now();
+            entry.retryAt = entry.fetchedAt + FRESHNESS_MS;
+            entry.error = null;
+            entry.unavailable = null;
+            return snapshot(entry);
+          } catch (error) {
+            if (state.generation !== generation)
+              return changedAccount();
+            const message = error instanceof Error ? error.message : String(error);
+            entry.error = message;
+            entry.unavailable = { kind: "unavailable", reason: "failed", message };
+            entry.retryAt = Date.now() + RETRY_MS;
+            return snapshot(entry);
+          } finally {
+            entry.flight = null;
+          }
+        })();
+        entry.flight = { result, abort };
+        return raceWithAbortSignal2(result, operationSignal2(options?.signal));
+      }
+    };
+  }
+}
+
+export { AccountLimitsCache2 };

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

@@ -0,0 +1,92 @@
+// src/api/openai-completions-reasoning.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var reasoningDetailFields = {
+  id: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+  format: Type.Optional(Type.String()),
+  index: Type.Optional(Type.Number())
+};
+var OpenAIReasoningDetailSchema2 = Type.Union([
+  Type.Object({
+    ...reasoningDetailFields,
+    type: Type.Literal("reasoning.summary"),
+    summary: Type.String()
+  }),
+  Type.Object({
+    ...reasoningDetailFields,
+    type: Type.Literal("reasoning.encrypted"),
+    data: Type.String()
+  }),
+  Type.Object({
+    ...reasoningDetailFields,
+    type: Type.Literal("reasoning.text"),
+    text: Type.String(),
+    signature: Type.Optional(Type.Union([Type.String(), Type.Null()]))
+  })
+]);
+var OpenAIReasoningDetailsSchema = Type.Array(OpenAIReasoningDetailSchema2, { minItems: 1 });
+function parseOpenAIReasoningDetails2(signature) {
+  if (!signature)
+    return;
+  try {
+    const parsed = JSON.parse(signature);
+    return Value.Check(OpenAIReasoningDetailsSchema, parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function parseLegacyEncryptedReasoningDetail2(signature) {
+  if (!signature)
+    return;
+  try {
+    const parsed = JSON.parse(signature);
+    return Value.Check(OpenAIReasoningDetailSchema2, parsed) && parsed.type === "reasoning.encrypted" && parsed.id !== undefined && parsed.id !== null && parsed.id.length > 0 && parsed.data.length > 0 ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function fillMissingCommonReasoningDetailFields(target, source) {
+  target.id ??= source.id;
+  target.format ||= source.format;
+  target.index ??= source.index;
+}
+function appendOpenAIReasoningDetail2(details, detail) {
+  const lastDetail = details.at(-1);
+  if (detail.type === "reasoning.text" && lastDetail?.type === "reasoning.text") {
+    lastDetail.text += detail.text;
+    lastDetail.signature ||= detail.signature;
+    fillMissingCommonReasoningDetailFields(lastDetail, detail);
+    return;
+  }
+  if (detail.type === "reasoning.summary" && lastDetail?.type === "reasoning.summary") {
+    lastDetail.summary += detail.summary;
+    fillMissingCommonReasoningDetailFields(lastDetail, detail);
+    return;
+  }
+  details.push({ ...detail });
+}
+var OPENAI_COMPLETIONS_REASONING_FIELDS = [
+  "reasoning",
+  "reasoning_content",
+  "reasoning_text"
+];
+var OpenAICompletionsReasoningFieldSchema2 = Type.Enum(OPENAI_COMPLETIONS_REASONING_FIELDS);
+var CopilotReasoningOpaqueSchema2 = Type.Object({
+  reasoning_opaque: Type.String({ minLength: 1 })
+});
+var REASONING_DELTA_SCHEMAS2 = ["reasoning_content", "reasoning", "reasoning_text"].map((field) => ({ field, schema: Type.Object({ [field]: Type.String({ minLength: 1 }) }) }));
+var ReasoningDetailsDeltaSchema2 = Type.Object({
+  reasoning_details: Type.Array(Type.Unknown())
+});
+function parseCopilotReasoningOpaque2(signature) {
+  if (!signature)
+    return;
+  try {
+    const parsed = JSON.parse(signature);
+    return Value.Check(CopilotReasoningOpaqueSchema2, parsed) ? parsed.reasoning_opaque : undefined;
+  } catch {
+    return;
+  }
+}
+
+export { OpenAIReasoningDetailSchema2, parseOpenAIReasoningDetails2, parseLegacyEncryptedReasoningDetail2, appendOpenAIReasoningDetail2, OpenAICompletionsReasoningFieldSchema2, CopilotReasoningOpaqueSchema2, REASONING_DELTA_SCHEMAS2, ReasoningDetailsDeltaSchema2, parseCopilotReasoningOpaque2 };

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

@@ -0,0 +1,128 @@
+import {
+  DEFAULT_CODEX_BASE_URL2,
+  extractAccountId2,
+  buildBaseCodexHeaders2
+} from "./account-limits-cache-fvadc36m.js";
+import {
+  limitWindow2,
+  fetchAccountUsage2
+} from "./account-limits-cache-ehy0ze2b.js";
+
+// src/providers/openai-codex-limits.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var OptionalJsonNumber = Type.Optional(Type.Union([Type.Number(), Type.Null()]));
+var CodexUsageWindowSchema = Type.Object({
+  used_percent: Type.Number(),
+  limit_window_seconds: OptionalJsonNumber,
+  reset_at: OptionalJsonNumber
+});
+var CodexUsageResponseSchema = Type.Object({
+  rate_limit: Type.Optional(Type.Union([
+    Type.Object({
+      primary_window: Type.Optional(Type.Unknown()),
+      secondary_window: Type.Optional(Type.Unknown())
+    }),
+    Type.Null()
+  ]))
+});
+var CodexPlanSchema = Type.Object({ plan_type: Type.String() });
+var CodexRateLimitsFrameSchema = Type.Object({
+  type: Type.Literal("codex.rate_limits"),
+  plan_type: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+  rate_limits: Type.Optional(Type.Union([
+    Type.Object({
+      primary: Type.Optional(Type.Unknown()),
+      secondary: Type.Optional(Type.Unknown())
+    }),
+    Type.Null()
+  ]))
+});
+var CodexRateLimitWindowSchema = Type.Object({
+  used_percent: Type.Number(),
+  window_minutes: OptionalJsonNumber,
+  reset_at: OptionalJsonNumber
+});
+var FIVE_HOURS_SECONDS = 5 * 60 * 60;
+var WEEK_SECONDS = 7 * 24 * 60 * 60;
+function durationLabel(seconds) {
+  if (seconds === WEEK_SECONDS)
+    return "Weekly";
+  if (seconds % (24 * 60 * 60) === 0)
+    return `${String(seconds / (24 * 60 * 60))}-day`;
+  if (seconds % (60 * 60) === 0)
+    return `${String(seconds / (60 * 60))}-hour`;
+  return `${String(Math.round(seconds / 60))}-minute`;
+}
+function codexLimitWindow(fallbackId, usedPercent, windowSeconds, resetAtSeconds) {
+  const id = windowSeconds === FIVE_HOURS_SECONDS ? "five_hour" : windowSeconds === WEEK_SECONDS ? "seven_day" : fallbackId;
+  const label = windowSeconds === undefined || windowSeconds === null ? fallbackId === "primary" ? "Primary" : "Secondary" : durationLabel(windowSeconds);
+  return limitWindow2(id, label, usedPercent, resetAtSeconds === undefined || resetAtSeconds === null ? undefined : resetAtSeconds * 1000, windowSeconds === undefined || windowSeconds === null ? undefined : windowSeconds / 60);
+}
+function minutesWindow(fallbackId, window) {
+  if (!window.window_minutes)
+    return;
+  return codexLimitWindow(fallbackId, window.used_percent, window.window_minutes * 60, window.reset_at);
+}
+function accountLimits(providerId, windows, plan) {
+  if (windows.length === 0)
+    return;
+  const limits = { providerId, windows, observedAt: Date.now() };
+  if (plan)
+    limits.plan = plan;
+  return limits;
+}
+function codexFrameLimits2(frame, providerId) {
+  if (!Value.Check(CodexRateLimitsFrameSchema, frame))
+    return;
+  const windows = [];
+  for (const id of ["primary", "secondary"]) {
+    const window = frame.rate_limits?.[id];
+    const parsed = Value.Check(CodexRateLimitWindowSchema, window) ? minutesWindow(id, window) : undefined;
+    if (parsed !== undefined)
+      windows.push(parsed);
+  }
+  return accountLimits(providerId, windows, frame.plan_type);
+}
+function codexHeaderLimits2(headers, providerId) {
+  const windows = [];
+  for (const id of ["primary", "secondary"]) {
+    const usedPercent = Number(headers[`x-codex-${id}-used-percent`]);
+    if (!Number.isFinite(usedPercent))
+      continue;
+    const resetHeader = headers[`x-codex-${id}-reset-at`];
+    const resetAt = resetHeader ? Number(resetHeader) : Number.NaN;
+    const parsed = minutesWindow(id, {
+      used_percent: usedPercent,
+      window_minutes: Number(headers[`x-codex-${id}-window-minutes`]),
+      reset_at: Number.isFinite(resetAt) ? resetAt : null
+    });
+    if (parsed !== undefined)
+      windows.push(parsed);
+  }
+  return accountLimits(providerId, windows, headers["x-codex-plan-type"]);
+}
+async function fetchOpenAICodexAccountLimits2(model, options) {
+  const apiKey = options?.apiKey;
+  if (!apiKey)
+    throw new Error(`No API key for provider: ${model.provider}`);
+  const headers = buildBaseCodexHeaders2(model.headers, options?.headers, extractAccountId2(apiKey), apiKey);
+  headers.set("accept", "application/json");
+  const baseUrl = (model.baseUrl?.trim() || DEFAULT_CODEX_BASE_URL2).replace(/\/+$/, "").replace(/\/codex$/, "");
+  const decoded = await fetchAccountUsage2(`${baseUrl}/wham/usage`, headers, options, CodexUsageResponseSchema, "Codex");
+  const windows = [];
+  for (const [id, window] of [
+    ["primary", decoded.rate_limit?.primary_window],
+    ["secondary", decoded.rate_limit?.secondary_window]
+  ]) {
+    if (!Value.Check(CodexUsageWindowSchema, window))
+      continue;
+    windows.push(codexLimitWindow(id, window.used_percent, window.limit_window_seconds, window.reset_at));
+  }
+  const limits = { providerId: model.provider, windows, observedAt: Date.now() };
+  if (Value.Check(CodexPlanSchema, decoded))
+    limits.plan = decoded.plan_type;
+  return limits;
+}
+
+export { codexFrameLimits2, codexHeaderLimits2, fetchOpenAICodexAccountLimits2 };