@shop-os/modelkit 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,580 @@
+import { ImageModel, experimental_generateVideo, generateText as generateText$1, LanguageModel, FlexibleSchema, InferSchema, ToolSet, Output, streamText as streamText$1, JSONValue, generateObject as generateObject$1, streamObject as streamObject$1, LanguageModelUsage } from 'ai';
+export * from 'ai';
+export { Warning as AiWarning } from 'ai';
+import { LanguageModelV3, LanguageModelV2 } from '@ai-sdk/provider';
+import { z } from 'zod';
+
+/**
+ * Canonical vocabulary shared by every adapter. Adapters translate these
+ * values to provider field names and casing; callers never do.
+ */
+
+/** The AI SDK video model spelling: a catalog id or a provider video model instance. */
+type VideoModel = Parameters<typeof experimental_generateVideo>[0]["model"];
+type AspectRatio = "1:1" | "16:9" | "9:16" | "4:3" | "3:4" | "3:2" | "2:3" | "4:5" | "5:4" | "21:9" | "9:21" | "97:30" | "adaptive";
+type ImageSize = "1K" | "2K" | "4K";
+type VideoResolution = "360p" | "480p" | "720p" | "768p" | "1080p" | "2k" | "4k";
+type ImageQuality = "auto" | "low" | "medium" | "high";
+type OutputFormat = "png" | "jpeg" | "webp";
+type MediaRef = {
+    url: string;
+} | {
+    bytes: Uint8Array;
+    mime: string;
+};
+type ModelType = "text" | "image" | "video" | "audio" | "upscale" | "bg-remove";
+type Lifecycle = "active" | "hidden" | "deprecated" | "retired";
+type AdapterId = "ai-sdk-text" | "google-image" | "openai-image" | "google-genai" | "ark" | "fal" | "replicate" | "prodia" | "higgsfield" | "xai-video";
+interface ImageRequest {
+    model: string;
+    prompt: string;
+    references?: MediaRef[];
+    aspectRatio?: AspectRatio;
+    size?: ImageSize;
+    exactSize?: string;
+    quality?: ImageQuality;
+    seed?: number;
+    count?: number;
+    outputFormat?: OutputFormat;
+}
+/**
+ * What a caller passes to generateImage. Same field names as the AI SDK's
+ * generateImage where the concept matches: `n`, `size` as `WxH`, `abortSignal`,
+ * `providerOptions`. The model is a catalog id or alias, or an AI SDK image
+ * model instance that runs through the SDK unchanged.
+ */
+interface ImageCallOptions extends Omit<ImageRequest, "model" | "size"> {
+    model: ImageModel;
+    /** Alias of `count`. */
+    n?: number;
+    /** Catalog tier or an exact `WxH` size (alias of `exactSize`). */
+    size?: ImageSize | `${number}x${number}`;
+    abortSignal?: AbortSignal;
+    /** Reaches the provider only for AI SDK model instances; catalog rows carry their own. */
+    providerOptions?: ProviderOptions;
+}
+interface VideoRequest {
+    model: string;
+    prompt: string;
+    firstFrame?: MediaRef;
+    lastFrame?: MediaRef;
+    sourceVideo?: MediaRef;
+    referenceImages?: MediaRef[];
+    referenceVideos?: MediaRef[];
+    referenceAudios?: MediaRef[];
+    aspectRatio?: AspectRatio;
+    resolution?: VideoResolution;
+    durationSeconds?: number;
+    generateAudio?: boolean;
+    seed?: number;
+    negativePrompt?: string;
+    cfgScale?: number;
+    promptExpansion?: "fast" | "balanced" | "quality";
+    mode?: "standard" | "pro";
+}
+/**
+ * What a caller passes to generateVideo. `duration` is the AI SDK spelling of
+ * `durationSeconds`. An AI SDK video model instance runs through
+ * `experimental_generateVideo` and is exposed as a settled job.
+ */
+interface VideoCallOptions extends Omit<VideoRequest, "model"> {
+    model: VideoModel;
+    /** Alias of `durationSeconds`. */
+    duration?: number;
+    abortSignal?: AbortSignal;
+    /** Reaches the provider only for AI SDK model instances; catalog rows carry their own. */
+    providerOptions?: ProviderOptions;
+}
+interface AudioRequest {
+    model: string;
+    prompt: string;
+    /** Lyria: optional reference image. MMAudio: the video to score. */
+    references?: MediaRef[];
+    sourceVideo?: MediaRef;
+    negativePrompt?: string;
+    durationSeconds?: number;
+    seed?: number;
+    /** Music models: no vocals. */
+    instrumental?: boolean;
+}
+interface AudioResult {
+    audio: {
+        bytes: Uint8Array;
+        mime: string;
+    } | {
+        url: string;
+        expiresAt?: Date;
+    };
+    /** Lyria returns lyrics as text parts next to the audio. */
+    text?: string;
+    usage: UsageEvent;
+    raw?: JsonValue;
+}
+/** An AI SDK file part ready for generateText/generateObject, e.g. a video for understanding. */
+interface MediaPart {
+    type: "file";
+    data: string | Uint8Array;
+    mediaType: string;
+    /** Set when the bytes were uploaded to a provider file store (Gemini Files API). Call `cleanup` after the request. */
+    cleanup?: () => Promise<void>;
+}
+type RequiredInput = "firstFrame" | "sourceVideo" | "references";
+type SupportedOption = "seed" | "quality" | "negativePrompt" | "cfgScale" | "generateAudio" | "promptExpansion" | "lastFrame" | "count" | "outputFormat" | "instrumental";
+interface ReferenceLimits {
+    images?: number;
+    videos?: number;
+    audios?: number;
+    total?: number;
+    /** Provider rejects a request whose only references are audio. */
+    audioOnly?: boolean;
+}
+interface ModelConstraints {
+    aspectRatios?: AspectRatio[];
+    sizes?: ImageSize[];
+    resolutions?: VideoResolution[];
+    durations?: {
+        min: number;
+        max: number;
+    } | number[];
+    references?: ReferenceLimits;
+    requires?: RequiredInput[];
+    supports?: SupportedOption[];
+    /** Ratio is dropped, with a warning, when one of these inputs is present. */
+    ratioIgnoredWith?: ("firstFrame" | "sourceVideo")[];
+}
+/** JSON-compatible value. Provider options and raw payloads carry these, never `unknown`. */
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+/**
+ * Options handed to the provider untouched, keyed by provider name like the AI SDK's
+ * providerOptions: { anthropic: { thinking: ... } }. Values are JSON without null.
+ */
+type ProviderOptionValue = string | number | boolean | ProviderOptionValue[] | {
+    [key: string]: ProviderOptionValue;
+};
+type ProviderOptions = {
+    [provider: string]: {
+        [key: string]: ProviderOptionValue;
+    };
+};
+type UsageUnit = "tokens" | "images" | "seconds" | "reported_cost_usd" | "compute_seconds";
+type UsageModality = "TEXT" | "IMAGE" | "VIDEO" | "AUDIO";
+type PricingKind = "token" | "image_size" | "video_per_second" | "flat";
+interface CatalogModel {
+    /** Canonical id. Equals the pricing key in pro-backend credit_pricing_* tables. */
+    id: string;
+    aliases: string[];
+    label: string;
+    type: ModelType;
+    adapter: AdapterId;
+    /** Id the provider expects, e.g. dola-seedream-5-0-pro-260628. */
+    providerModelId: string;
+    lifecycle: Lifecycle;
+    replacedBy?: string;
+    constraints: ModelConstraints;
+    defaults: Partial<Omit<ImageRequest, "model" | "prompt"> & Omit<VideoRequest, "model" | "prompt"> & Omit<AudioRequest, "model" | "prompt">>;
+    providerOptions?: ProviderOptions;
+    usage: {
+        unit: UsageUnit;
+        modality: UsageModality;
+    };
+    pricingKind: PricingKind;
+}
+interface Warning {
+    code: "ratio_coerced" | "ratio_dropped" | "size_coerced" | "resolution_coerced" | "duration_coerced" | "references_trimmed" | "option_ignored";
+    message: string;
+    field: string;
+    from?: unknown;
+    to?: unknown;
+}
+interface ImageBytes {
+    bytes: Uint8Array;
+    mime: string;
+}
+/** An image with the AI SDK `GeneratedFile` accessors next to the kit's `bytes`/`mime`. */
+interface GeneratedImage extends ImageBytes {
+    readonly uint8Array: Uint8Array;
+    readonly base64: string;
+    readonly mediaType: string;
+}
+/** What an adapter returns. */
+interface ImageResult {
+    images: ImageBytes[];
+    usage: UsageEvent;
+    raw?: unknown;
+}
+/** What generateImage returns: the adapter result plus `image`, SDK accessors and warnings. */
+interface ImageCallResult extends ImageResult {
+    image: GeneratedImage;
+    images: GeneratedImage[];
+    warnings: Warning[];
+}
+interface VideoResult {
+    video: {
+        url: string;
+        expiresAt?: Date;
+    } | {
+        bytes: Uint8Array;
+        mime: string;
+    };
+    usage: UsageEvent;
+    raw?: unknown;
+}
+interface VideoCallJob extends VideoJob {
+    warnings: Warning[];
+}
+interface VideoJob {
+    jobId: string;
+    poll(): Promise<{
+        status: "pending" | "running" | "succeeded" | "failed";
+        raw?: unknown;
+    }>;
+    result(opts?: {
+        pollIntervalMs?: number;
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<VideoResult>;
+}
+interface UsageEvent {
+    /** Canonical catalog id, never the provider id. */
+    model: string;
+    provider: string;
+    modality: UsageModality;
+    unit: UsageUnit;
+    quantity: number;
+    imageSize?: ImageSize;
+    imageQuality?: ImageQuality;
+    resolution?: VideoResolution;
+    durationSeconds?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    reportedCostUsd?: number;
+    raw?: unknown;
+}
+type ProviderKeyName = "openai" | "anthropic" | "google" | "xai" | "perplexity" | "deepseek" | "moonshot" | "minimax" | "ark" | "fal" | "replicate" | "prodia" | "higgsfield" | "openrouter" | "cloudflare";
+type ProviderKeys = Partial<Record<ProviderKeyName, string>> & {
+    /** Higgsfield needs the pair; both switch together. */
+    higgsfieldSecret?: string;
+    /** Bedrock runtime credentials for Anthropic models when routing.anthropic = "bedrock". */
+    aws?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        region: string;
+        sessionToken?: string;
+    };
+};
+interface Routing {
+    /** Text models: direct provider, Cloudflare AI Gateway, or OpenRouter. */
+    text?: "direct" | "cloudflare" | "openrouter";
+    /** Anthropic chat via Bedrock (us. prefixed ids) or the Anthropic API. */
+    anthropic?: "direct" | "bedrock";
+    /** fal from geo-blocked regions goes through the Cloudflare passthrough. */
+    fal?: "direct" | "cloudflare-passthrough";
+    cloudflare?: {
+        accountId: string;
+        gatewayId: string;
+    };
+}
+interface ModelKitConfig {
+    keys: {
+        pro: ProviderKeys;
+        enterprise?: ProviderKeys;
+    };
+    routing?: Routing;
+    /** Called once per completed provider call. */
+    onUsage?: (event: UsageEvent) => void | Promise<void>;
+    /** Extra or replacement catalog rows, merged by id. */
+    catalogOverride?: CatalogModel[];
+    fetch?: typeof fetch;
+    logger?: Pick<Console, "debug" | "info" | "warn" | "error">;
+}
+interface CallContext {
+    /** "enterprise" picks keys.enterprise when every key for the provider is set, else falls back to pro. */
+    tier?: "pro" | "enterprise";
+    signal?: AbortSignal;
+    /** Seedance: input urls that are verified assets and may contain human faces. */
+    verifiedAssetUrls?: string[];
+    /** Space Builder: center-crop the image to the requested ratio after generation. */
+    postCropToAspect?: boolean;
+    onUnsupported?: "error" | "coerce";
+}
+
+/** Provider body or the lifted detail (Gemini blockReason, fal body.detail). */
+type ProviderErrorBody = string | JsonValue;
+type ModelKitErrorCode = "unknown_model" | "unsupported_option" | "missing_input" | "content_blocked" | "provider_rejected" | "timeout" | "auth" | "network" | "rate_limited";
+interface ModelKitErrorInit {
+    code: ModelKitErrorCode;
+    message: string;
+    provider?: string;
+    model?: string;
+    status?: number;
+    body?: ProviderErrorBody;
+    cause?: unknown;
+    retryable?: boolean;
+}
+declare class ModelKitError extends Error {
+    readonly code: ModelKitErrorCode;
+    readonly provider: string | undefined;
+    readonly model: string | undefined;
+    readonly status: number | undefined;
+    readonly body: ProviderErrorBody | undefined;
+    readonly retryable: boolean;
+    constructor(init: ModelKitErrorInit);
+}
+declare function isModelKitError(err: unknown): err is ModelKitError;
+
+declare class Catalog {
+    private readonly byId;
+    private readonly byAlias;
+    constructor(models: CatalogModel[]);
+    add(model: CatalogModel): void;
+    /** Resolves a canonical id or any historical alias. */
+    resolveId(idOrAlias: string): string | undefined;
+    get(idOrAlias: string): CatalogModel | undefined;
+    require(idOrAlias: string): CatalogModel;
+    list(filter?: {
+        type?: ModelType;
+        lifecycle?: Lifecycle[];
+    }): CatalogModel[];
+    /** Merge rows by id. Used for catalogOverride. */
+    withOverrides(rows: CatalogModel[]): Catalog;
+}
+
+/** Seeded from Cowork, Space Builder and trigger-workflows. See catalog/*.ts. */
+declare const MODELS: CatalogModel[];
+
+type OnUnsupported = "error" | "coerce";
+interface ResolveResult<T> {
+    request: T;
+    warnings: Warning[];
+}
+/** Nearest supported ratio in the same orientation bucket, else nearest overall, by log distance. */
+declare function nearestAspectRatio(requested: AspectRatio, supported: AspectRatio[]): AspectRatio;
+declare function resolveImageOptions(model: CatalogModel, request: ImageRequest, onUnsupported?: OnUnsupported): ResolveResult<ImageRequest>;
+declare function resolveVideoOptions(model: CatalogModel, request: VideoRequest, onUnsupported?: OnUnsupported): ResolveResult<VideoRequest>;
+
+/** Which key names an adapter needs. All of them must be set on a tier for that tier to win. */
+declare const ADAPTER_KEYS: Record<AdapterId, ProviderKeyName[]>;
+/**
+ * Enterprise wins only when every key the adapter needs is set on the
+ * enterprise tier; otherwise the pro keys are used. Mirrors trigger-workflows
+ * enterprise-keys.ts, extended to Ark and Prodia.
+ */
+declare function resolveKeys(config: ModelKitConfig, names: ProviderKeyName[], tier?: "pro" | "enterprise"): ProviderKeys;
+/** Build a ProviderKeys map from env with the given prefix ("" for pro, "ENTERPRISE_" for enterprise). */
+declare function keysFromEnv(env: NodeJS.ProcessEnv, prefix?: string): ProviderKeys;
+
+/**
+ * One classifier for every adapter. Never retry safety blocks,
+ * content_policy_violation, or 4xx other than 429. Retry 429, 5xx, timeouts
+ * and network failures. Adapters must not stack their own retry loop on top.
+ */
+declare function classifyHttpError(status: number | undefined, body: ProviderErrorBody, provider: string, model?: string): ModelKitError;
+declare function shouldRetry(err: Error): boolean;
+interface RetryOptions {
+    attempts?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    factor?: number;
+    signal?: AbortSignal;
+}
+declare function withRetry<T>(fn: (attempt: number) => Promise<T>, opts?: RetryOptions): Promise<T>;
+declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
+/** Poll until `check` returns a value. Throws timeout after `timeoutMs`. */
+declare function pollUntil<T>(check: () => Promise<T | undefined>, opts: {
+    intervalMs: number;
+    timeoutMs: number;
+    signal?: AbortSignal;
+    backoff?: number;
+    maxIntervalMs?: number;
+}): Promise<T>;
+
+/** Everything an adapter needs for one call. Resolved by the core before dispatch. */
+interface AdapterContext {
+    model: CatalogModel;
+    keys: ProviderKeys;
+    routing: Routing;
+    fetch: typeof fetch;
+    logger: Pick<Console, "debug" | "info" | "warn" | "error">;
+    signal?: AbortSignal;
+    call: CallContext;
+    warnings: Warning[];
+}
+/**
+ * One adapter per provider API. The request the adapter receives has already
+ * passed resolveOptions: every option is inside the catalog constraints and the
+ * catalog defaults are filled in.
+ */
+interface Adapter {
+    id: string;
+    generateImage?(req: ImageRequest, ctx: AdapterContext): Promise<ImageResult>;
+    generateVideo?(req: VideoRequest, ctx: AdapterContext): Promise<VideoJob>;
+    generateAudio?(req: AudioRequest, ctx: AdapterContext): Promise<AudioResult>;
+    /**
+     * Turn a media reference into an AI SDK file part the provider's language
+     * model accepts. Google uploads large videos through the Files API.
+     */
+    prepareMediaPart?(ref: MediaRef, mediaType: string, ctx: AdapterContext): Promise<MediaPart>;
+    /** Text: return an AI SDK LanguageModel for streamText / generateText. */
+    languageModel?(ctx: AdapterContext): LanguageModelV3;
+}
+
+/**
+ * The AI SDK `LanguageModel` type. A string is a catalog id or alias; a provider
+ * instance (`openai("gpt-4o")`) runs through the SDK unchanged, with usage
+ * attributed to its own provider and model id.
+ */
+type CatalogTextModel = LanguageModel;
+/** A provider instance the caller built; anything that is not a catalog id string. */
+type TextModelInstance = LanguageModelV3 | LanguageModelV2;
+type WithCatalogModel<T> = {
+    [K in keyof T]: K extends "model" ? CatalogTextModel : T[K];
+};
+type DistributiveOmit<T, K extends PropertyKey> = T extends T ? Omit<T, K> : never;
+type ObjectMode<SCHEMA extends FlexibleSchema, OUTPUT extends ObjectOutput, RESULT> = (OUTPUT extends "enum" ? {
+    enum: Array<RESULT>;
+    output: "enum";
+} : OUTPUT extends "no-schema" ? {} : {
+    schema: SCHEMA;
+    schemaName?: string;
+    schemaDescription?: string;
+}) & {
+    output?: OUTPUT;
+    model: CatalogTextModel;
+};
+type ObjectOutput = "object" | "array" | "enum" | "no-schema";
+type DefaultObjectOutput<S extends FlexibleSchema> = InferSchema<S> extends string ? "enum" : "object";
+type ObjectResult<S extends FlexibleSchema, O extends ObjectOutput> = O extends "array" ? Array<InferSchema<S>> : InferSchema<S>;
+type ModelkitGenerateTextOptions<TOOLS extends ToolSet, OUTPUT extends Output.Output = Output.Output<string, string>> = WithCatalogModel<Parameters<typeof generateText$1<TOOLS, OUTPUT>>[0]>;
+type ModelkitStreamTextOptions<TOOLS extends ToolSet, OUTPUT extends Output.Output = Output.Output<string, string, never>> = WithCatalogModel<Parameters<typeof streamText$1<TOOLS, OUTPUT>>[0]>;
+type ModelkitGenerateObjectOptions<SCHEMA extends FlexibleSchema = FlexibleSchema<JSONValue>, OUTPUT extends ObjectOutput = DefaultObjectOutput<SCHEMA>, RESULT = ObjectResult<SCHEMA, OUTPUT>> = DistributiveOmit<Parameters<typeof generateObject$1<SCHEMA, "no-schema", RESULT>>[0], "model" | "output"> & ObjectMode<SCHEMA, OUTPUT, RESULT>;
+type ModelkitStreamObjectOptions<SCHEMA extends FlexibleSchema = FlexibleSchema<JSONValue>, OUTPUT extends ObjectOutput = DefaultObjectOutput<SCHEMA>, RESULT = ObjectResult<SCHEMA, OUTPUT>> = DistributiveOmit<Parameters<typeof streamObject$1<SCHEMA, "no-schema", RESULT>>[0], "model" | "output"> & ObjectMode<SCHEMA, OUTPUT, RESULT>;
+interface TextMethods {
+    generateText<TOOLS extends ToolSet, OUTPUT extends Output.Output = Output.Output<string, string>>(options: ModelkitGenerateTextOptions<TOOLS, OUTPUT>, call?: CallContext): ReturnType<typeof generateText$1<TOOLS, OUTPUT>>;
+    streamText<TOOLS extends ToolSet, OUTPUT extends Output.Output = Output.Output<string, string, never>>(options: ModelkitStreamTextOptions<TOOLS, OUTPUT>, call?: CallContext): ReturnType<typeof streamText$1<TOOLS, OUTPUT>>;
+    generateObject<SCHEMA extends FlexibleSchema = FlexibleSchema<JSONValue>, OUTPUT extends ObjectOutput = DefaultObjectOutput<SCHEMA>, RESULT = ObjectResult<SCHEMA, OUTPUT>>(options: ModelkitGenerateObjectOptions<SCHEMA, OUTPUT, RESULT>, call?: CallContext): ReturnType<typeof generateObject$1<SCHEMA, OUTPUT, RESULT>>;
+    streamObject<SCHEMA extends FlexibleSchema = FlexibleSchema<JSONValue>, OUTPUT extends ObjectOutput = DefaultObjectOutput<SCHEMA>, RESULT = ObjectResult<SCHEMA, OUTPUT>>(options: ModelkitStreamObjectOptions<SCHEMA, OUTPUT, RESULT>, call?: CallContext): ReturnType<typeof streamObject$1<SCHEMA, OUTPUT, RESULT>>;
+}
+type AiTextProviderOptions = NonNullable<Parameters<typeof generateText$1>[0]["providerOptions"]>;
+/**
+ * Merge catalog providerOptions under caller providerOptions. The catalog
+ * `modelkit` routing hint never reaches the provider. Per-provider objects
+ * merge shallowly so a caller can override one key without dropping the rest.
+ */
+declare function mergeTextProviderOptions(catalog: CatalogModel, caller: AiTextProviderOptions | undefined): AiTextProviderOptions;
+/**
+ * A catalog row standing in for a provider instance the caller passed as `model`.
+ * It has no aliases, defaults or providerOptions; usage carries the SDK model id.
+ */
+declare function passthroughTextModel(model: TextModelInstance): CatalogModel;
+/** Canonical token usage for a completed text call. Quantity is total tokens. */
+declare function textUsageEvent(model: CatalogModel, provider: string, usage: LanguageModelUsage): UsageEvent;
+
+interface ModelKit extends TextMethods {
+    catalog: Catalog;
+    /**
+     * Generate one or more images. Blocks until the provider returns bytes.
+     * `model` is a catalog id or an AI SDK image model instance.
+     */
+    generateImage(req: ImageCallOptions, call?: CallContext): Promise<ImageCallResult>;
+    /**
+     * Submit a video job. Await `job.result()` for the final asset.
+     * `model` is a catalog id or an AI SDK video model instance.
+     */
+    generateVideo(req: VideoCallOptions, call?: CallContext): Promise<VideoCallJob>;
+    /** AI SDK LanguageModel for chat models. Pair with the catalog's providerOptions. */
+    languageModel(modelId: string, call?: CallContext): LanguageModelHandle;
+    /** Generate music or a soundtrack. Blocks until the provider returns audio. */
+    generateAudio(req: AudioRequest, call?: CallContext): Promise<AudioResult>;
+    /**
+     * Prepare a video or document for a language model call (video understanding).
+     * Uses the provider file store when the payload is too large to inline.
+     */
+    prepareMediaPart(modelId: string, ref: MediaRef, mediaType: string, call?: CallContext): Promise<MediaPart>;
+    /** Which options a caller may show for this model. */
+    describe(modelId: string): CatalogModel;
+}
+interface LanguageModelHandle {
+    model: LanguageModelV3;
+    providerOptions: ProviderOptions;
+    catalog: CatalogModel;
+}
+type AdapterRegistry = Partial<Record<AdapterId, Adapter>>;
+declare function createModelKit(config: ModelKitConfig, adapters: AdapterRegistry): ModelKit;
+
+declare const aiSdkTextAdapter: Adapter;
+
+declare const arkAdapter: Adapter;
+
+declare const falAdapter: Adapter;
+
+declare const googleGenaiAdapter: Adapter;
+
+declare const googleImageAdapter: Adapter;
+
+declare const higgsfieldAdapter: Adapter;
+
+/**
+ * Vibe's aspect_ratio + image_size tier to a WIDTHxHEIGHT string for
+ * gpt-image-2. All tiers honor the true aspect ratio; the tier only sets the
+ * target long edge (1K->1024, 2K->2048, 4K->3840). gpt-image-2 hard constraints
+ * (see OpenAI docs - "Size and quality options"):
+ *   - both edges divisible by 16
+ *   - max edge <= 3840
+ *   - long:short ratio <= 3:1 (all mapped ratios already satisfy this)
+ *   - total pixels between 655,360 and 8,294,400
+ * We scale UP to clear the pixel floor (a literal 16:9 @ 1024 long edge is only
+ * 589,824 px, below the minimum) and DOWN to clear the ceiling.
+ */
+declare function aspectRatioToSize(ratio: string, tier: ImageSize): string;
+declare const openaiImageAdapter: Adapter;
+
+declare const prodiaAdapter: Adapter;
+
+declare const replicateAdapter: Adapter;
+
+declare const xaiVideoAdapter: Adapter;
+
+declare const DEFAULT_ADAPTERS: AdapterRegistry;
+
+/**
+ * All adapters registered. Keys default to process.env (pro = bare names,
+ * enterprise = ENTERPRISE_ prefix) when `keys` is omitted.
+ */
+declare function createDefaultModelKit(config?: Partial<ModelKitConfig>): ModelKit;
+/**
+ * Environment-backed calls with the `ai` function names and shapes. Use a configured
+ * kit for routing, tier keys, or a usage sink.
+ */
+declare const generateText: ModelKit["generateText"];
+declare const streamText: ModelKit["streamText"];
+declare const generateObject: ModelKit["generateObject"];
+declare const streamObject: ModelKit["streamObject"];
+declare const generateImage: ModelKit["generateImage"];
+declare const generateVideo: ModelKit["generateVideo"];
+declare const generateAudio: ModelKit["generateAudio"];
+declare const prepareMediaPart: ModelKit["prepareMediaPart"];
+declare const languageModel: ModelKit["languageModel"];
+declare const describe: ModelKit["describe"];
+
+/** Decodes any provider payload into JsonValue at the I/O boundary. Non-JSON input becomes null. */
+declare const JsonValueSchema: z.ZodType<JsonValue>;
+declare const JsonObjectSchema: z.ZodType<JsonObject>;
+/** Body text of a failed response, decoded to JSON when possible. */
+declare function readErrorBody(res: Response): Promise<JsonValue>;
+interface ThrownErrorInfo {
+    message: string;
+    status: number | undefined;
+    body: JsonValue;
+}
+declare function describeThrown(cause: unknown): ThrownErrorInfo;
+
+/** Add the AI SDK `GeneratedFile` accessors to adapter image bytes. base64 is computed on first read. */
+declare function toGeneratedImage(image: ImageBytes): GeneratedImage;
+
+export { ADAPTER_KEYS, type Adapter, type AdapterContext, type AdapterId, type AdapterRegistry, type AiTextProviderOptions, type AspectRatio, type AudioRequest, type AudioResult, type CallContext, Catalog, type CatalogModel, type CatalogTextModel, DEFAULT_ADAPTERS, type DefaultObjectOutput, type GeneratedImage, type ImageBytes, type ImageCallOptions, type ImageCallResult, type ImageQuality, type ImageRequest, type ImageResult, type ImageSize, type JsonObject, JsonObjectSchema, type JsonPrimitive, type JsonValue, JsonValueSchema, type LanguageModelHandle, type Lifecycle, MODELS, type MediaPart, type MediaRef, type ModelConstraints, type ModelKit, type ModelKitConfig, ModelKitError, type ModelKitErrorCode, type ModelKitErrorInit, type ModelType, type ModelkitGenerateObjectOptions, type ModelkitGenerateTextOptions, type ModelkitStreamObjectOptions, type ModelkitStreamTextOptions, type ObjectOutput, type ObjectResult, type OnUnsupported, type OutputFormat, type PricingKind, type ProviderErrorBody, type ProviderKeyName, type ProviderKeys, type ProviderOptionValue, type ProviderOptions, type ReferenceLimits, type RequiredInput, type ResolveResult, type Routing, type SupportedOption, type TextMethods, type TextModelInstance, type UsageEvent, type UsageModality, type UsageUnit, type VideoCallJob, type VideoCallOptions, type VideoJob, type VideoModel, type VideoRequest, type VideoResolution, type VideoResult, type Warning, aiSdkTextAdapter, arkAdapter, aspectRatioToSize, classifyHttpError, createDefaultModelKit, createModelKit, describe, describeThrown, generateImage as experimental_generateImage, falAdapter, generateAudio, generateImage, generateObject, generateText, generateVideo, googleGenaiAdapter, googleImageAdapter, higgsfieldAdapter, isModelKitError, keysFromEnv, languageModel, mergeTextProviderOptions, nearestAspectRatio, openaiImageAdapter, passthroughTextModel, pollUntil, prepareMediaPart, prodiaAdapter, readErrorBody, replicateAdapter, resolveImageOptions, resolveKeys, resolveVideoOptions, shouldRetry, sleep, streamObject, streamText, textUsageEvent, toGeneratedImage, withRetry, xaiVideoAdapter };