@aryee337/aery-ai 0.1.148 → 0.2.10

package/dist/types/index.d.ts

@@ -0,0 +1,49 @@
+export { type ZodType, z } from "zod/v4";
+export * from "./api-registry";
+export * from "./auth-broker";
+export { type AuthGatewayBootOptions, type ModelResolver, startAuthGateway } from "./auth-gateway/server";
+export * from "./auth-gateway/types";
+export * from "./auth-storage";
+export * from "./model-cache";
+export * from "./model-manager";
+export * from "./model-thinking";
+export * from "./models";
+export * from "./provider-details";
+export * from "./provider-models";
+export * from "./providers/anthropic";
+export * from "./providers/anthropic-client";
+export * from "./providers/azure-openai-responses";
+export type * from "./providers/cursor";
+export * from "./providers/gitlab-duo";
+export type * from "./providers/google";
+export type * from "./providers/google-gemini-cli";
+export * from "./providers/google-gemini-headers";
+export type * from "./providers/google-vertex";
+export * from "./providers/kimi";
+export * from "./providers/mock";
+export * from "./providers/ollama";
+export * from "./providers/openai-codex-responses";
+export * from "./providers/openai-completions";
+export * from "./providers/openai-responses";
+export * from "./providers/synthetic";
+export * from "./rate-limit-utils";
+export * from "./stream";
+export * from "./types";
+export * from "./usage";
+export * from "./usage/claude";
+export * from "./usage/gemini";
+export * from "./usage/github-copilot";
+export * from "./usage/google-antigravity";
+export * from "./usage/kimi";
+export * from "./usage/minimax-code";
+export * from "./usage/openai-codex";
+export * from "./usage/zai";
+export * from "./utils/anthropic-auth";
+export * from "./utils/discovery";
+export * from "./utils/event-stream";
+export * from "./utils/oauth";
+export type { OAuthCredentials, OAuthProvider, OAuthProviderId, OAuthProviderInfo, } from "./utils/oauth/types";
+export * from "./utils/overflow";
+export * from "./utils/retry";
+export * from "./utils/schema";
+export * from "./utils/validation";

package/dist/types/model-cache.d.ts

@@ -0,0 +1,17 @@
+import type { Api, Model } from "./types";
+interface CacheEntry<TApi extends Api = Api> {
+    models: Model<TApi>[];
+    fresh: boolean;
+    authoritative: boolean;
+    updatedAt: number;
+    /**
+     * Hash of the static catalog slice that was merged into `models` when this
+     * row was written. `resolveProviderModels` compares against the current
+     * static fingerprint and bypasses the static+cache re-merge when they
+     * match — the cache already incorporates the same static state.
+     */
+    staticFingerprint: string;
+}
+export declare function readModelCache<TApi extends Api>(providerId: string, ttlMs: number, now: () => number, dbPath?: string): CacheEntry<TApi> | null;
+export declare function writeModelCache<TApi extends Api>(providerId: string, updatedAt: number, models: Model<TApi>[], authoritative: boolean, staticFingerprint: string, dbPath?: string): void;
+export {};

package/dist/types/model-manager.d.ts

