@nyte-ai/ai 0.0.0-stage → 0.0.18

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

@@ -0,0 +1,110 @@
+import {
+  providerHeadersToRecord2
+} from "./account-limits-cache-ag5b8dja.js";
+import {
+  getNyteUserAgent2
+} from "./account-limits-cache-gknnm1kv.js";
+
+// src/api/openai-codex-wire.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var CodexFrameJson2 = Type.Object({ type: Type.String() });
+var TextJson = Type.String();
+var BooleanJson = Type.Boolean();
+var NumberJson = Type.Number();
+var JsonObjectJson = Type.Record(Type.String(), Type.Unknown());
+function readText2(value) {
+  return Value.Check(TextJson, value) ? value : undefined;
+}
+function readBoolean2(value) {
+  return Value.Check(BooleanJson, value) ? value : undefined;
+}
+function readNumber2(value) {
+  return Value.Check(NumberJson, value) ? value : undefined;
+}
+function readRecord2(value) {
+  return Value.Check(JsonObjectJson, value) ? value : undefined;
+}
+var TERMINAL_RESPONSE_TYPES2 = new Set([
+  "response.completed",
+  "response.done",
+  "response.incomplete",
+  "response.failed"
+]);
+var DEFAULT_CODEX_BASE_URL2 = "https://chatgpt.com/backend-api";
+var OPENAI_BETA_RESPONSES_WEBSOCKETS = "responses_websockets=2026-02-06";
+var AccessTokenClaimsSchema = Type.Object({
+  "https://api.openai.com/auth": Type.Object({
+    chatgpt_account_id: Type.String({ minLength: 1 })
+  })
+});
+function normalizeTimeoutMs2(value) {
+  if (value === undefined)
+    return;
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error(`Invalid timeoutMs: ${String(value)}`);
+  }
+  return Math.floor(value);
+}
+function resolveCodexUrl2(baseUrl) {
+  const raw = baseUrl && baseUrl.trim().length > 0 ? baseUrl : DEFAULT_CODEX_BASE_URL2;
+  const normalized = raw.replace(/\/+$/, "");
+  if (normalized.endsWith("/codex/responses"))
+    return normalized;
+  if (normalized.endsWith("/codex"))
+    return `${normalized}/responses`;
+  return `${normalized}/codex/responses`;
+}
+function resolveCodexWebSocketUrl2(baseUrl) {
+  const url = new URL(resolveCodexUrl2(baseUrl));
+  if (url.protocol === "https:")
+    url.protocol = "wss:";
+  if (url.protocol === "http:")
+    url.protocol = "ws:";
+  return url.toString();
+}
+function extractAccountId2(token) {
+  const parts = token.split(".");
+  let claims;
+  try {
+    claims = parts.length === 3 ? JSON.parse(atob(parts[1])) : undefined;
+  } catch {
+    claims = undefined;
+  }
+  if (!Value.Check(AccessTokenClaimsSchema, claims)) {
+    throw new Error("Failed to extract accountId from token");
+  }
+  return claims["https://api.openai.com/auth"].chatgpt_account_id;
+}
+function buildBaseCodexHeaders2(initHeaders, additionalHeaders, accountId, token) {
+  const headers = new Headers(Object.entries(providerHeadersToRecord2(initHeaders, additionalHeaders) ?? {}));
+  headers.set("Authorization", `Bearer ${token}`);
+  headers.set("chatgpt-account-id", accountId);
+  headers.set("originator", "nyte");
+  headers.set("User-Agent", getNyteUserAgent2());
+  return headers;
+}
+function buildSSEHeaders2(initHeaders, additionalHeaders, accountId, token, sessionId) {
+  const headers = buildBaseCodexHeaders2(initHeaders, additionalHeaders, accountId, token);
+  headers.set("OpenAI-Beta", "responses=experimental");
+  headers.set("accept", "text/event-stream");
+  headers.set("content-type", "application/json");
+  if (sessionId) {
+    headers.set("session-id", sessionId);
+    headers.set("x-client-request-id", sessionId);
+  }
+  return headers;
+}
+function buildWebSocketHeaders2(initHeaders, additionalHeaders, accountId, token, requestId) {
+  const headers = buildBaseCodexHeaders2(initHeaders, additionalHeaders, accountId, token);
+  headers.delete("accept");
+  headers.delete("content-type");
+  headers.delete("OpenAI-Beta");
+  headers.delete("openai-beta");
+  headers.set("OpenAI-Beta", OPENAI_BETA_RESPONSES_WEBSOCKETS);
+  headers.set("x-client-request-id", requestId);
+  headers.set("session-id", requestId);
+  return headers;
+}
+
+export { CodexFrameJson2, readText2, readBoolean2, readNumber2, readRecord2, TERMINAL_RESPONSE_TYPES2, DEFAULT_CODEX_BASE_URL2, normalizeTimeoutMs2, resolveCodexUrl2, resolveCodexWebSocketUrl2, extractAccountId2, buildBaseCodexHeaders2, buildSSEHeaders2, buildWebSocketHeaders2 };

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

