@opencode/ai 2.0.15 → 2.0.16

package/dist/promise.d.ts

@@ -1,13 +1,21 @@
 import { Effect, Layer } from "effect";
-import { ImageModel, ImageRequest, type ImageRequestInput } from "./image.js";
+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 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.
  */
 export interface Options {
     /** Executor layer; defaults to `RequestExecutor.fetchLayer`. Inject a recorder or middleware here. */
@@ -16,7 +24,15 @@ export interface Options {
 export interface RunOptions {
     readonly signal?: AbortSignal;
 }
-export type Services = Layer.Success<typeof LLMClient.layer> | Layer.Success<typeof ImageClient.layer> | RequestExecutor.Service;
+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: {
@@ -237,8 +253,20 @@ 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: import("./media.js").Asset;
+        } | {
             readonly type: "image";
             readonly index: number;
             readonly image: import("./media.js").Asset;
@@ -280,6 +308,196 @@ export declare const make: (options?: Options) => {
                 } | 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>;
 };
@@ -505,8 +723,20 @@ 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: import("./media.js").Asset;
+        } | {
             readonly type: "image";
             readonly index: number;
             readonly image: import("./media.js").Asset;
@@ -548,6 +778,196 @@ export declare const ai: {
                 } | 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>;
 };

package/dist/promise.js

@@ -5,6 +5,12 @@ import { LLM } from "./index.js";
 import { LLMClient } from "./route/client.js";
 import { RequestExecutor } from "./route/executor.js";
 import { LanguageModel, LLMRequest } from "./schema/index.js";
+import { Speech, SpeechModel, SpeechRequest } from "./speech.js";
+import { SpeechClient } from "./speech-client.js";
+import { Transcription, TranscriptionModel, TranscriptionRequest, } from "./transcription.js";
+import { TranscriptionClient } from "./transcription-client.js";
+import { Video, VideoModel, VideoRequest } from "./video.js";
+import { VideoClient } from "./video-client.js";
 const abortEffect = (signal) => signal === undefined
     ? Effect.never
     : Effect.callback((resume) => {
@@ -17,13 +23,23 @@ 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)));
+    const runtime = ManagedRuntime.make(Layer.mergeAll(LLMClient.layer, ImageClient.layer, VideoClient.layer, SpeechClient.layer, TranscriptionClient.layer).pipe(Layer.provideMerge(options.layer ?? RequestExecutor.fetchLayer)));
     /** Run any package Effect (for example `asset.bytes()`) 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))))));
+    const handle = (generation) => ({
+        ...generation.snapshot,
+        token: generation.token,
+        await: (options) => run(generation.await({ poll: options?.poll }), options),
+        refresh: (options) => run(generation.refresh(), options).then(handle),
+        cancel: (options) => run(generation.cancel(), options),
+    });
     // 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 videoRequest = (input) => input instanceof VideoRequest ? input : Video.request(input);
+    const speechRequest = (input) => input instanceof SpeechRequest ? input : Speech.request(input);
+    const transcriptionRequest = (input) => input instanceof TranscriptionRequest ? input : Transcription.request(input);
     return {
         run,
         llm: {
@@ -33,8 +49,29 @@ export const make = (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(imageRequest(input), { poll: options?.poll }), options),
+            stream: (input, options) => iterate(Image.stream(imageRequest(input), { poll: options?.poll }), options),
+            start: (input, options) => run(Image.start(imageRequest(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(videoRequest(input)), options).then(handle),
+            generate: (input, options) => run(Video.generate(videoRequest(input), { poll: options?.poll }), options),
+            resume: (model, token, options) => run(Video.resume(model, token), options).then(handle),
+            stream: (input, options) => iterate(Video.stream(videoRequest(input), { poll: options?.poll }), options),
+        },
+        speech: {
+            request: Speech.request,
+            generate: (input, options) => run(Speech.generate(speechRequest(input)), options),
+            stream: (input, options) => iterate(Speech.stream(speechRequest(input)), options),
+        },
+        transcription: {
+            request: Transcription.request,
+            generate: (input, options) => run(Transcription.generate(transcriptionRequest(input), { poll: options?.poll }), options),
+            stream: (input, options) => iterate(Transcription.stream(transcriptionRequest(input), { poll: options?.poll }), options),
+            start: (input, options) => run(Transcription.start(transcriptionRequest(input)), options).then(handle),
+            resume: (model, token, options) => run(Transcription.resume(model, token), options).then(handle),
         },
         dispose: () => runtime.dispose(),
     };

package/dist/protocols/alibaba-chat.d.ts

@@ -50,6 +50,12 @@ export declare const protocol: Protocol<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly role: "user";
@@ -65,6 +71,12 @@ export declare const protocol: Protocol<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly [x: string]: unknown;

package/dist/protocols/alibaba-responses.d.ts

@@ -77,8 +77,8 @@ export declare const protocol: Protocol<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -114,8 +114,8 @@ export declare const protocol: Protocol<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";

package/dist/protocols/anthropic-messages.js

@@ -897,7 +897,6 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
     const format = outputConfig?.format ?? undefined;
     const updates = resolveEffortUpdates(request, options.effort ?? outputConfig?.effort ?? undefined);
     const generation = request.generation;
-    const toolSchemaCompatibility = request.model.compatibility?.toolSchema;
     // Allocate the 4-breakpoint budget in invalidation order: tools → system →
     // messages. Tools live highest in the cache hierarchy, so when callers
     // over-mark we keep their tool hints and shed the message-tail ones first.
@@ -905,7 +904,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
     const flattened = ProviderShared.flattenToolRequest(updates.request);
     const tools = flattened.tools.length === 0
         ? undefined
-        : flattened.tools.map((tool) => lowerTool(breakpoints, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)));
+        : flattened.tools.map((tool) => lowerTool(breakpoints, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model)));
     // Anthropic rejects tool_choice when tools are absent; "none" is only meaningful with tools present.
     const toolChoice = tools === undefined || !request.toolChoice ? undefined : yield* lowerToolChoice(request.toolChoice);
     const systemParts = request.system.filter((part) => part.text.length > 0);

package/dist/protocols/assemblyai-transcription.d.ts

@@ -0,0 +1,40 @@
+import { Schema } from "effect";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { TranscriptionModel, TranscriptionResponse, type TranscriptionRequestFor } from "../transcription.js";
+export declare const DEFAULT_BASE_URL = "https://api.assemblyai.com";
+export declare const PATH = "/v2/transcript";
+export declare const UPLOAD_PATH = "/v2/upload";
+export type AssemblyAITranscriptionOptions = {
+    readonly keyterms_prompt?: ReadonlyArray<string>;
+    readonly punctuate?: boolean;
+    readonly format_text?: boolean;
+    readonly disfluencies?: boolean;
+    readonly filter_profanity?: boolean;
+    readonly temperature?: number;
+    readonly speaker_options?: {
+        readonly min_speakers_expected?: number;
+        readonly max_speakers_expected?: number;
+    };
+    readonly language_detection_options?: {
+        readonly expected_languages?: ReadonlyArray<string>;
+        readonly fallback_language?: string;
+        readonly code_switching?: boolean;
+    };
+    readonly speech_models?: ReadonlyArray<"universal-3-5-pro" | "universal-2" | (string & {})>;
+} & Record<string, unknown>;
+export type Request = TranscriptionRequestFor<AssemblyAITranscriptionOptions>;
+export declare const Token: Schema.Struct<{
+    readonly transcriptID: Schema.String;
+}>;
+export type Token = Schema.Schema.Type<typeof Token>;
+export declare const protocol: MediaProtocol.Queued<Request, TranscriptionResponse, {
+    readonly transcriptID: string;
+}>;
+export declare const model: (input: MediaRoute.ModelInput) => TranscriptionModel<AssemblyAITranscriptionOptions>;
+export declare const AssemblyAITranscription: {
+    readonly protocol: MediaProtocol.Queued<Request, TranscriptionResponse, {
+        readonly transcriptID: string;
+    }>;
+    readonly model: (input: MediaRoute.ModelInput) => TranscriptionModel<AssemblyAITranscriptionOptions>;
+};