@@ -0,0 +1,64 @@
+import type { Api, Model, Provider } from "./types";
+/**
+ * Controls when dynamic endpoint models should be fetched.
+ */
+export type ModelRefreshStrategy = "online" | "offline" | "online-if-uncached";
+/**
+ * Hook for loading and mapping models.dev fallback data into canonical model objects.
+ */
+export interface ModelsDevFallback<TApi extends Api = Api, TPayload = unknown> {
+    /** Fetches raw fallback payload (for example from models.dev). */
+    fetch(): Promise<TPayload>;
+    /** Maps payload into provider models. */
+    map(payload: TPayload, providerId: Provider): readonly Model<TApi>[];
+}
+/**
+ * Configuration for provider model resolution.
+ */
+export interface ModelManagerOptions<TApi extends Api = Api, TModelsDevPayload = unknown> {
+    /** Provider id used for static lookup and cache namespacing. */
+    providerId: Provider;
+    /** Optional static list override. When omitted, bundled models.json is used. */
+    staticModels?: readonly Model<TApi>[];
+    /** Optional override for the cache database path. Default: <agent-dir>/models.db. */
+    cacheDbPath?: string;
+    /** Maximum cache age in milliseconds before considered stale. Default: 24h. */
+    cacheTtlMs?: number;
+    /** When true, a successful dynamic fetch is the complete provider catalog and prunes static-only models. */
+    dynamicModelsAuthoritative?: boolean;
+    /** Optional dynamic endpoint fetcher. */
+    fetchDynamicModels?: () => Promise<readonly Model<TApi>[] | null>;
+    /** Optional models.dev fallback hook. */
+    modelsDev?: ModelsDevFallback<TApi, TModelsDevPayload>;
+    /** Clock override for deterministic tests. */
+    now?: () => number;
+}
+/**
+ * Resolution result.
+ *
+ * `stale` is false when the resolved catalog is authoritative for the selected provider:
+ * - dynamic endpoint data was fetched in this call,
+ * - a still-fresh authoritative cache was reused in `online-if-uncached` mode, or
+ * - the provider has no dynamic fetcher configured.
+ */
+export interface ModelResolutionResult<TApi extends Api = Api> {
+    models: Model<TApi>[];
+    stale: boolean;
+}
+/**
+ * Stateful facade over provider model resolution.
+ */
+export interface ModelManager<TApi extends Api = Api> {
+    refresh(strategy?: ModelRefreshStrategy): Promise<ModelResolutionResult<TApi>>;
+}
+/**
+ * Creates a reusable provider model manager.
+ */
+export declare function createModelManager<TApi extends Api = Api, TModelsDevPayload = unknown>(options: ModelManagerOptions<TApi, TModelsDevPayload>): ModelManager<TApi>;
+/**
+ * Resolves provider models with source precedence:
+ * static -> models.dev -> cache -> dynamic.
+ *
+ * Later sources override earlier ones by model id.
+ */
+export declare function resolveProviderModels<TApi extends Api = Api, TModelsDevPayload = unknown>(options: ModelManagerOptions<TApi, TModelsDevPayload>, strategy?: ModelRefreshStrategy): Promise<ModelResolutionResult<TApi>>;

package/dist/types/model-thinking.d.ts