@@ -0,0 +1,69 @@
+import {
+  defaultProviderAuthContext2
+} from "./account-limits-cache-1jv43fhh.js";
+import {
+  FileCredentialStore2
+} from "./account-limits-cache-c7v93krb.js";
+import {
+  FileModelsStore2
+} from "./account-limits-cache-a55e14fr.js";
+import {
+  createModels2
+} from "./account-limits-cache-5jdhn0e1.js";
+import {
+  anthropicProvider2
+} from "./account-limits-cache-8wfqg73s.js";
+import {
+  githubCopilotProvider2
+} from "./account-limits-cache-a1jyaq00.js";
+import {
+  openaiCodexProvider2
+} from "./account-limits-cache-09vs98g6.js";
+import {
+  openaiProvider2
+} from "./account-limits-cache-gsa5tzck.js";
+import {
+  opencodeProvider2
+} from "./account-limits-cache-nbkyhs6v.js";
+import {
+  opencodeGoProvider2
+} from "./account-limits-cache-nyy770yd.js";
+import {
+  openrouterProvider2
+} from "./account-limits-cache-pfa86y8e.js";
+import {
+  vercelAiGatewayProvider2
+} from "./account-limits-cache-q63mc41j.js";
+
+// src/providers/nyte-catalog.ts
+var NYTE_PROVIDERS = [
+  openaiCodexProvider2,
+  openaiProvider2,
+  anthropicProvider2,
+  opencodeProvider2,
+  opencodeGoProvider2,
+  githubCopilotProvider2,
+  vercelAiGatewayProvider2,
+  openrouterProvider2
+];
+var defaultModelPerProvider2 = {
+  "openai-codex": "gpt-5.6-luna",
+  openai: "gpt-5.6-luna",
+  anthropic: "claude-opus-5"
+};
+function createNyteModels2() {
+  const models = createModels2({
+    credentials: new FileCredentialStore2,
+    authContext: defaultProviderAuthContext2(),
+    modelsStore: new FileModelsStore2,
+    catalog: { url: process.env.NYTE_MODELS_URL }
+  });
+  for (const provider of nyteProviders2())
+    models.setProvider(provider);
+  return models;
+}
+function nyteProviders2() {
+  return NYTE_PROVIDERS.map((provider) => provider());
+}
+
+export { defaultModelPerProvider2, createNyteModels2, nyteProviders2 };

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

@@ -0,0 +1,13 @@
+// src/utils/nyte-user-agent.ts
+function loadNodeOs() {
+  if (typeof process === "undefined" || !(process.versions?.node || process.versions?.bun)) {
+    return null;
+  }
+  return process.getBuiltinModule?.("node:os") ?? null;
+}
+var nodeOs = loadNodeOs();
+function getNyteUserAgent2() {
+  return nodeOs ? `nyte (${nodeOs.platform()} ${nodeOs.release()}; ${nodeOs.arch()})` : "nyte (browser)";
+}
+
+export { getNyteUserAgent2 };

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

@@ -0,0 +1,40 @@
+// src/session-resources.ts
+var sessionResourceCleanups = new Set;
+var sessionResourceLeases = new Map;
+function registerSessionResourceCleanup2(cleanup) {
+  sessionResourceCleanups.add(cleanup);
+  return () => {
+    sessionResourceCleanups.delete(cleanup);
+  };
+}
+function cleanupSessionResources2(sessionId) {
+  const errors = [];
+  for (const cleanup of sessionResourceCleanups) {
+    try {
+      cleanup(sessionId);
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  if (errors.length > 0) {
+    throw new AggregateError(errors, "Failed to cleanup session resources");
+  }
+}
+function acquireSessionResources2(sessionId) {
+  sessionResourceLeases.set(sessionId, (sessionResourceLeases.get(sessionId) ?? 0) + 1);
+  let released = false;
+  return () => {
+    if (released)
+      return;
+    released = true;
+    const remaining = (sessionResourceLeases.get(sessionId) ?? 1) - 1;
+    if (remaining > 0) {
+      sessionResourceLeases.set(sessionId, remaining);
+      return;
+    }
+    sessionResourceLeases.delete(sessionId);
+    cleanupSessionResources2(sessionId);
+  };
+}
+
+export { registerSessionResourceCleanup2, cleanupSessionResources2, acquireSessionResources2 };

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