@opencode/ai 2.0.14 → 2.0.16

package/dist/promise.d.ts

@@ -0,0 +1,974 @@
+import { Effect, Layer } from "effect";
+import type { AwaitOptions, Snapshot } from "./generation.js";
+import { ImageModel, ImageRequest, type ImageOptions, type ImageRequestInput } from "./image.js";
+import { ImageClient } from "./image-client.js";
+import { LLMClient } from "./route/client.js";
+import { RequestExecutor } from "./route/executor.js";
+import { LanguageModel, LLMRequest } from "./schema/index.js";
+import type { RequestInput } from "./llm.js";
+import { SpeechModel, SpeechRequest, type SpeechRequestInput } from "./speech.js";
+import { SpeechClient } from "./speech-client.js";
+import { TranscriptionModel, TranscriptionRequest, type TranscriptionOptions, type TranscriptionRequestInput } from "./transcription.js";
+import { TranscriptionClient } from "./transcription-client.js";
+import { VideoModel, VideoRequest, type VideoOptions, type VideoRequestInput } from "./video.js";
+import { VideoClient } from "./video-client.js";
+/**
+ * Promise-first entrypoint for scripts and non-Effect callers. One `ManagedRuntime` hosts the LLM, image, video, speech,
+ * and transcription clients over a request executor; every method runs the corresponding Effect API and rethrows
+ * `AIError` unchanged.
+ */
+export interface Options {
+    /** Executor layer; defaults to `RequestExecutor.fetchLayer`. Inject a recorder or middleware here. */
+    readonly layer?: Layer.Layer<RequestExecutor.Service>;
+}
+export interface RunOptions {
+    readonly signal?: AbortSignal;
+}
+export type Services = Layer.Success<typeof LLMClient.layer> | Layer.Success<typeof ImageClient.layer> | Layer.Success<typeof VideoClient.layer> | Layer.Success<typeof SpeechClient.layer> | Layer.Success<typeof TranscriptionClient.layer> | RequestExecutor.Service;
+/** Promise view of a `Generation`: its snapshot plus `await`, `refresh`, and `cancel` returning promises. */
+export type GenerationHandle<Response> = Snapshot & {
+    /** Serializable JSON; pass it back to `resume` from another process. */
+    readonly token: unknown;
+    readonly await: (options?: AwaitOptions & RunOptions) => Promise<Response>;
+    readonly refresh: (options?: RunOptions) => Promise<GenerationHandle<Response>>;
+    readonly cancel: (options?: RunOptions) => Promise<void>;
+};
+export declare const make: (options?: Options) => {
+    run: <A, E>(effect: Effect.Effect<A, E, Services>, options?: RunOptions) => Promise<A>;
+    llm: {
+        request: <const SelectedLanguageModel extends LanguageModel>(input: RequestInput<SelectedLanguageModel>) => LLMRequest<SelectedLanguageModel>;
+        generate: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) => Promise<import("./index.js").LLMResponse>;
+        stream: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) => AsyncIterable<({
+            readonly type: "compaction";
+            readonly provider: string & import("effect/Brand").Brand<"AI.ProviderID">;
+            readonly id?: string | undefined;
+            readonly text?: string | null | undefined;
+            readonly encrypted?: string | undefined;
+        } & ({
+            readonly encrypted: string;
+            readonly text?: never;
+        } | {
+            readonly text: string | null;
+            readonly encrypted?: never;
+        })) | {
+            readonly type: "step-start";
+            readonly index: number;
+        } | {
+            readonly id: string;
+            readonly type: "text-start";
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "text-delta";
+            readonly text: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "text-end";
+            readonly text?: string | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "reasoning-start";
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "reasoning-delta";
+            readonly text: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "reasoning-end";
+            readonly text?: string | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-input-start";
+            readonly name: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+            readonly providerExecuted?: boolean | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-input-delta";
+            readonly name: string;
+            readonly text: string;
+            readonly input?: unknown;
+            readonly namespace?: string | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-input-end";
+            readonly name: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-input-error";
+            readonly name: string;
+            readonly raw: string;
+            readonly namespace?: string | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-call";
+            readonly name: string;
+            readonly input: unknown;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+            readonly providerExecuted?: boolean | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-result";
+            readonly name: string;
+            readonly result: {
+                readonly type: "json";
+                readonly value: unknown;
+            } | {
+                readonly type: "text";
+                readonly value: unknown;
+            } | {
+                readonly type: "error";
+                readonly value: unknown;
+            } | {
+                readonly type: "content";
+                readonly value: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            };
+            readonly output?: {
+                readonly structured: unknown;
+                readonly content: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            } | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+            readonly providerExecuted?: boolean | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-error";
+            readonly name: string;
+            readonly message: string;
+            readonly error?: unknown;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+        } | {
+            readonly type: "media";
+            readonly media: import("./media.js").Asset;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "step-finish";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
+            readonly index: number;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly usage?: import("./index.js").Usage | undefined;
+        } | {
+            readonly type: "finish";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly usage?: import("./index.js").Usage | undefined;
+        } | {
+            readonly type: "provider-error";
+            readonly message: string;
+            readonly classification?: "context-overflow" | "payload-too-large" | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        }>;
+    };
+    image: {
+        request: typeof import("./image.js").request;
+        generate: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: AwaitOptions & RunOptions) => Promise<import("./image.js").ImageResponse>;
+        stream: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: AwaitOptions & RunOptions) => AsyncIterable<{
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        } | {
+            readonly type: "image-partial";
+            readonly index: number;
+            readonly image: import("./media.js").Asset;
+        } | {
+            readonly type: "image";
+            readonly index: number;
+            readonly image: import("./media.js").Asset;
+        } | {
+            readonly type: "finish";
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly usage?: {
+                readonly type: "tokens";
+                readonly input?: number | undefined;
+                readonly output?: number | undefined;
+                readonly total?: number | undefined;
+                readonly details?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "seconds";
+                readonly seconds: number;
+            } | {
+                readonly type: "characters";
+                readonly characters: number;
+            } | {
+                readonly type: "credits";
+                readonly credits: number;
+            } | {
+                readonly type: "compute";
+                readonly seconds: number;
+            } | undefined;
+            readonly notices?: readonly {
+                readonly type: "other" | "moderated" | "filtered";
+                readonly message: string;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+            }[] | undefined;
+        }>;
+        start: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
+        resume: <Options extends ImageOptions>(model: ImageModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
+    };
+    video: {
+        request: typeof import("./video.js").request;
+        start: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
+        generate: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: AwaitOptions & RunOptions) => Promise<import("./video.js").VideoResponse>;
+        resume: <Options extends VideoOptions>(model: VideoModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
+        stream: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: AwaitOptions & RunOptions) => AsyncIterable<{
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        } | {
+            readonly type: "video";
+            readonly index: number;
+            readonly video: import("./media.js").Asset;
+        } | {
+            readonly type: "finish";
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly usage?: {
+                readonly type: "tokens";
+                readonly input?: number | undefined;
+                readonly output?: number | undefined;
+                readonly total?: number | undefined;
+                readonly details?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "seconds";
+                readonly seconds: number;
+            } | {
+                readonly type: "characters";
+                readonly characters: number;
+            } | {
+                readonly type: "credits";
+                readonly credits: number;
+            } | {
+                readonly type: "compute";
+                readonly seconds: number;
+            } | undefined;
+            readonly notices?: readonly {
+                readonly type: "other" | "moderated" | "filtered";
+                readonly message: string;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+            }[] | undefined;
+        }>;
+    };
+    speech: {
+        request: typeof import("./speech.js").request;
+        generate: <const Model extends SpeechModel>(input: SpeechRequestInput<Model> | SpeechRequest, options?: RunOptions) => Promise<import("./speech.js").SpeechResponse>;
+        stream: <const Model extends SpeechModel>(input: SpeechRequestInput<Model> | SpeechRequest, options?: RunOptions) => AsyncIterable<{
+            readonly type: "audio-delta";
+            readonly chunk: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly type: "timestamps";
+            readonly items: readonly {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+            }[];
+        } | {
+            readonly type: "finish";
+            readonly audio: import("./media.js").Asset;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly usage?: {
+                readonly type: "tokens";
+                readonly input?: number | undefined;
+                readonly output?: number | undefined;
+                readonly total?: number | undefined;
+                readonly details?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "seconds";
+                readonly seconds: number;
+            } | {
+                readonly type: "characters";
+                readonly characters: number;
+            } | {
+                readonly type: "credits";
+                readonly credits: number;
+            } | {
+                readonly type: "compute";
+                readonly seconds: number;
+            } | undefined;
+            readonly notices?: readonly {
+                readonly type: "other" | "moderated" | "filtered";
+                readonly message: string;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+            }[] | undefined;
+        }>;
+    };
+    transcription: {
+        request: typeof import("./transcription.js").request;
+        generate: <const Model extends TranscriptionModel>(input: TranscriptionRequestInput<Model> | TranscriptionRequest, options?: AwaitOptions & RunOptions) => Promise<import("./transcription.js").TranscriptionResponse>;
+        stream: <const Model extends TranscriptionModel>(input: TranscriptionRequestInput<Model> | TranscriptionRequest, options?: AwaitOptions & RunOptions) => AsyncIterable<{
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        } | {
+            readonly type: "text-delta";
+            readonly delta: string;
+        } | {
+            readonly type: "segment";
+            readonly segment: {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+                readonly speaker?: string | undefined;
+            };
+        } | {
+            readonly type: "finish";
+            readonly text: string;
+            readonly durationSeconds?: number | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly usage?: {
+                readonly type: "tokens";
+                readonly input?: number | undefined;
+                readonly output?: number | undefined;
+                readonly total?: number | undefined;
+                readonly details?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "seconds";
+                readonly seconds: number;
+            } | {
+                readonly type: "characters";
+                readonly characters: number;
+            } | {
+                readonly type: "credits";
+                readonly credits: number;
+            } | {
+                readonly type: "compute";
+                readonly seconds: number;
+            } | undefined;
+            readonly notices?: readonly {
+                readonly type: "other" | "moderated" | "filtered";
+                readonly message: string;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+            }[] | undefined;
+            readonly language?: string | undefined;
+            readonly segments?: readonly {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+                readonly speaker?: string | undefined;
+            }[] | undefined;
+            readonly words?: readonly {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+                readonly speaker?: string | undefined;
+                readonly confidence?: number | undefined;
+            }[] | undefined;
+        }>;
+        start: <const Model extends TranscriptionModel>(input: TranscriptionRequestInput<Model> | TranscriptionRequest, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
+        resume: <Options extends TranscriptionOptions>(model: TranscriptionModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
+    };
+    dispose: () => Promise<void>;
+};
+export type Client = ReturnType<typeof make>;
+/** Default client over `RequestExecutor.fetchLayer` for scripts; the runtime builds its layer on first use. */
+export declare const ai: {
+    run: <A, E>(effect: Effect.Effect<A, E, Services>, options?: RunOptions) => Promise<A>;
+    llm: {
+        request: <const SelectedLanguageModel extends LanguageModel>(input: RequestInput<SelectedLanguageModel>) => LLMRequest<SelectedLanguageModel>;
+        generate: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) => Promise<import("./index.js").LLMResponse>;
+        stream: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) => AsyncIterable<({
+            readonly type: "compaction";
+            readonly provider: string & import("effect/Brand").Brand<"AI.ProviderID">;
+            readonly id?: string | undefined;
+            readonly text?: string | null | undefined;
+            readonly encrypted?: string | undefined;
+        } & ({
+            readonly encrypted: string;
+            readonly text?: never;
+        } | {
+            readonly text: string | null;
+            readonly encrypted?: never;
+        })) | {
+            readonly type: "step-start";
+            readonly index: number;
+        } | {
+            readonly id: string;
+            readonly type: "text-start";
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "text-delta";
+            readonly text: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "text-end";
+            readonly text?: string | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "reasoning-start";
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "reasoning-delta";
+            readonly text: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "reasoning-end";
+            readonly text?: string | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-input-start";
+            readonly name: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+            readonly providerExecuted?: boolean | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-input-delta";
+            readonly name: string;
+            readonly text: string;
+            readonly input?: unknown;
+            readonly namespace?: string | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-input-end";
+            readonly name: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-input-error";
+            readonly name: string;
+            readonly raw: string;
+            readonly namespace?: string | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-call";
+            readonly name: string;
+            readonly input: unknown;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+            readonly providerExecuted?: boolean | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-result";
+            readonly name: string;
+            readonly result: {
+                readonly type: "json";
+                readonly value: unknown;
+            } | {
+                readonly type: "text";
+                readonly value: unknown;
+            } | {
+                readonly type: "error";
+                readonly value: unknown;
+            } | {
+                readonly type: "content";
+                readonly value: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            };
+            readonly output?: {
+                readonly structured: unknown;
+                readonly content: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            } | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+            readonly providerExecuted?: boolean | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-error";
+            readonly name: string;
+            readonly message: string;
+            readonly error?: unknown;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+        } | {
+            readonly type: "media";
+            readonly media: import("./media.js").Asset;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "step-finish";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
+            readonly index: number;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly usage?: import("./index.js").Usage | undefined;
+        } | {
+            readonly type: "finish";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly usage?: import("./index.js").Usage | undefined;
+        } | {
+            readonly type: "provider-error";
+            readonly message: string;
+            readonly classification?: "context-overflow" | "payload-too-large" | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        }>;
+    };
+    image: {
+        request: typeof import("./image.js").request;
+        generate: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: AwaitOptions & RunOptions) => Promise<import("./image.js").ImageResponse>;
+        stream: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: AwaitOptions & RunOptions) => AsyncIterable<{
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        } | {
+            readonly type: "image-partial";
+            readonly index: number;
+            readonly image: import("./media.js").Asset;
+        } | {
+            readonly type: "image";
+            readonly index: number;
+            readonly image: import("./media.js").Asset;
+        } | {
+            readonly type: "finish";
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly usage?: {
+                readonly type: "tokens";
+                readonly input?: number | undefined;
+                readonly output?: number | undefined;
+                readonly total?: number | undefined;
+                readonly details?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "seconds";
+                readonly seconds: number;
+            } | {
+                readonly type: "characters";
+                readonly characters: number;
+            } | {
+                readonly type: "credits";
+                readonly credits: number;
+            } | {
+                readonly type: "compute";
+                readonly seconds: number;
+            } | undefined;
+            readonly notices?: readonly {
+                readonly type: "other" | "moderated" | "filtered";
+                readonly message: string;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+            }[] | undefined;
+        }>;
+        start: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
+        resume: <Options extends ImageOptions>(model: ImageModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
+    };
+    video: {
+        request: typeof import("./video.js").request;
+        start: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
+        generate: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: AwaitOptions & RunOptions) => Promise<import("./video.js").VideoResponse>;
+        resume: <Options extends VideoOptions>(model: VideoModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
+        stream: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: AwaitOptions & RunOptions) => AsyncIterable<{
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        } | {
+            readonly type: "video";
+            readonly index: number;
+            readonly video: import("./media.js").Asset;
+        } | {
+            readonly type: "finish";
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly usage?: {
+                readonly type: "tokens";
+                readonly input?: number | undefined;
+                readonly output?: number | undefined;
+                readonly total?: number | undefined;
+                readonly details?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "seconds";
+                readonly seconds: number;
+            } | {
+                readonly type: "characters";
+                readonly characters: number;
+            } | {
+                readonly type: "credits";
+                readonly credits: number;
+            } | {
+                readonly type: "compute";
+                readonly seconds: number;
+            } | undefined;
+            readonly notices?: readonly {
+                readonly type: "other" | "moderated" | "filtered";
+                readonly message: string;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+            }[] | undefined;
+        }>;
+    };
+    speech: {
+        request: typeof import("./speech.js").request;
+        generate: <const Model extends SpeechModel>(input: SpeechRequestInput<Model> | SpeechRequest, options?: RunOptions) => Promise<import("./speech.js").SpeechResponse>;
+        stream: <const Model extends SpeechModel>(input: SpeechRequestInput<Model> | SpeechRequest, options?: RunOptions) => AsyncIterable<{
+            readonly type: "audio-delta";
+            readonly chunk: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly type: "timestamps";
+            readonly items: readonly {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+            }[];
+        } | {
+            readonly type: "finish";
+            readonly audio: import("./media.js").Asset;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly usage?: {
+                readonly type: "tokens";
+                readonly input?: number | undefined;
+                readonly output?: number | undefined;
+                readonly total?: number | undefined;
+                readonly details?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "seconds";
+                readonly seconds: number;
+            } | {
+                readonly type: "characters";
+                readonly characters: number;
+            } | {
+                readonly type: "credits";
+                readonly credits: number;
+            } | {
+                readonly type: "compute";
+                readonly seconds: number;
+            } | undefined;
+            readonly notices?: readonly {
+                readonly type: "other" | "moderated" | "filtered";
+                readonly message: string;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+            }[] | undefined;
+        }>;
+    };
+    transcription: {
+        request: typeof import("./transcription.js").request;
+        generate: <const Model extends TranscriptionModel>(input: TranscriptionRequestInput<Model> | TranscriptionRequest, options?: AwaitOptions & RunOptions) => Promise<import("./transcription.js").TranscriptionResponse>;
+        stream: <const Model extends TranscriptionModel>(input: TranscriptionRequestInput<Model> | TranscriptionRequest, options?: AwaitOptions & RunOptions) => AsyncIterable<{
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        } | {
+            readonly type: "text-delta";
+            readonly delta: string;
+        } | {
+            readonly type: "segment";
+            readonly segment: {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+                readonly speaker?: string | undefined;
+            };
+        } | {
+            readonly type: "finish";
+            readonly text: string;
+            readonly durationSeconds?: number | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly usage?: {
+                readonly type: "tokens";
+                readonly input?: number | undefined;
+                readonly output?: number | undefined;
+                readonly total?: number | undefined;
+                readonly details?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "seconds";
+                readonly seconds: number;
+            } | {
+                readonly type: "characters";
+                readonly characters: number;
+            } | {
+                readonly type: "credits";
+                readonly credits: number;
+            } | {
+                readonly type: "compute";
+                readonly seconds: number;
+            } | undefined;
+            readonly notices?: readonly {
+                readonly type: "other" | "moderated" | "filtered";
+                readonly message: string;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+            }[] | undefined;
+            readonly language?: string | undefined;
+            readonly segments?: readonly {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+                readonly speaker?: string | undefined;
+            }[] | undefined;
+            readonly words?: readonly {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+                readonly speaker?: string | undefined;
+                readonly confidence?: number | undefined;
+            }[] | undefined;
+        }>;
+        start: <const Model extends TranscriptionModel>(input: TranscriptionRequestInput<Model> | TranscriptionRequest, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
+        resume: <Options extends TranscriptionOptions>(model: TranscriptionModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
+    };
+    dispose: () => Promise<void>;
+};
+export * as AI from "./promise.js";