@@ -0,0 +1,100 @@
+import type { Api, Model as ApiModel } from "./types";
+/** User-facing thinking levels, ordered least to most intensive. */
+export declare const enum Effort {
+    Minimal = "minimal",
+    Low = "low",
+    Medium = "medium",
+    High = "high",
+    XHigh = "xhigh"
+}
+export declare const THINKING_EFFORTS: readonly Effort[];
+/**
+ * Static fallback model injected when Cloudflare AI Gateway discovery
+ * returns no results. Ensures the provider always has at least one usable
+ * model entry in the catalog.
+ */
+export declare const CLOUDFLARE_FALLBACK_MODEL: ApiModel<"anthropic-messages">;
+/**
+ * Returns a copy of the model with canonical thinking metadata attached.
+ *
+ * This helper belongs to catalog enrichment only. Runtime consumers should
+ * trust `model.thinking` and avoid inferring capabilities on demand.
+ */
+export declare function enrichModelThinking<TApi extends Api>(model: ApiModel<TApi>): ApiModel<TApi>;
+/**
+ * Returns a copy of the model with thinking metadata recomputed from the
+ * canonical rules, replacing any existing `thinking`.
+ */
+export declare function refreshModelThinking<TApi extends Api>(model: ApiModel<TApi>): ApiModel<TApi>;
+/**
+ * Apply upstream metadata corrections to a mutable array of models.
+ *
+ * Each model is first normalized through `refreshModelThinking()` so generated
+ * catalogs keep canonical thinking metadata and policy fixes in one pass.
+ */
+export declare function applyGeneratedModelPolicies(models: ApiModel<Api>[]): void;
+/**
+ * Link OpenAI model variants to their context promotion targets.
+ *
+ * When a model's context is exhausted, the agent can promote to a sibling
+ * model with a larger context window on the same provider:
+ * - `codex-spark` variants promote to `gpt-5.5`.
+ * - `gpt-5.5` (270K input) promotes to `gpt-5.4` (1M input).
+ */
+export declare function linkOpenAIPromotionTargets(models: ApiModel<Api>[]): void;
+/**
+ * True when the model reasons natively but rejects the wire `reasoning.effort`
+ * param (compat.supportsReasoningEffort: false on openai-responses*). Callers
+ * are expected to omit the effort field; the wire-side omitReasoningEffort
+ * gate (providers/xai-responses.ts:78) is the actual strip, and this
+ * predicate is the upstream check that prevents a redundant
+ * requireSupportedEffort throw from defeating that gate.
+ *
+ * Scoped to openai-responses* because that's the only API surface where
+ * `compat.supportsReasoningEffort: false` is meaningful today. The
+ * `in`-narrowed access is necessary because Model.compat is
+ * `AnthropicCompat | OpenAICompat` and the api gate doesn't narrow the
+ * union for TS.
+ */
+export declare function modelOmitsReasoningEffort<TApi extends Api>(model: ApiModel<TApi>): boolean;
+/**
+ * Returns the supported thinking efforts declared on the model metadata.
+ *
+ * Catalog enrichment is responsible for normalizing bundled model metadata up front.
+ * Runtime callers must treat explicit `model.thinking` on custom models as authoritative
+ * so proxy-specific overrides from `models.yml` survive request construction.
+ *
+ * @throws Error when a reasoning-capable model is missing thinking metadata
+ */
+export declare function getSupportedEfforts<TApi extends Api>(model: ApiModel<TApi>): readonly Effort[];
+/**
+ * Clamps a requested thinking level against explicit model metadata.
+ *
+ * Non-reasoning models always resolve to `undefined`.
+ */
+export declare function clampThinkingLevelForModel<TApi extends Api>(model: ApiModel<TApi> | undefined, requested: Effort | undefined): Effort | undefined;
+export declare function requireSupportedEffort<TApi extends Api>(model: ApiModel<TApi>, effort: Effort): Effort;
+/** Maps a normalized thinking effort to Google's `thinkingLevel` enum values. */
+export declare function mapEffortToGoogleThinkingLevel<TApi extends Api>(model: ApiModel<TApi>, effort: Effort): "MINIMAL" | "LOW" | "MEDIUM" | "HIGH";
+/** Maps a normalized thinking effort to Anthropic adaptive effort values. */
+export declare function mapEffortToAnthropicAdaptiveEffort<TApi extends Api>(model: ApiModel<TApi>, effort: Effort): "low" | "medium" | "high" | "xhigh" | "max";
+/**
+ * Returns true for Anthropic models with Opus 4.7 API restrictions:
+ * - Sampling parameters (temperature/top_p/top_k) return 400 error
+ * - Thinking content is omitted by default (needs display: "summarized")
+ */
+export declare function hasOpus47ApiRestrictions(modelId: string): boolean;
+/**
+ * Mid-conversation `role: "system"` messages (system instructions appended at
+ * non-first positions in the `messages` array) are supported starting with
+ * Claude Opus 4.8. Earlier Claude models reject the role.
+ * @see https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages
+ */
+export declare function supportsMidConversationSystemMessages(modelId: string): boolean;
+/**
+ * Claude Opus 4.8 must emit at most one tool call per turn: the Anthropic
+ * Messages provider sends `tool_choice.disable_parallel_tool_use = true` for
+ * this model. Scoped to exactly 4.8 — earlier and later Opus versions keep
+ * Anthropic's default parallel tool-calling.
+ */
+export declare function disablesParallelToolUse(modelId: string): boolean;

package/dist/types/models.d.ts

