@opencode/ai 0.0.0-dev-21801 → 0.0.0-dev-21803

package/dist/index.d.ts

@@ -1,39 +1,1030 @@
-export { AIClient } from "./ai-client.js";
-export { LLMClient } from "./route/client.js";
-export { ImageClient } from "./image-client.js";
-export { Auth } from "./route/auth.js";
-export { Provider } from "./provider.js";
-export { ProviderPackage } from "./provider-package.js";
-export { isContextOverflow, isContextOverflowFailure, isRetryable } from "./provider-error.js";
-export type { RouteLanguageModelInput, RouteRoutedLanguageModelInput, Interface as LLMClientShape, LLMClientService, } from "./route/client.js";
-export * from "./schema/index.js";
-export { ImageAspectRatio, ImageEvent, ImageModel, ImageModelSchema, ImageRequest, ImageResponse } from "./image.js";
-export type { ImageModelOptions, ImageOptions, ImageRequestFor, ImageRequestInput, ImageResolution, ImageRoute, } from "./image.js";
-export { Image } from "./image.js";
-export { VideoClient } from "./video-client.js";
-export { VideoAspectRatio, VideoEvent, VideoFrames, VideoModel, VideoModelSchema, VideoRequest, VideoResponse, } from "./video.js";
-export type { VideoModelOptions, VideoOptions, VideoRequestFor, VideoRequestInput, VideoResolution, VideoRoute, } from "./video.js";
-export { Video } from "./video.js";
-export { SpeechClient } from "./speech-client.js";
-export { SpeechEvent, SpeechModel, SpeechModelSchema, SpeechRequest, SpeechResponse, SpeechTimestamp, SpeechVoice, } from "./speech.js";
-export type { SpeechFormat, SpeechModelOptions, SpeechOptions, SpeechRequestFor, SpeechRequestInput, SpeechRoute, } from "./speech.js";
-export { Speech } from "./speech.js";
-export { TranscriptionClient } from "./transcription-client.js";
-export { TranscriptionEvent, TranscriptionModel, TranscriptionModelSchema, TranscriptionRequest, TranscriptionResponse, TranscriptionSegment, TranscriptionTimestamps, TranscriptionWord, } from "./transcription.js";
-export type { TranscriptionModelOptions, TranscriptionOptions, TranscriptionRequestFor, TranscriptionRequestInput, TranscriptionRoute, } from "./transcription.js";
-export { Transcription } from "./transcription.js";
-export { DecisionClient } from "./decision-client.js";
-export { ChoiceAnswer, ChoiceQuestion, ChoiceValue, DecisionAnswer, DecisionJsonPart, DecisionMediaPart, DecisionModel, DecisionModelCompatibility, DecisionModelSchema, DecisionPart, DecisionQuestion, DecisionRequest, DecisionResponse, DecisionTextPart, ErrorAnswer, PredicateAnswer, PredicateQuestion, ScoreAnswer, ScoreQuestion, } from "./decision.js";
-export type { AnswerFor, AnswersFor, DecisionInput, DecisionModelOptions, DecisionOptions, DecisionQuestions, DecisionRequestFor, DecisionRequestInput, DecisionResponseFor, DecisionModelRoute, } from "./decision.js";
-export { Decision } from "./decision.js";
-export { DecisionRoute } from "./route/decision.js";
-export { Media } from "./media.js";
-export { Generation } from "./generation.js";
-export type { AwaitOptions as GenerationAwaitOptions, Event as GenerationEvent, Poll, Route as GenerationRoute, Snapshot as GenerationSnapshot, Status as GenerationStatus, } from "./generation.js";
-export { Tool, ToolFailure, toDefinitions } from "./tool.js";
-export { ToolRuntime } from "./tool-runtime.js";
-export type { DispatchResult as ToolDispatchResult, ToolSettlement } from "./tool-runtime.js";
-export type { AnyExecutableTool, AnyTool, ExecutableTool, ExecutableTools, Definition as ToolShape, ToolExecute, ToolExecuteContext, ToolModelOutputInput, Tools, ToolSchema, ToolToModelOutput, } from "./tool.js";
-export * as LLM from "./llm.js";
-export type { Definition as ProviderDefinition, LanguageModelFactory as ProviderLanguageModelFactory, LanguageModelOptions as ProviderLanguageModelOptions, } from "./provider.js";
-export type { Definition as ProviderPackageDefinition, Settings as ProviderPackageSettings, } from "./provider-package.js";
+import { Effect, Layer } from "effect";
+import { AIClient } from "./ai-client.js";
+import { type DecisionModel, type DecisionQuestions, type DecisionRequestInput } from "./decision.js";
+import type { AwaitOptions, Event, Snapshot } from "./generation.js";
+import { type ImageModel, type ImageRequest, type ImageRequestInput } from "./image.js";
+import { LLM } from "./effect.js";
+import { Media } from "./media.js";
+import { RequestExecutor } from "./route/executor.js";
+import { LanguageModel, type LLMRequest } from "./schema/index.js";
+import type { RequestInput } from "./llm.js";
+import { type SpeechModel, type SpeechRequest, type SpeechRequestInput } from "./speech.js";
+import { type TranscriptionModel, type TranscriptionRequest, type TranscriptionRequestInput } from "./transcription.js";
+import { type VideoModel, type VideoRequest, type VideoRequestInput } from "./video.js";
+/**
+ * Promise-first entrypoint for scripts and non-Effect callers. One `ManagedRuntime` hosts the LLM, image, video, speech,
+ * transcription and decision clients over a request executor; every method runs the corresponding Effect API and rethrows
+ * `AIError` unchanged. `file` and `write` load `node:fs/promises` on first use, so importing this module does not.
+ */
+export interface Options {
+    /** Executor layer; defaults to `RequestExecutor.fetchLayer`. Inject a recorder or `RequestExecutor.middleware(fn)` here. */
+    readonly layer?: Layer.Layer<RequestExecutor.Service>;
+}
+export interface RunOptions {
+    readonly signal?: AbortSignal;
+}
+export type Services = AIClient.Services;
+/**
+ * Promise view of a `Generation`. Its fields are a snapshot taken when the handle was created; `refresh()` resolves to a
+ * new handle rather than updating this one.
+ */
+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>;
+    /** Status observations until the first terminal one, polling like `await`; abort throws `signal.reason`. */
+    readonly events: (options?: AwaitOptions & RunOptions) => AsyncIterable<Event>;
+    /** The result without polling; fails when the generation has not completed. */
+    readonly result: (options?: 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>;
+    /** Decoded asset bytes, downloading `url` sources through the executor. */
+    bytes: (asset: Media.Asset, options?: RunOptions) => Promise<Uint8Array<ArrayBufferLike>>;
+    base64: (asset: Media.Asset, options?: RunOptions) => Promise<string>;
+    /** Pull a `url` asset into owned bytes before the provider URL expires. */
+    materialize: (asset: Media.Asset, options?: RunOptions) => Promise<Media.Asset>;
+    /** Read a file into an asset like `Media.file`: sniffed media type, then the extension's. */
+    file: (path: string, options?: Media.AssetOptions & RunOptions) => Promise<Media.Asset>;
+    /** Write an asset's bytes like `Media.write`, downloading `url` sources through the executor. */
+    write: (asset: Media.Asset, path: string, options?: RunOptions) => Promise<void>;
+    llm: {
+        request: typeof LLM.request;
+        generate: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) => Promise<import("./effect.js").LLMResponse>;
+        stream: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) => AsyncIterable<{
+            readonly type: "step-start";
+            readonly index: number;
+        } | {
+            readonly type: "text-start";
+            readonly id: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "text-delta";
+            readonly id: string;
+            readonly text: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "text-end";
+            readonly id: string;
+            readonly text?: string | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "reasoning-start";
+            readonly id: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "reasoning-delta";
+            readonly id: string;
+            readonly text: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "reasoning-end";
+            readonly id: string;
+            readonly text?: string | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "tool-input-start";
+            readonly id: string;
+            readonly name: string;
+            readonly namespace?: string | undefined;
+            readonly providerExecuted?: boolean | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "tool-input-delta";
+            readonly id: string;
+            readonly name: string;
+            readonly namespace?: string | undefined;
+            readonly text: string;
+            readonly input?: unknown;
+        } | {
+            readonly type: "tool-input-end";
+            readonly id: string;
+            readonly name: string;
+            readonly namespace?: string | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "tool-input-error";
+            readonly id: string;
+            readonly name: string;
+            readonly namespace?: string | undefined;
+            readonly raw: string;
+        } | {
+            readonly type: "tool-call";
+            readonly id: string;
+            readonly name: string;
+            readonly namespace?: string | undefined;
+            readonly input: unknown;
+            readonly providerExecuted?: boolean | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "tool-result";
+            readonly id: string;
+            readonly name: string;
+            readonly namespace?: string | undefined;
+            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 providerExecuted?: boolean | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "tool-error";
+            readonly id: string;
+            readonly name: string;
+            readonly namespace?: string | undefined;
+            readonly message: string;
+            readonly error?: unknown;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "step-finish";
+            readonly index: number;
+            readonly reason: {
+                readonly normalized: "content-filter" | "error" | "length" | "stop" | "tool-calls" | "unknown";
+                readonly raw?: string | undefined;
+                readonly category?: string | undefined;
+                readonly explanation?: string | undefined;
+            };
+            readonly usage?: import("./effect.js").Usage | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "finish";
+            readonly reason: {
+                readonly normalized: "content-filter" | "error" | "length" | "stop" | "tool-calls" | "unknown";
+                readonly raw?: string | undefined;
+                readonly category?: string | undefined;
+                readonly explanation?: string | undefined;
+            };
+            readonly usage?: import("./effect.js").Usage | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "media";
+            readonly media: Media.Asset;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | 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;
+        } | ({
+            readonly type: "compaction";
+            readonly provider: string & import("effect/Brand").Brand<"AI.ProviderID">;
+            readonly id?: string | undefined;
+            readonly encrypted?: string | undefined;
+            readonly text?: string | null | undefined;
+        } & ({
+            readonly encrypted: string;
+            readonly text?: never;
+        } | {
+            readonly text: string | null;
+            readonly encrypted?: never;
+        }))>;
+    };
+    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 type: "image-partial";
+            readonly index: number;
+            readonly image: Media.Asset;
+        } | {
+            readonly type: "image";
+            readonly index: number;
+            readonly image: Media.Asset;
+        } | {
+            readonly type: "generation-queued";
+            readonly id: string;
+            readonly position?: number | undefined;
+        } | {
+            readonly type: "generation-progress";
+            readonly id: string;
+            readonly progress?: number | undefined;
+        } | {
+            readonly type: "finish";
+            readonly usage?: {
+                readonly type: "seconds";
+                readonly seconds: number;
+            } | {
+                readonly type: "characters";
+                readonly characters: number;
+            } | {
+                readonly type: "credits";
+                readonly credits: number;
+            } | {
+                readonly type: "compute";
+                readonly seconds: number;
+            } | {
+                readonly type: "tokens";
+                readonly input?: number | undefined;
+                readonly output?: number | undefined;
+                readonly total?: number | undefined;
+                readonly details?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | undefined;
+            readonly notices?: readonly {
+                readonly type: "filtered" | "moderated" | "other";
+                readonly message: string;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+            }[] | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        }>;
+        start: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
+        resume: (model: ImageModel, 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: (model: VideoModel, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
+        stream: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: AwaitOptions & RunOptions) => AsyncIterable<{
+            readonly type: "video";
+            readonly index: number;
+            readonly video: Media.Asset;
+        } | {
+            readonly type: "generation-queued";
+            readonly id: string;
+            readonly position?: number | undefined;
+        } | {
+            readonly type: "generation-progress";
+            readonly id: string;
+            readonly progress?: number | undefined;
+        } | {
+            readonly type: "finish";
+            readonly usage?: {
+                readonly type: "seconds";
+                readonly seconds: number;
+            } | {
+                readonly type: "characters";
+                readonly characters: number;
+            } | {
+                readonly type: "credits";
+                readonly credits: number;
+            } | {
+                readonly type: "compute";
+                readonly seconds: number;
+            } | {
+                readonly type: "tokens";
+                readonly input?: number | undefined;
+                readonly output?: number | undefined;
+                readonly total?: number | undefined;
+                readonly details?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | undefined;
+            readonly notices?: readonly {
+                readonly type: "filtered" | "moderated" | "other";
+                readonly message: string;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+            }[] | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | 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: "generation-queued";
+            readonly id: string;
+            readonly position?: number | undefined;
+        } | {
+            readonly type: "generation-progress";
+            readonly id: string;
+            readonly progress?: number | undefined;
+        } | {
+            readonly type: "finish";
+            readonly audio: Media.Asset;
+            readonly usage?: {
+                readonly type: "seconds";
+                readonly seconds: number;
+            } | {
+                readonly type: "characters";
+                readonly characters: number;
+            } | {
+                readonly type: "credits";
+                readonly credits: number;
+            } | {
+                readonly type: "compute";
+                readonly seconds: number;
+            } | {
+                readonly type: "tokens";
+                readonly input?: number | undefined;
+                readonly output?: number | undefined;
+                readonly total?: number | undefined;
+                readonly details?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | undefined;
+            readonly notices?: readonly {
+                readonly type: "filtered" | "moderated" | "other";
+                readonly message: string;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+            }[] | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | 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 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: "generation-queued";
+            readonly id: string;
+            readonly position?: number | undefined;
+        } | {
+            readonly type: "generation-progress";
+            readonly id: string;
+            readonly progress?: number | undefined;
+        } | {
+            readonly text: string;
+            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;
+            readonly language?: string | undefined;
+            readonly durationSeconds?: number | undefined;
+            readonly usage?: {
+                readonly type: "seconds";
+                readonly seconds: number;
+            } | {
+                readonly type: "characters";
+                readonly characters: number;
+            } | {
+                readonly type: "credits";
+                readonly credits: number;
+            } | {
+                readonly type: "compute";
+                readonly seconds: number;
+            } | {
+                readonly type: "tokens";
+                readonly input?: number | undefined;
+                readonly output?: number | undefined;
+                readonly total?: number | undefined;
+                readonly details?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | undefined;
+            readonly notices?: readonly {
+                readonly type: "filtered" | "moderated" | "other";
+                readonly message: string;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+            }[] | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly type: "finish";
+        }>;
+        start: <const Model extends TranscriptionModel>(input: TranscriptionRequestInput<Model> | TranscriptionRequest, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
+        resume: (model: TranscriptionModel, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
+    };
+    decision: {
+        request: typeof import("./decision.js").request;
+        generate: <const Model extends DecisionModel, const Questions extends DecisionQuestions>(input: DecisionRequestInput<Model, Questions>, options?: RunOptions) => Promise<import("./decision.js").DecisionResponseFor<Questions>>;
+    };
+    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>;
+    /** Decoded asset bytes, downloading `url` sources through the executor. */
+    bytes: (asset: Media.Asset, options?: RunOptions) => Promise<Uint8Array<ArrayBufferLike>>;
+    base64: (asset: Media.Asset, options?: RunOptions) => Promise<string>;
+    /** Pull a `url` asset into owned bytes before the provider URL expires. */
+    materialize: (asset: Media.Asset, options?: RunOptions) => Promise<Media.Asset>;
+    /** Read a file into an asset like `Media.file`: sniffed media type, then the extension's. */
+    file: (path: string, options?: Media.AssetOptions & RunOptions) => Promise<Media.Asset>;
+    /** Write an asset's bytes like `Media.write`, downloading `url` sources through the executor. */
+    write: (asset: Media.Asset, path: string, options?: RunOptions) => Promise<void>;
+    llm: {
+        request: typeof LLM.request;
+        generate: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) => Promise<import("./effect.js").LLMResponse>;
+        stream: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) => AsyncIterable<{
+            readonly type: "step-start";
+            readonly index: number;
+        } | {
+            readonly type: "text-start";
+            readonly id: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "text-delta";
+            readonly id: string;
+            readonly text: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "text-end";
+            readonly id: string;
+            readonly text?: string | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "reasoning-start";
+            readonly id: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "reasoning-delta";
+            readonly id: string;
+            readonly text: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "reasoning-end";
+            readonly id: string;
+            readonly text?: string | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "tool-input-start";
+            readonly id: string;
+            readonly name: string;
+            readonly namespace?: string | undefined;
+            readonly providerExecuted?: boolean | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "tool-input-delta";
+            readonly id: string;
+            readonly name: string;
+            readonly namespace?: string | undefined;
+            readonly text: string;
+            readonly input?: unknown;
+        } | {
+            readonly type: "tool-input-end";
+            readonly id: string;
+            readonly name: string;
+            readonly namespace?: string | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "tool-input-error";
+            readonly id: string;
+            readonly name: string;
+            readonly namespace?: string | undefined;
+            readonly raw: string;
+        } | {
+            readonly type: "tool-call";
+            readonly id: string;
+            readonly name: string;
+            readonly namespace?: string | undefined;
+            readonly input: unknown;
+            readonly providerExecuted?: boolean | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "tool-result";
+            readonly id: string;
+            readonly name: string;
+            readonly namespace?: string | undefined;
+            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 providerExecuted?: boolean | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "tool-error";
+            readonly id: string;
+            readonly name: string;
+            readonly namespace?: string | undefined;
+            readonly message: string;
+            readonly error?: unknown;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "step-finish";
+            readonly index: number;
+            readonly reason: {
+                readonly normalized: "content-filter" | "error" | "length" | "stop" | "tool-calls" | "unknown";
+                readonly raw?: string | undefined;
+                readonly category?: string | undefined;
+                readonly explanation?: string | undefined;
+            };
+            readonly usage?: import("./effect.js").Usage | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "finish";
+            readonly reason: {
+                readonly normalized: "content-filter" | "error" | "length" | "stop" | "tool-calls" | "unknown";
+                readonly raw?: string | undefined;
+                readonly category?: string | undefined;
+                readonly explanation?: string | undefined;
+            };
+            readonly usage?: import("./effect.js").Usage | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "media";
+            readonly media: Media.Asset;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | 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;
+        } | ({
+            readonly type: "compaction";
+            readonly provider: string & import("effect/Brand").Brand<"AI.ProviderID">;
+            readonly id?: string | undefined;
+            readonly encrypted?: string | undefined;
+            readonly text?: string | null | undefined;
+        } & ({
+            readonly encrypted: string;
+            readonly text?: never;
+        } | {
+            readonly text: string | null;
+            readonly encrypted?: never;
+        }))>;
+    };
+    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 type: "image-partial";
+            readonly index: number;
+            readonly image: Media.Asset;
+        } | {
+            readonly type: "image";
+            readonly index: number;
+            readonly image: Media.Asset;
+        } | {
+            readonly type: "generation-queued";
+            readonly id: string;
+            readonly position?: number | undefined;
+        } | {
+            readonly type: "generation-progress";
+            readonly id: string;
+            readonly progress?: number | undefined;
+        } | {
+            readonly type: "finish";
+            readonly usage?: {
+                readonly type: "seconds";
+                readonly seconds: number;
+            } | {
+                readonly type: "characters";
+                readonly characters: number;
+            } | {
+                readonly type: "credits";
+                readonly credits: number;
+            } | {
+                readonly type: "compute";
+                readonly seconds: number;
+            } | {
+                readonly type: "tokens";
+                readonly input?: number | undefined;
+                readonly output?: number | undefined;
+                readonly total?: number | undefined;
+                readonly details?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | undefined;
+            readonly notices?: readonly {
+                readonly type: "filtered" | "moderated" | "other";
+                readonly message: string;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+            }[] | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        }>;
+        start: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
+        resume: (model: ImageModel, 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: (model: VideoModel, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
+        stream: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: AwaitOptions & RunOptions) => AsyncIterable<{
+            readonly type: "video";
+            readonly index: number;
+            readonly video: Media.Asset;
+        } | {
+            readonly type: "generation-queued";
+            readonly id: string;
+            readonly position?: number | undefined;
+        } | {
+            readonly type: "generation-progress";
+            readonly id: string;
+            readonly progress?: number | undefined;
+        } | {
+            readonly type: "finish";
+            readonly usage?: {
+                readonly type: "seconds";
+                readonly seconds: number;
+            } | {
+                readonly type: "characters";
+                readonly characters: number;
+            } | {
+                readonly type: "credits";
+                readonly credits: number;
+            } | {
+                readonly type: "compute";
+                readonly seconds: number;
+            } | {
+                readonly type: "tokens";
+                readonly input?: number | undefined;
+                readonly output?: number | undefined;
+                readonly total?: number | undefined;
+                readonly details?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | undefined;
+            readonly notices?: readonly {
+                readonly type: "filtered" | "moderated" | "other";
+                readonly message: string;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+            }[] | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | 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: "generation-queued";
+            readonly id: string;
+            readonly position?: number | undefined;
+        } | {
+            readonly type: "generation-progress";
+            readonly id: string;
+            readonly progress?: number | undefined;
+        } | {
+            readonly type: "finish";
+            readonly audio: Media.Asset;
+            readonly usage?: {
+                readonly type: "seconds";
+                readonly seconds: number;
+            } | {
+                readonly type: "characters";
+                readonly characters: number;
+            } | {
+                readonly type: "credits";
+                readonly credits: number;
+            } | {
+                readonly type: "compute";
+                readonly seconds: number;
+            } | {
+                readonly type: "tokens";
+                readonly input?: number | undefined;
+                readonly output?: number | undefined;
+                readonly total?: number | undefined;
+                readonly details?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | undefined;
+            readonly notices?: readonly {
+                readonly type: "filtered" | "moderated" | "other";
+                readonly message: string;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+            }[] | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | 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 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: "generation-queued";
+            readonly id: string;
+            readonly position?: number | undefined;
+        } | {
+            readonly type: "generation-progress";
+            readonly id: string;
+            readonly progress?: number | undefined;
+        } | {
+            readonly text: string;
+            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;
+            readonly language?: string | undefined;
+            readonly durationSeconds?: number | undefined;
+            readonly usage?: {
+                readonly type: "seconds";
+                readonly seconds: number;
+            } | {
+                readonly type: "characters";
+                readonly characters: number;
+            } | {
+                readonly type: "credits";
+                readonly credits: number;
+            } | {
+                readonly type: "compute";
+                readonly seconds: number;
+            } | {
+                readonly type: "tokens";
+                readonly input?: number | undefined;
+                readonly output?: number | undefined;
+                readonly total?: number | undefined;
+                readonly details?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | undefined;
+            readonly notices?: readonly {
+                readonly type: "filtered" | "moderated" | "other";
+                readonly message: string;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+            }[] | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly type: "finish";
+        }>;
+        start: <const Model extends TranscriptionModel>(input: TranscriptionRequestInput<Model> | TranscriptionRequest, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
+        resume: (model: TranscriptionModel, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
+    };
+    decision: {
+        request: typeof import("./decision.js").request;
+        generate: <const Model extends DecisionModel, const Questions extends DecisionQuestions>(input: DecisionRequestInput<Model, Questions>, options?: RunOptions) => Promise<import("./decision.js").DecisionResponseFor<Questions>>;
+    };
+    dispose: () => Promise<void>;
+};
+export * as AI from "./index.js";