@opencode/ai 2.0.15 → 2.0.17

package/dist/promise.d.ts

@@ -1,24 +1,53 @@
 import { Effect, Layer } from "effect";
-import { ImageModel, ImageRequest, type ImageRequestInput } from "./image.js";
-import { ImageClient } from "./image-client.js";
-import { LLMClient } from "./route/client.js";
+import { AIClient } from "./ai-client.js";
+import type { AwaitOptions, Event, Snapshot } from "./generation.js";
+import { type ImageModel, type ImageRequest, type ImageRequestInput } from "./image.js";
+import { Media } from "./media.js";
 import { RequestExecutor } from "./route/executor.js";
 import { LanguageModel, 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 and image clients
- * over a request executor; every method runs the corresponding Effect API and rethrows `AIError` unchanged.
+ * 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. `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 middleware here. */
+    /** 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 = Layer.Success<typeof LLMClient.layer> | Layer.Success<typeof ImageClient.layer> | RequestExecutor.Service;
+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 ends iteration without throwing. */
+    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: <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>;
@@ -193,7 +222,7 @@ export declare const make: (options?: Options) => {
             readonly namespace?: string | undefined;
         } | {
             readonly type: "media";
-            readonly media: import("./media.js").Asset;
+            readonly media: Media.Asset;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -237,13 +266,144 @@ export declare const make: (options?: Options) => {
     };
     image: {
         request: typeof import("./image.js").request;
-        generate: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => Promise<import("./image.js").ImageResponse>;
-        stream: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => AsyncIterable<{
+        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: Media.Asset;
+        } | {
             readonly type: "image";
             readonly index: number;
-            readonly image: import("./media.js").Asset;
+            readonly image: Media.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: (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 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: Media.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 id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        } | {
+            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: Media.Asset;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -281,12 +441,100 @@ export declare const make: (options?: Options) => {
             }[] | 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: (model: TranscriptionModel, 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>;
+    /** 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: <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>;
@@ -461,7 +709,7 @@ export declare const ai: {
             readonly namespace?: string | undefined;
         } | {
             readonly type: "media";
-            readonly media: import("./media.js").Asset;
+            readonly media: Media.Asset;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -505,11 +753,81 @@ export declare const ai: {
     };
     image: {
         request: typeof import("./image.js").request;
-        generate: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => Promise<import("./image.js").ImageResponse>;
-        stream: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => AsyncIterable<{
+        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: Media.Asset;
+        } | {
             readonly type: "image";
             readonly index: number;
-            readonly image: import("./media.js").Asset;
+            readonly image: Media.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: (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 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: Media.Asset;
         } | {
             readonly type: "finish";
             readonly providerMetadata?: {
@@ -549,6 +867,146 @@ export declare const ai: {
             }[] | 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 id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        } | {
+            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: Media.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: (model: TranscriptionModel, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
+    };
     dispose: () => Promise<void>;
 };
 export * as AI from "./promise.js";

package/dist/promise.js

@@ -1,10 +1,15 @@
 import { Effect, Layer, ManagedRuntime, Stream } from "effect";
-import { Image, ImageModel, ImageRequest } from "./image.js";
-import { ImageClient } from "./image-client.js";
+import { AIClient } from "./ai-client.js";
+import { Image } from "./image.js";
 import { LLM } from "./index.js";
-import { LLMClient } from "./route/client.js";
+import { Media } from "./media.js";
+import { tryRequest } from "./media-model.js";
 import { RequestExecutor } from "./route/executor.js";
-import { LanguageModel, LLMRequest } from "./schema/index.js";
+import { AIError, InvalidRequestError, LanguageModel, LLMRequest } from "./schema/index.js";
+import { Speech } from "./speech.js";
+import { Transcription, } from "./transcription.js";
+import { fileMediaType } from "./utils/media-type.js";
+import { Video } from "./video.js";
 const abortEffect = (signal) => signal === undefined
     ? Effect.never
     : Effect.callback((resume) => {
@@ -17,28 +22,81 @@ const abortEffect = (signal) => signal === undefined
         return Effect.sync(() => signal.removeEventListener("abort", onAbort));
     });
 export const make = (options = {}) => {
-    const runtime = ManagedRuntime.make(Layer.mergeAll(LLMClient.layer, ImageClient.layer).pipe(Layer.provideMerge(options.layer ?? RequestExecutor.fetchLayer)));
-    /** Run any package Effect (for example `asset.bytes()`) inside this runtime. */
+    const runtime = ManagedRuntime.make(AIClient.layerWith(options.layer ?? RequestExecutor.fetchLayer));
+    /** Run any package Effect (for example `LLMClient.compact(...)`) inside this runtime. */
     const run = (effect, options) => runtime.runPromise(effect, { signal: options?.signal });
     const iterate = (stream, options) => Stream.toAsyncIterable(Stream.unwrap(runtime.contextEffect.pipe(Effect.map((context) => stream.pipe(Stream.interruptWhen(abortEffect(options?.signal)), Stream.provideContext(context))))));
-    // The typed `generate`/`stream` overloads take a concrete input or a request, not the union; normalize once here.
-    const llmRequest = (input) => (input instanceof LLMRequest ? input : LLM.request(input));
-    const imageRequest = (input) => input instanceof ImageRequest ? input : Image.request(input);
+    const handle = (generation) => ({
+        ...generation.snapshot,
+        token: generation.token,
+        await: (options) => run(generation.await({ poll: options?.poll }), options),
+        events: (options) => iterate(generation.events({ poll: options?.poll }), options),
+        result: (options) => run(generation.result(), options),
+        refresh: (options) => run(generation.refresh(), options).then(handle),
+        cancel: (options) => run(generation.cancel(), options),
+    });
+    const llmRequest = (input) => input instanceof LLMRequest ? Effect.succeed(input) : tryRequest(() => LLM.request(input));
     return {
         run,
+        /** Decoded asset bytes, downloading `url` sources through the executor. */
+        bytes: (asset, options) => run(asset.bytes(), options),
+        base64: (asset, options) => run(asset.base64(), options),
+        /** Pull a `url` asset into owned bytes before the provider URL expires. */
+        materialize: (asset, options) => run(asset.materialize(), options),
+        /** Read a file into an asset like `Media.file`: sniffed media type, then the extension's. */
+        file: async (path, options) => {
+            const { readFile } = await import("node:fs/promises");
+            return run(Effect.tryPromise({
+                try: (signal) => readFile(path, { signal }),
+                catch: (cause) => fileError(`Failed to read media file ${path}`, cause),
+            }).pipe(Effect.map((buffer) => {
+                const data = new Uint8Array(buffer);
+                return Media.bytes(data, fileMediaType(data, path), options);
+            })), options);
+        },
+        /** Write an asset's bytes like `Media.write`, downloading `url` sources through the executor. */
+        write: async (asset, path, options) => {
+            const { writeFile } = await import("node:fs/promises");
+            return run(asset.bytes().pipe(Effect.flatMap((data) => Effect.tryPromise({
+                try: (signal) => writeFile(path, data, { signal }),
+                catch: (cause) => fileError(`Failed to write media file ${path}`, cause),
+            }))), options);
+        },
         llm: {
             request: LLM.request,
-            generate: (input, options) => run(LLM.generate(llmRequest(input)), options),
-            stream: (input, options) => iterate(LLM.stream(llmRequest(input)), options),
+            generate: (input, options) => run(Effect.flatMap(llmRequest(input), LLM.generate), options),
+            stream: (input, options) => iterate(Stream.unwrap(Effect.map(llmRequest(input), LLM.stream)), options),
         },
         image: {
             request: Image.request,
-            generate: (input, options) => run(Image.generate(imageRequest(input)), options),
-            stream: (input, options) => iterate(Image.stream(imageRequest(input)), options),
+            generate: (input, options) => run(Image.generate(input, { poll: options?.poll }), options),
+            stream: (input, options) => iterate(Image.stream(input, { poll: options?.poll }), options),
+            start: (input, options) => run(Image.start(input), options).then(handle),
+            resume: (model, token, options) => run(Image.resume(model, token), options).then(handle),
+        },
+        video: {
+            request: Video.request,
+            start: (input, options) => run(Video.start(input), options).then(handle),
+            generate: (input, options) => run(Video.generate(input, { poll: options?.poll }), options),
+            resume: (model, token, options) => run(Video.resume(model, token), options).then(handle),
+            stream: (input, options) => iterate(Video.stream(input, { poll: options?.poll }), options),
+        },
+        speech: {
+            request: Speech.request,
+            generate: (input, options) => run(Speech.generate(input), options),
+            stream: (input, options) => iterate(Speech.stream(input), options),
+        },
+        transcription: {
+            request: Transcription.request,
+            generate: (input, options) => run(Transcription.generate(input, { poll: options?.poll }), options),
+            stream: (input, options) => iterate(Transcription.stream(input, { poll: options?.poll }), options),
+            start: (input, options) => run(Transcription.start(input), options).then(handle),
+            resume: (model, token, options) => run(Transcription.resume(model, token), options).then(handle),
         },
         dispose: () => runtime.dispose(),
     };
 };
+const fileError = (message, cause) => new AIError({ reason: new InvalidRequestError({ message, cause }) });
 /** Default client over `RequestExecutor.fetchLayer` for scripts; the runtime builds its layer on first use. */
 export const ai = make();
 export * as AI from "./promise.js";