@@ -0,0 +1,12 @@
+import MODELS from "./models.json";
+import type { Api, KnownProvider, Model, Usage } from "./types";
+export type GeneratedProvider = keyof typeof MODELS;
+export declare function getBundledModel<TApi extends Api = Api>(provider: GeneratedProvider, modelId: string): Model<TApi>;
+export declare function getBundledProviders(): KnownProvider[];
+export declare function getBundledModels(provider: GeneratedProvider): Model<Api>[];
+export declare function calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage): Usage["cost"];
+/**
+ * Check if two models are equal by comparing both their id and provider.
+ * Returns false if either model is null or undefined.
+ */
+export declare function modelsAreEqual<TApi extends Api>(a: Model<TApi> | null | undefined, b: Model<TApi> | null | undefined): boolean;

package/dist/types/provider-details.d.ts

@@ -0,0 +1,24 @@
+import type { Api, Model, Provider, ProviderSessionState } from "./types";
+export interface ProviderDetailField {
+    label: string;
+    value: string;
+}
+export interface ProviderDetails {
+    provider: Provider;
+    api: Api;
+    fields: ProviderDetailField[];
+}
+export interface ProviderDetailsContext {
+    model: Model<Api>;
+    sessionId?: string;
+    authMode?: string;
+    /**
+     * Human-readable description of the active credential, e.g.
+     * `"broker http://can.internal:8765 · oauth #5 (foo@bar.com)"`.
+     * Rendered as a `Source` field; omitted when undefined.
+     */
+    credentialSource?: string;
+    preferWebsockets?: boolean;
+    providerSessionState?: Map<string, ProviderSessionState>;
+}
+export declare function getProviderDetails(context: ProviderDetailsContext): ProviderDetails;

package/dist/types/provider-models/bundled-references.d.ts

@@ -0,0 +1,4 @@
+import { getBundledModels } from "../models";
+import type { Api, Model } from "../types";
+export declare function createBundledReferenceMap<TApi extends Api>(provider: Parameters<typeof getBundledModels>[0]): Map<string, Model<TApi>>;
+export declare function createReferenceResolver<TApi extends Api>(providerRefs: Map<string, Model<TApi>>): (modelId: string) => Model<TApi> | undefined;

package/dist/types/provider-models/descriptors.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Unified provider descriptors — single source of truth for provider metadata
+ * used by both runtime model discovery (model-registry.ts) and catalog
+ * generation (generate-models.ts).
+ */
+import type { ModelManagerOptions } from "../model-manager";
+import type { Api, KnownProvider } from "../types";
+import type { OAuthProvider } from "../utils/oauth/types";
+/** Catalog discovery configuration for providers that support endpoint-based model listing. */
+export interface CatalogDiscoveryConfig {
+    /** Human-readable name for log messages. */
+    label: string;
+    /** Environment variables to check for API keys during catalog generation. */
+    envVars: string[];
+    /** OAuth provider for credential refresh during catalog generation. */
+    oauthProvider?: OAuthProvider;
+    /** When true, catalog discovery proceeds even without credentials. */
+    allowUnauthenticated?: boolean;
+}
+/** Unified provider descriptor used by both runtime discovery and catalog generation. */
+export interface ProviderDescriptor {
+    providerId: KnownProvider;
+    createModelManagerOptions(config: {
+        apiKey?: string;
+        baseUrl?: string;
+    }): ModelManagerOptions<Api>;
+    /** Preferred model ID when no explicit selection is made. */
+    defaultModel: string;
+    /** When true, the runtime creates a model manager even without a valid API key (e.g. ollama). */
+    allowUnauthenticated?: boolean;
+    /** When true, successful runtime discovery replaces bundled provider models instead of merging fallback-only IDs. */
+    dynamicModelsAuthoritative?: boolean;
+    /** Catalog discovery configuration. Only providers with this field participate in generate-models.ts. */
+    catalogDiscovery?: CatalogDiscoveryConfig;
+}
+/** A provider descriptor that has catalog discovery configured. */
+export type CatalogProviderDescriptor = ProviderDescriptor & {
+    catalogDiscovery: CatalogDiscoveryConfig;
+};
+/** Type guard for descriptors with catalog discovery. */
+export declare function isCatalogDescriptor(d: ProviderDescriptor): d is CatalogProviderDescriptor;
+/** Whether catalog discovery may run without provider credentials. */
+export declare function allowsUnauthenticatedCatalogDiscovery(descriptor: CatalogProviderDescriptor): boolean;
+/**
+ * All standard providers. Special providers (google-antigravity, google-gemini-cli,
+ * openai-codex) are handled separately because they require different config shapes.
+ */
+export declare const PROVIDER_DESCRIPTORS: readonly ProviderDescriptor[];
+/** Default model IDs for all known providers, built from descriptors + special providers. */
+export declare const DEFAULT_MODEL_PER_PROVIDER: Record<KnownProvider, string>;

