@nyte-ai/ai 0.0.0-stage → 0.0.18

package/dist/chunks/account-limits-cache-5jdhn0e1.js

@@ -0,0 +1,562 @@
+import {
+  lazyStream2
+} from "./account-limits-cache-90c9c2eb.js";
+import {
+  operationSignal2,
+  raceWithAbortSignal2
+} from "./account-limits-cache-j2bt392s.js";
+import {
+  AccountLimitsCache2
+} from "./account-limits-cache-hemxtapd.js";
+import {
+  defaultProviderAuthContext2
+} from "./account-limits-cache-1jv43fhh.js";
+import {
+  InMemoryCredentialStore2
+} from "./account-limits-cache-emg5b4hj.js";
+import {
+  ModelsError2,
+  resolveProviderAuth2,
+  DEFAULT_OAUTH_REFRESH_TIMEOUT_MS2
+} from "./account-limits-cache-7z9s8j16.js";
+import {
+  InMemoryModelsStore2
+} from "./account-limits-cache-5ygxyyss.js";
+import {
+  withFastVariants2,
+  baseModel2,
+  providerRequest2
+} from "./account-limits-cache-031vfpt3.js";
+import {
+  mergeProviderHeaders2
+} from "./account-limits-cache-ag5b8dja.js";
+import {
+  uuidv72
+} from "./account-limits-cache-8137j3zp.js";
+import {
+  CatalogRefreshes2
+} from "./account-limits-cache-zpjmeyt0.js";
+
+// src/models.ts
+import { normalizeContext } from "@nyte-ai/schema/model";
+var DEFAULT_MODELS_CATALOG_URL2 = "https://pub-426b80ba181f408387bc9361b2fcbe3f.r2.dev";
+
+class ModelsImpl {
+  providers = new Map;
+  credentials;
+  modelsStore;
+  authContext;
+  catalog;
+  accountLimits;
+  activeAccounts;
+  refreshes;
+  constructor(options, accountLimits = new AccountLimitsCache2, activeAccounts = new Map) {
+    this.credentials = options?.credentials ?? new InMemoryCredentialStore2;
+    this.modelsStore = options?.modelsStore ?? new InMemoryModelsStore2;
+    this.authContext = options?.authContext ?? defaultProviderAuthContext2();
+    this.catalog = {
+      url: options?.catalog?.url ?? DEFAULT_MODELS_CATALOG_URL2,
+      fetch: options?.catalog?.fetch ?? globalThis.fetch
+    };
+    this.accountLimits = accountLimits;
+    this.activeAccounts = activeAccounts;
+    this.refreshes = new CatalogRefreshes2(this.modelsStore, this.catalog);
+  }
+  withProvider(provider) {
+    const models = new ModelsImpl({
+      credentials: this.credentials,
+      modelsStore: this.modelsStore,
+      authContext: this.authContext,
+      catalog: this.catalog
+    }, this.accountLimits, this.activeAccounts);
+    for (const entry of this.providers.values())
+      models.setProvider(entry);
+    models.setProvider(provider);
+    return models;
+  }
+  setProvider(provider) {
+    this.refreshes.supersede(provider.id);
+    this.providers.set(provider.id, provider);
+  }
+  deleteProvider(id) {
+    this.refreshes.supersede(id);
+    this.providers.delete(id);
+  }
+  clearProviders() {
+    for (const id of new Set([...this.providers.keys(), ...this.refreshes.running()])) {
+      this.refreshes.supersede(id);
+    }
+    this.providers.clear();
+  }
+  getProviders() {
+    return Array.from(this.providers.values());
+  }
+  getProvider(id) {
+    return this.providers.get(id);
+  }
+  getModels(provider) {
+    if (provider !== undefined) {
+      const entry = this.providers.get(provider);
+      if (!entry)
+        return [];
+      try {
+        return withFastVariants2(entry.getModels());
+      } catch {
+        return [];
+      }
+    }
+    const models = [];
+    for (const entry of this.providers.values()) {
+      try {
+        models.push(...withFastVariants2(entry.getModels()));
+      } catch {
+        continue;
+      }
+    }
+    return models;
+  }
+  getModel(provider, id) {
+    return this.getModels(provider).find((model) => model.id === id);
+  }
+  async refresh(options = {}) {
+    const allowNetwork = options.allowNetwork ?? true;
+    const callerSignal = operationSignal2(options.signal);
+    const errors = new Map;
+    if (callerSignal.aborted)
+      return { aborted: true, errors };
+    const selected = options.providers ? new Set(options.providers) : undefined;
+    const refresh = Promise.all(Array.from(this.providers.values()).map(async (provider) => {
+      if (provider.refreshModels === undefined || selected && !selected.has(provider.id)) {
+        return;
+      }
+      const error = await this.refreshes.run(provider, allowNetwork, options.force, callerSignal, (signal) => this.readAccounts(provider.id, signal), (accounts, signal) => this.resolveRefreshCredential(provider, accounts, signal));
+      if (error !== undefined)
+        errors.set(provider.id, error);
+    }));
+    try {
+      await raceWithAbortSignal2(refresh, callerSignal);
+    } catch (error) {
+      if (!callerSignal.aborted)
+        throw error;
+    }
+    return { aborted: callerSignal.aborted, errors: new Map(errors) };
+  }
+  async resolveRefreshCredential(provider, stored, signal) {
+    const account = stored?.accounts.find((entry) => entry.id === stored.active);
+    if (stored && !account)
+      return;
+    const credential = account?.credential;
+    if (credential?.type === "oauth") {
+      const oauth = provider.auth.oauth;
+      if (!oauth)
+        return;
+      if (Date.now() < credential.expires)
+        return credential;
+      if (signal.aborted)
+        return;
+      let refreshed;
+      const post = await this.credentials.modify(provider.id, async (current) => {
+        const selected = current?.accounts.find((entry) => entry.id === account?.id);
+        if (!current || selected?.credential.type !== "oauth")
+          return;
+        const previous = selected.credential;
+        if (Date.now() < previous.expires)
+          return;
+        if (refreshed?.token !== previous.refresh) {
+          const next = await oauth.refresh(previous, AbortSignal.any([signal, AbortSignal.timeout(DEFAULT_OAUTH_REFRESH_TIMEOUT_MS2)]));
+          refreshed = { token: previous.refresh, credential: next };
+        }
+        const next = refreshed.credential;
+        return {
+          ...current,
+          accounts: current.accounts.map((entry) => entry.id === account?.id ? { ...entry, credential: next } : entry)
+        };
+      }, { signal });
+      const updated = post?.accounts.find((entry) => entry.id === account?.id)?.credential;
+      return updated?.type === "oauth" ? updated : undefined;
+    }
+    const apiKey = provider.auth.apiKey;
+    if (!apiKey)
+      return;
+    const result = await apiKey.resolve({
+      ctx: this.authContext,
+      credential: credential?.type === "api_key" ? credential : undefined,
+      signal
+    });
+    if (!result)
+      return;
+    return { type: "api_key", key: result.auth.apiKey, env: result.env };
+  }
+  async readAccounts(providerId, signal) {
+    try {
+      return await this.credentials.read(providerId, { signal });
+    } catch (error) {
+      throw new ModelsError2("auth", `Credential store read failed for ${providerId}`, {
+        cause: error
+      });
+    }
+  }
+  async checkOAuthAuth(provider, signal) {
+    const oauth = provider.auth.oauth;
+    if (!oauth)
+      return;
+    if (!oauth.check)
+      return { source: "OAuth", type: "oauth" };
+    try {
+      return await oauth.check({ ctx: this.authContext, signal });
+    } catch (error) {
+      throw new ModelsError2("auth", `OAuth auth check failed for provider ${provider.id}`, {
+        cause: error
+      });
+    }
+  }
+  async checkProviderAuth(provider, credential, signal) {
+    if (credential?.type === "oauth")
+      return this.checkOAuthAuth(provider, signal);
+    const apiKey = provider.auth.apiKey;
+    if (!apiKey)
+      return;
+    if (apiKey.check) {
+      try {
+        return await apiKey.check({
+          ctx: this.authContext,
+          credential: credential?.type === "api_key" ? credential : undefined,
+          signal
+        });
+      } catch (error) {
+        throw new ModelsError2("auth", `API key auth check failed for provider ${provider.id}`, {
+          cause: error
+        });
+      }
+    }
+    try {
+      const resolution = await apiKey.resolve({ ctx: this.authContext, credential, signal });
+      return resolution ? { source: resolution.source, type: "api_key" } : undefined;
+    } catch (error) {
+      throw new ModelsError2("auth", `API key auth check failed for provider ${provider.id}`, {
+        cause: error
+      });
+    }
+  }
+  getAccountLimits(providerId, accountId) {
+    return this.accountLimits.get(providerId, accountId === undefined ? this.activeAccounts.get(providerId) : accountId);
+  }
+  async fetchAccountLimits(providerId, options) {
+    const signal = operationSignal2(options?.signal);
+    signal.throwIfAborted();
+    const provider = this.providers.get(providerId);
+    const scope = this.accountLimits.scope(providerId);
+    const fetchLimits = provider?.fetchAccountLimits;
+    if (!fetchLimits)
+      return scope.fetch(this.activeAccounts.get(providerId) ?? undefined, async () => {
+        return;
+      }, {
+        signal
+      });
+    const accounts = await this.listAccounts(providerId, { signal });
+    const account = accounts.find((entry) => entry.active);
+    if (accounts.length > 0 && !account || !account && await this.checkAuth(providerId, { signal }) === undefined)
+      return {
+        kind: "unavailable",
+        reason: "unconfigured",
+        message: "Sign in to view account usage."
+      };
+    return scope.fetch(account?.id, async (fetchSignal) => {
+      const resolution = await this.getAuth(providerId, { signal: fetchSignal });
+      if (!resolution || resolution.accountId !== account?.id) {
+        this.accountLimits.invalidate(providerId);
+        return;
+      }
+      return fetchLimits({ auth: resolution.auth, signal: fetchSignal });
+    }, { signal });
+  }
+  async listAccounts(providerId, options) {
+    try {
+      const rows = await this.credentials.list(options);
+      const selected = providerId === undefined ? rows : rows.filter((row) => row.providerId === providerId);
+      const providers = providerId === undefined ? this.providers.keys() : [providerId];
+      for (const provider of providers)
+        this.activeAccounts.set(provider, selected.find((row) => row.providerId === provider && row.active)?.id ?? null);
+      return selected;
+    } catch (error) {
+      throw new ModelsError2("auth", `Credential store list failed${providerId ? ` for ${providerId}` : ""}`, { cause: error });
+    }
+  }
+  async selectAccount(providerId, accountId, options) {
+    const signal = operationSignal2(options?.signal);
+    signal.throwIfAborted();
+    if (!this.providers.has(providerId))
+      throw new ModelsError2("provider", `Unknown provider: ${providerId}`);
+    let changed = false;
+    await this.credentials.modify(providerId, async (current) => {
+      if (!current?.accounts.some((account) => account.id === accountId))
+        throw new ModelsError2("auth", `Unknown account for ${providerId}: ${accountId}`);
+      if (current.active === accountId)
+        return;
+      changed = true;
+      return { ...current, active: accountId };
+    }, { signal });
+    this.activeAccounts.set(providerId, accountId);
+    if (!changed)
+      return;
+    this.accountLimits.invalidate(providerId);
+    this.refreshes.supersede(providerId);
+  }
+  checkAuth(providerId, options) {
+    const signal = operationSignal2(options?.signal);
+    const check = (async () => {
+      signal.throwIfAborted();
+      const provider = this.providers.get(providerId);
+      if (!provider)
+        return;
+      const accounts = await this.listAccounts(providerId, { signal });
+      const stored = accounts.find((account) => account.active);
+      if (accounts.length > 0 && stored === undefined)
+        return;
+      if (stored?.type === "oauth")
+        return this.checkOAuthAuth(provider, signal);
+      if (stored?.type === "api_key" && provider.auth.apiKey?.check === undefined)
+        return provider.auth.apiKey ? { source: "stored credential", type: "api_key" } : undefined;
+      const current = stored === undefined ? undefined : await this.readAccounts(providerId, signal);
+      return this.checkProviderAuth(provider, current?.accounts.find((account) => account.id === stored?.id)?.credential, signal);
+    })();
+    return raceWithAbortSignal2(check, signal);
+  }
+  verifyAuth(providerId, options) {
+    const signal = operationSignal2(options?.signal);
+    const verification = (async () => {
+      signal.throwIfAborted();
+      const provider = this.providers.get(providerId);
+      if (!provider) {
+        return { ok: false, reason: "unconfigured", message: `Unknown provider: ${providerId}` };
+      }
+      const resolution = await resolveProviderAuth2(provider, this.credentials, this.authContext, {
+        signal
+      });
+      if (!resolution) {
+        return {
+          ok: false,
+          reason: "unconfigured",
+          message: `${provider.name} has no credential configured`
+        };
+      }
+      const source = resolution.source ?? provider.name;
+      const verify = provider.auth.verify;
+      if (!verify)
+        return { ok: true, source, verified: false };
+      try {
+        const result = await verify({ auth: resolution.auth, ctx: this.authContext, signal });
+        return result.ok ? { ...result, source, verified: result.verified ?? true } : result;
+      } catch {
+        signal.throwIfAborted();
+        return {
+          ok: false,
+          reason: "unreachable",
+          message: `${provider.name} could not be reached to verify the credential`
+        };
+      }
+    })();
+    return raceWithAbortSignal2(verification, signal);
+  }
+  getAvailable(providerId, options) {
+    const signal = operationSignal2(options?.signal);
+    const available = (async () => {
+      signal.throwIfAborted();
+      const providers = providerId ? [this.providers.get(providerId)].filter((entry) => entry !== undefined) : this.getProviders();
+      const checks = await Promise.all(providers.map(async (provider) => {
+        const stored = await this.readAccounts(provider.id, signal);
+        const credential = stored?.accounts.find((account) => account.id === stored.active)?.credential;
+        return {
+          provider,
+          credential,
+          auth: stored && !credential ? undefined : await this.checkProviderAuth(provider, credential, signal)
+        };
+      }));
+      return checks.flatMap(({ provider, credential, auth }) => {
+        if (!auth)
+          return [];
+        const models = provider.getModels();
+        return withFastVariants2(provider.filterModels?.(models, credential) ?? models);
+      });
+    })();
+    return raceWithAbortSignal2(available, signal);
+  }
+  async getAuth(providerOrModel, overrides) {
+    const signal = operationSignal2(overrides?.signal);
+    const providerId = typeof providerOrModel === "string" ? providerOrModel : providerOrModel.provider;
+    const provider = this.providers.get(providerId);
+    if (!provider)
+      return;
+    const result = await resolveProviderAuth2(provider, this.credentials, this.authContext, {
+      ...overrides,
+      signal
+    });
+    if (!result || typeof providerOrModel === "string" || !providerOrModel.headers)
+      return result;
+    return {
+      ...result,
+      auth: {
+        ...result.auth,
+        headers: mergeProviderHeaders2(result.auth.headers, providerOrModel.headers)
+      }
+    };
+  }
+  async login(providerId, type, interaction, label) {
+    const signal = operationSignal2(interaction.signal);
+    signal.throwIfAborted();
+    const provider = this.providers.get(providerId);
+    if (!provider)
+      throw new ModelsError2("provider", `Unknown provider: ${providerId}`);
+    const method = type === "oauth" ? provider.auth.oauth : provider.auth.apiKey;
+    if (!method?.login) {
+      throw new ModelsError2("auth", `${provider.name} does not support ${type} login`);
+    }
+    const accounts = await this.listAccounts(providerId, { signal });
+    const name = label?.trim() || `Account ${accounts.length + 1}`;
+    const loginOperation = method.login({ ...interaction, signal });
+    const credential = await raceWithAbortSignal2(loginOperation, signal);
+    if (credential.type === "api_key" && credential.key !== undefined && credential.key.trim() === "")
+      throw new ModelsError2("auth", "Enter an API key.");
+    let mutationStarted = false;
+    let markMutationStarted;
+    const started = new Promise((resolve) => {
+      markMutationStarted = resolve;
+    });
+    const id = uuidv72();
+    const mutation = this.credentials.modify(providerId, async (current) => {
+      mutationStarted = true;
+      markMutationStarted?.();
+      return {
+        active: id,
+        accounts: [...current?.accounts ?? [], { id, label: name, credential }]
+      };
+    }, { signal });
+    mutation.catch(() => {});
+    try {
+      await new Promise((resolve, reject) => {
+        const onAbort = () => {
+          if (!mutationStarted)
+            reject(signal.reason);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        Promise.race([started, mutation]).finally(() => signal.removeEventListener("abort", onAbort)).then(() => resolve(), reject);
+        if (signal.aborted)
+          onAbort();
+      });
+      await mutation;
+    } catch (error) {
+      signal.throwIfAborted();
+      throw new ModelsError2("auth", `Credential store modify failed for ${providerId}`, {
+        cause: error
+      });
+    }
+    this.refreshes.supersede(providerId);
+    this.activeAccounts.set(providerId, id);
+    this.accountLimits.invalidate(providerId);
+    return credential;
+  }
+  async logout(providerId, options) {
+    const signal = operationSignal2(options?.signal);
+    signal.throwIfAborted();
+    try {
+      const stored = await this.readAccounts(providerId, signal);
+      const id = stored?.active;
+      if (id === undefined || id === null)
+        return;
+      const post = await this.credentials.modify(providerId, async (current) => {
+        if (!current?.accounts.some((account) => account.id === id))
+          return;
+        return {
+          active: current.active === id ? null : current.active,
+          accounts: current.accounts.filter((account) => account.id !== id)
+        };
+      }, { signal });
+      this.activeAccounts.set(providerId, post?.active ?? null);
+    } catch (error) {
+      signal.throwIfAborted();
+      throw new ModelsError2("auth", `Credential store delete failed for ${providerId}`, {
+        cause: error
+      });
+    }
+    this.refreshes.supersede(providerId);
+    this.accountLimits.invalidate(providerId);
+  }
+  requireProvider(model) {
+    const provider = this.providers.get(model.provider);
+    if (!provider) {
+      throw new ModelsError2("provider", `Unknown provider: ${model.provider}`);
+    }
+    return provider;
+  }
+  async applyAuth(selected, selectedOptions) {
+    const { model, options } = providerRequest2(selected, selectedOptions);
+    const scope = this.accountLimits.scope(model.provider);
+    const resolution = await this.getAuth(model, {
+      apiKey: options?.apiKey,
+      env: options?.env,
+      signal: options?.signal
+    });
+    if (!resolution) {
+      throw new ModelsError2("auth", `Provider is not configured: ${model.provider}`);
+    }
+    const auth = resolution.auth;
+    const apiKey = options?.apiKey ?? auth.apiKey;
+    let headers = auth.headers || options?.headers ? mergeProviderHeaders2(auth.headers, options?.headers) : undefined;
+    if (options?.transformHeaders)
+      headers = await options.transformHeaders(headers ?? {});
+    const env = resolution.env || options?.env ? { ...resolution.env ?? {}, ...options?.env ?? {} } : undefined;
+    const requestModel = auth.baseUrl ? { ...model, baseUrl: auth.baseUrl } : model;
+    const { transformHeaders: _transformHeaders, ...providerOptions } = options ?? {};
+    const onAccountLimits = async (limits, requested) => {
+      scope.observe(resolution.accountId, limits);
+      await options?.onAccountLimits?.(limits, requested);
+    };
+    const requestOptions = { ...providerOptions, apiKey, headers, env, onAccountLimits };
+    return { requestModel, requestOptions };
+  }
+  stream(model, context, options) {
+    const transcript = normalizeContext(context);
+    return lazyStream2(baseModel2(model), async () => {
+      const provider = this.requireProvider(model);
+      const { requestModel, requestOptions } = await this.applyAuth(model, options);
+      return provider.stream(requestModel, transcript, requestOptions);
+    });
+  }
+  async complete(model, context, options) {
+    return this.stream(model, context, options).result();
+  }
+  streamSimple(model, context, options) {
+    const transcript = normalizeContext(context);
+    return lazyStream2(baseModel2(model), async () => {
+      const provider = this.requireProvider(model);
+      const { requestModel, requestOptions } = await this.applyAuth(model, options);
+      return provider.streamSimple(requestModel, transcript, requestOptions);
+    });
+  }
+  async completeSimple(model, context, options) {
+    return this.streamSimple(model, context, options).result();
+  }
+  async fetchDeferred(model, handle, options) {
+    return lazyStream2(baseModel2(model), async () => {
+      const provider = this.requireProvider(model);
+      if (!provider.fetchDeferred) {
+        throw new ModelsError2("provider", `Provider ${model.provider} does not support deferred responses`);
+      }
+      const { requestModel, requestOptions } = await this.applyAuth(model, options);
+      return provider.fetchDeferred(requestModel, handle, requestOptions);
+    }).result();
+  }
+  async cancelDeferred(model, handle, options) {
+    const provider = this.requireProvider(model);
+    if (!provider.cancelDeferred) {
+      throw new ModelsError2("provider", `Provider ${model.provider} does not support deferred responses`);
+    }
+    const { requestModel, requestOptions } = await this.applyAuth(model, options);
+    await provider.cancelDeferred(requestModel, handle, requestOptions);
+  }
+}
+function createModels2(options) {
+  return new ModelsImpl(options);
+}
+
+export { DEFAULT_MODELS_CATALOG_URL2, createModels2 };

package/dist/chunks/account-limits-cache-5rx2pfm5.js

@@ -0,0 +1,8 @@
+import {
+  lazyApi2
+} from "./account-limits-cache-90c9c2eb.js";
+
+// src/api/openai-codex-responses.lazy.ts
+var openAICodexResponsesApi2 = () => lazyApi2(() => import("../src/api/openai-codex-responses.js"));
+
+export { openAICodexResponsesApi2 };

package/dist/chunks/account-limits-cache-5ygxyyss.js

@@ -0,0 +1,19 @@
+// src/models-store.ts
+class InMemoryModelsStore2 {
+  entries = new Map;
+  async read(providerId, options) {
+    options?.signal?.throwIfAborted();
+    const entry = this.entries.get(providerId);
+    return entry ? structuredClone(entry) : undefined;
+  }
+  async write(providerId, entry, options) {
+    options?.signal?.throwIfAborted();
+    this.entries.set(providerId, structuredClone(entry));
+  }
+  async delete(providerId, options) {
+    options?.signal?.throwIfAborted();
+    this.entries.delete(providerId);
+  }
+}
+
+export { InMemoryModelsStore2 };

package/dist/chunks/account-limits-cache-6250ykn6.js

@@ -0,0 +1,21 @@
+// src/utils/transcript.ts
+import {
+  collapseSystemMessages as collapseSystemMessages2,
+  createInitialSystemMessage as createInitialSystemMessage2,
+  declarationsEqual as declarationsEqual2,
+  getCurrentSystemMessage as getCurrentSystemMessage2,
+  getCurrentSystemPrompt as getCurrentSystemPrompt2,
+  getCurrentTools as getCurrentTools2,
+  getDeclaredTools as getDeclaredTools2,
+  getInitialSystemMessage as getInitialSystemMessage2,
+  getToolStateChanges as getToolStateChanges2,
+  hasNonAdditiveToolChanges as hasNonAdditiveToolChanges2,
+  hasToolRedefinitions as hasToolRedefinitions2,
+  normalizeContext as normalizeContext2,
+  resolveTranscript as resolveTranscript2,
+  resolveTranscriptTools as resolveTranscriptTools2,
+  toToolDeclaration as toToolDeclaration2,
+  withoutInitialSystemMessage as withoutInitialSystemMessage2
+} from "@nyte-ai/schema/model";
+
+export { collapseSystemMessages2, createInitialSystemMessage2, declarationsEqual2, getCurrentSystemMessage2, getCurrentSystemPrompt2, getCurrentTools2, getDeclaredTools2, getInitialSystemMessage2, getToolStateChanges2, hasNonAdditiveToolChanges2, hasToolRedefinitions2, normalizeContext2, resolveTranscript2, resolveTranscriptTools2, toToolDeclaration2, withoutInitialSystemMessage2 };

package/dist/chunks/account-limits-cache-6x05n06z.js

@@ -0,0 +1,49 @@
+// src/auth/helpers.ts
+function envApiKeyAuth2(name, envVars) {
+  return {
+    name,
+    login: async (interaction) => {
+      interaction.signal.throwIfAborted();
+      const key = await interaction.prompt({ type: "secret", message: `Enter ${name}` });
+      interaction.signal.throwIfAborted();
+      return { type: "api_key", key };
+    },
+    resolve: async ({ ctx, credential, signal }) => {
+      signal.throwIfAborted();
+      if (credential?.key) {
+        return {
+          auth: { apiKey: credential.key },
+          env: credential.env,
+          source: "stored credential"
+        };
+      }
+      for (const envVar of envVars) {
+        const value = await ctx.env(envVar);
+        signal.throwIfAborted();
+        if (value)
+          return { auth: { apiKey: value }, source: envVar };
+      }
+      return;
+    }
+  };
+}
+function lazyOAuth2(input) {
+  let promise;
+  const loaded = () => {
+    promise ??= input.load().catch((error) => {
+      promise = undefined;
+      throw error;
+    });
+    return promise;
+  };
+  return {
+    name: input.name,
+    isSubscription: input.isSubscription,
+    loginLabel: input.loginLabel,
+    login: async (interaction) => (await loaded()).login(interaction),
+    refresh: async (credential, signal) => (await loaded()).refresh(credential, signal),
+    toAuth: async (credential) => (await loaded()).toAuth(credential)
+  };
+}
+
+export { envApiKeyAuth2, lazyOAuth2 };

package/dist/chunks/account-limits-cache-736tdyme.js

@@ -0,0 +1,6 @@
+// src/api/token-count.ts
+import { Type } from "typebox";
+var TokenCount2 = Type.Integer({ minimum: 0 });
+var NullableTokenCount2 = Type.Optional(Type.Union([TokenCount2, Type.Null()]));
+
+export { TokenCount2, NullableTokenCount2 };