package/dist/types/provider-models/google.d.ts

@@ -0,0 +1,24 @@
+import type { ModelManagerOptions } from "../model-manager";
+import type { FetchImpl } from "../types";
+export interface GoogleModelManagerConfig {
+    apiKey?: string;
+}
+export interface GoogleVertexModelManagerConfig {
+    apiKey?: string;
+    project?: string;
+    location?: string;
+    signal?: AbortSignal;
+    fetch?: FetchImpl;
+}
+export interface GoogleAntigravityModelManagerConfig {
+    oauthToken?: string;
+    endpoint?: string;
+}
+export interface GoogleGeminiCliModelManagerConfig {
+    oauthToken?: string;
+    endpoint?: string;
+}
+export declare function googleModelManagerOptions(config?: GoogleModelManagerConfig): ModelManagerOptions<"google-generative-ai">;
+export declare function googleVertexModelManagerOptions(_config?: GoogleVertexModelManagerConfig): ModelManagerOptions;
+export declare function googleAntigravityModelManagerOptions(config?: GoogleAntigravityModelManagerConfig): ModelManagerOptions<"google-gemini-cli">;
+export declare function googleGeminiCliModelManagerOptions(config?: GoogleGeminiCliModelManagerConfig): ModelManagerOptions<"google-gemini-cli">;

package/dist/types/provider-models/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./descriptors";
+export * from "./google";
+export * from "./ollama";
+export * from "./openai-compat";
+export * from "./special";

package/dist/types/provider-models/ollama.d.ts

@@ -0,0 +1,7 @@
+import type { ModelManagerOptions } from "../model-manager";
+export interface OllamaCloudModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function normalizeOllamaCloudBaseUrl(baseUrl?: string): string;
+export declare function ollamaCloudModelManagerOptions(config?: OllamaCloudModelManagerConfig): ModelManagerOptions<"ollama-chat">;

package/dist/types/provider-models/openai-compat.d.ts

@@ -0,0 +1,296 @@
+import type { ModelManagerOptions } from "../model-manager";
+import type { Api, Model } from "../types";
+export interface ModelsDevModel {
+    id?: string;
+    name?: string;
+    tool_call?: boolean;
+    reasoning?: boolean;
+    limit?: {
+        context?: number;
+        output?: number;
+    };
+    cost?: {
+        input?: number;
+        output?: number;
+        cache_read?: number;
+        cache_write?: number;
+    };
+    modalities?: {
+        input?: string[];
+    };
+    status?: string;
+    provider?: {
+        npm?: string;
+    };
+}
+export interface OpenAIModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function openaiModelManagerOptions(config?: OpenAIModelManagerConfig): ModelManagerOptions<"openai-responses">;
+export interface GroqModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function groqModelManagerOptions(config?: GroqModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface CerebrasModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function cerebrasModelManagerOptions(config?: CerebrasModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface HuggingfaceModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function huggingfaceModelManagerOptions(config?: HuggingfaceModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface NvidiaModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function nvidiaModelManagerOptions(config?: NvidiaModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface XaiModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function xaiModelManagerOptions(config?: XaiModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface XaiOAuthModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+interface XAICuratedModel {
+    id: string;
+    contextWindow: number;
+    name?: string;
+    /** Whether the model reasons natively. Defaults to true for Grok-4.x family. */
+    reasoning?: boolean;
+    /**
+     * Whether xAI accepts the `reasoning.effort` wire param for this model.
+     * Default true. When false: picker hides the effort dial (via
+     * getSupportedEfforts in model-thinking.ts) AND wire-side already omits
+     * the param via GROK_EFFORT_CAPABLE_PREFIXES in providers/xai-responses.ts.
+     * Must agree with that allowlist; two truths kept in sync by curated-catalog
+     * author convention until a follow-up Op: compress unifies them.
+     */
+    supportsReasoningEffort?: boolean;
+    /**
+     * Input modalities this model accepts. Defaults to `["text"]` when absent.
+     * Vision-capable Grok models MUST list `"image"` here so the curated layer
+     * overrides `fetchOpenAICompatibleModels`' default of `["text"]` (which
+     * otherwise strips image capability on every online refresh).
+     */
+    input?: ("text" | "image")[];
+}
+export declare const XAI_OAUTH_CURATED_MODELS: readonly XAICuratedModel[];
+/**
+ * Render `XAI_OAUTH_CURATED_MODELS` as full `Model<"openai-responses">` entries.
+ *
+ * Single source of truth for the curated to Model fan-in, consumed by both
+ * - {@link xaiOAuthModelManagerOptions} (runtime static seed handed to the model
+ *   manager so the picker is populated on a fresh login), and
+ * - `packages/ai/scripts/generate-models.ts` (bundles the same entries into
+ *   `models.json`, so the synchronous `ModelRegistry.#loadModels()` boot path
+ *   sees `xai-oauth` without waiting for a refresh — fixes the boot-time
+ *   default-model reset when `modelRoles.default = "xai-oauth/<id>"`).
+ *
+ * `reasoning` defaults to `true` for the Grok-4.x family; the explicit
+ * `grok-4.20-0309-non-reasoning` entry opts out via `XAICuratedModel.reasoning`.
+ * `maxTokens` uses `UNK_MAX_TOKENS` so id-keyed overlays from a successful
+ * dynamic fetch merge cleanly. Mirrors
+ * `hermes-agent/hermes_cli/models.py:_XAI_STATIC_FALLBACK`.
+ */
+export declare function buildXaiOAuthStaticSeed(baseUrl?: string): Model<"openai-responses">[];
+export declare function xaiOAuthModelManagerOptions(config?: XaiOAuthModelManagerConfig): ModelManagerOptions<"openai-responses">;
+export interface DeepSeekModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function deepseekModelManagerOptions(config?: DeepSeekModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface ZhipuCodingPlanModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function zhipuCodingPlanModelManagerOptions(config?: ZhipuCodingPlanModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface FireworksModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function fireworksModelManagerOptions(config?: FireworksModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface FirepassModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+/**
+ * Fire Pass is a Fireworks subscription product that exposes a single router
+ * model (Kimi K2.6 Turbo) under `accounts/fireworks/routers/kimi-k2p6-turbo`.
+ * The dedicated `fpk_…` keys do not authorize `/v1/models`, so this manager
+ * never performs dynamic discovery — the bundled catalog entry is canonical.
+ * See https://docs.fireworks.ai/firepass.
+ */
+export declare function firepassModelManagerOptions(_config?: FirepassModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface WaferModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function waferPassModelManagerOptions(config?: WaferModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export declare function waferServerlessModelManagerOptions(config?: WaferModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface MistralModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function mistralModelManagerOptions(config?: MistralModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface OpenCodeModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function opencodeZenModelManagerOptions(config?: OpenCodeModelManagerConfig): ModelManagerOptions<Api>;
+export declare function opencodeGoModelManagerOptions(config?: OpenCodeModelManagerConfig): ModelManagerOptions<Api>;
+export interface OllamaModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function ollamaModelManagerOptions(config?: OllamaModelManagerConfig): ModelManagerOptions<"openai-responses">;
+export interface OpenRouterModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function openrouterModelManagerOptions(config?: OpenRouterModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface ZenMuxModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function zenmuxModelManagerOptions(config?: ZenMuxModelManagerConfig): ModelManagerOptions<Api>;
+export interface KiloModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function kiloModelManagerOptions(config?: KiloModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface AlibabaCodingPlanModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function alibabaCodingPlanModelManagerOptions(config?: AlibabaCodingPlanModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface VercelAiGatewayModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function vercelAiGatewayModelManagerOptions(config?: VercelAiGatewayModelManagerConfig): ModelManagerOptions<"anthropic-messages">;
+export interface KimiCodeModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function kimiCodeModelManagerOptions(config?: KimiCodeModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface LmStudioModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function lmStudioModelManagerOptions(config?: LmStudioModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface SyntheticModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function syntheticModelManagerOptions(config?: SyntheticModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface VeniceModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function veniceModelManagerOptions(config?: VeniceModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface TogetherModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function togetherModelManagerOptions(config?: TogetherModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface MoonshotModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function moonshotModelManagerOptions(config?: MoonshotModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface QwenPortalModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function qwenPortalModelManagerOptions(config?: QwenPortalModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface QianfanModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function qianfanModelManagerOptions(config?: QianfanModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface CloudflareAiGatewayModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function cloudflareAiGatewayModelManagerOptions(config?: CloudflareAiGatewayModelManagerConfig): ModelManagerOptions<"anthropic-messages">;
+export interface XiaomiModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function xiaomiModelManagerOptions(config?: XiaomiModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface LiteLLMModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function litellmModelManagerOptions(config?: LiteLLMModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface VllmModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function vllmModelManagerOptions(config?: VllmModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface NanoGptModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function nanoGptModelManagerOptions(config?: NanoGptModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface GithubCopilotModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function githubCopilotModelManagerOptions(config?: GithubCopilotModelManagerConfig): ModelManagerOptions<Api>;
+export interface AnthropicModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function anthropicModelManagerOptions(config?: AnthropicModelManagerConfig): ModelManagerOptions<"anthropic-messages">;
+export declare const UNK_CONTEXT_WINDOW = 222222;
+export declare const UNK_MAX_TOKENS = 8888;
+/** Describes how to map models.dev API data for a single provider. */
+export interface ModelsDevProviderDescriptor {
+    /** Key in the models.dev API response JSON (e.g., "anthropic", "amazon-bedrock") */
+    modelsDevKey: string;
+    /** Provider ID in our system */
+    providerId: string;
+    /** Default API type for this provider's models */
+    api: Api;
+    /** Default base URL */
+    baseUrl: string;
+    /** Default context window fallback (default: UNKNNOWN_CONTEXT_WINDOW) */
+    defaultContextWindow?: number;
+    /** Default max tokens fallback (default: UNKNNOWN_MAX_TOKENS) */
+    defaultMaxTokens?: number;
+    /** Optional compat overrides applied to every model from this provider */
+    compat?: Model<Api>["compat"];
+    /** Optional static headers applied to every model */
+    headers?: Record<string, string>;
+    /**
+     * Optional filter: return false to skip a model.
+     * Called with (modelId, rawModel). Default: skip if tool_call !== true.
+     */
+    filterModel?: (modelId: string, model: ModelsDevModel) => boolean;
+    /**
+     * Optional transform: modify the mapped model before it's added.
+     * Can return null to skip the model, or an array to emit multiple models.
+     */
+    transformModel?: (model: Model<Api>, modelId: string, raw: ModelsDevModel) => Model<Api> | Model<Api>[] | null;
+    /**
+     * Optional: override the API type per-model.
+     * Called with (modelId, raw). Return the API type to use.
+     * If not provided, uses the `api` field.
+     */
+    resolveApi?: (modelId: string, raw: ModelsDevModel) => {
+        api: Api;
+        baseUrl: string;
+    } | null;
+}
+/** Generic mapper that converts models.dev data using provider descriptors. */
+export declare function mapModelsDevToModels(data: Record<string, unknown>, descriptors: readonly ModelsDevProviderDescriptor[]): Model<Api>[];
+/** All provider descriptors for models.dev data mapping in generate-models.ts. */
+export declare const MODELS_DEV_PROVIDER_DESCRIPTORS: readonly ModelsDevProviderDescriptor[];
+export {};