@opencode/ai 0.0.0-dev-20138 → 0.0.0-dev-20141

package/dist/route/media.js

@@ -5,7 +5,7 @@ import { Endpoint } from "./endpoint.js";
 import { RequestExecutorService } from "./executor-service.js";
 import { RequestExecutor } from "./executor.js";
 import { MediaProtocol } from "./media-protocol.js";
-import { Generation, resultEvents } from "../generation.js";
+import { Generation } from "../generation.js";
 import { AIError, AIErrorReason, HttpOptions, InvalidRequestError, ProviderID, UnsupportedOperationError, mergeHttpOptions, } from "../schema/index.js";
 import { encodeJson } from "../utils/json.js";
 import { sanitizeSurrogates } from "../utils/sanitize.js";
@@ -112,41 +112,6 @@ export const stream = (input) => {
         generate: (request, execute) => events(request, execute, "generate").pipe(Stream.runCollect, Effect.flatMap(input.collect)),
     };
 };
-export const dispatch = (input) => {
-    const notQueued = (route, operation) => new AIError({
-        reason: new UnsupportedOperationError({
-            operation: `${input.modality}.${operation}`,
-            provider: route.provider,
-            route: route.id,
-            message: `${route.provider}/${route.id} is not a queued route; use generate or stream`,
-        }),
-    });
-    const start = (route, request) => {
-        if (route.kind !== "queued")
-            return Effect.fail(notQueued(route, "start"));
-        return route.start(request, input.execute);
-    };
-    return {
-        start,
-        resume: (route, model, token) => {
-            if (route.kind !== "queued")
-                return Effect.fail(notQueued(route, "resume"));
-            return route.resume(model, token, input.execute);
-        },
-        generate: (route, request, options) => {
-            if (route.kind !== "queued")
-                return route.generate(request, input.execute);
-            return start(route, request).pipe(Effect.flatMap((generation) => generation.await(options)));
-        },
-        stream: (route, request, options) => {
-            if (route.kind === "stream")
-                return route.stream(request, input.execute);
-            if (route.kind === "queued")
-                return Stream.unwrap(start(route, request).pipe(Effect.map((generation) => resultEvents(generation, input.responseEvents, options))));
-            return Stream.fromIterableEffect(Effect.map(route.generate(request, input.execute), input.responseEvents));
-        },
-    };
-};
 // ---------------------------------------------------------------------------
 // Transport plumbing shared by every kind
 // ---------------------------------------------------------------------------

package/dist/route/protocol.d.ts

@@ -1,5 +1,5 @@
 import { Schema, type Effect } from "effect";
-import type { AIError, LLMEvent, LLMRequest, ProtocolID } from "../schema/index.js";
+import type { AIError, LanguageModelSanitizerCompatibility, LLMEvent, LLMRequest, ProtocolID } from "../schema/index.js";
 /**
  * The semantic API contract of one model server family.
  *
@@ -42,6 +42,8 @@ export interface Protocol<Body, Frame, Event, State> {
     readonly stream: ProtocolStream<Frame, Event, State>;
     /** Whether `body.from` lowers `Message.effort(...)` markers; wrappers around another `body.from` must forward it. */
     readonly supportsEffortUpdates?: (request: LLMRequest) => boolean;
+    /** Tool schema sanitizer for every model on this protocol unless the model's compatibility sets one; wrappers around another `body.from` must forward it. */
+    readonly sanitizer?: LanguageModelSanitizerCompatibility;
 }
 export interface ProtocolBody<Body> {
     /** Schema for the validated provider-native body sent as the JSON request. */

package/dist/speech-client.d.ts

@@ -1,23 +1,66 @@
-import { Context, Effect, Layer, Stream } from "effect";
-import { RequestExecutor } from "./route/executor.js";
-import type { AIError } from "./schema/index.js";
-import type { SpeechEvent, SpeechOptions, SpeechRequestFor, SpeechResponse } from "./speech.js";
-export interface Interface {
-    readonly generate: <Options extends SpeechOptions>(request: SpeechRequestFor<Options>) => Effect.Effect<SpeechResponse, AIError>;
-    readonly stream: <Options extends SpeechOptions>(request: SpeechRequestFor<Options>) => Stream.Stream<SpeechEvent, AIError>;
-}
+import { Context } from "effect";
+import { MediaClient } from "./media-client.js";
+import { type SpeechEvent, type SpeechRequestFor, type SpeechResponse } from "./speech.js";
+export type Interface = MediaClient.Interface<SpeechRequestFor, SpeechEvent, SpeechResponse>;
 declare const SpeechClientService_base: Context.ServiceClass<SpeechClientService, "@opencode/SpeechClient", Interface>;
 export declare class SpeechClientService extends SpeechClientService_base {
 }
 export declare const Service: typeof SpeechClientService;
 export type Service = SpeechClientService;
-export declare const generate: <Options extends SpeechOptions>(request: SpeechRequestFor<Options>) => Effect.Effect<SpeechResponse, AIError, Service>;
-export declare const stream: <Options extends SpeechOptions>(request: SpeechRequestFor<Options>) => Stream.Stream<SpeechEvent, AIError, Service>;
-export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
 export declare const SpeechClient: {
+    readonly layer: import("effect/Layer").Layer<SpeechClientService, never, import("./route/executor-service.js").RequestExecutorService>;
+    readonly generate: (request: SpeechRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Effect").Effect<SpeechResponse, import("./index.js").AIError, SpeechClientService>;
+    readonly stream: (request: SpeechRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Stream").Stream<import("./generation.js").Observation | {
+        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;
+    }, import("./index.js").AIError, SpeechClientService>;
+    readonly start: (request: SpeechRequestFor) => import("effect/Effect").Effect<import("./generation.js").Generation<SpeechResponse>, import("./index.js").AIError, SpeechClientService>;
+    readonly resume: (model: import("./speech.js").SpeechModel<import("./media-model.js").MediaModel.Options>, token: unknown) => import("effect/Effect").Effect<import("./generation.js").Generation<SpeechResponse>, import("./index.js").AIError, SpeechClientService>;
     readonly Service: typeof SpeechClientService;
-    readonly layer: Layer.Layer<SpeechClientService, never, import("./route/executor-service.js").RequestExecutorService>;
-    readonly generate: <Options extends SpeechOptions>(request: SpeechRequestFor<Options>) => Effect.Effect<SpeechResponse, AIError, Service>;
-    readonly stream: <Options extends SpeechOptions>(request: SpeechRequestFor<Options>) => Stream.Stream<SpeechEvent, AIError, Service>;
 };
 export {};

package/dist/speech-client.js

@@ -1,26 +1,21 @@
-import { Context, Effect, Layer, Stream } from "effect";
-import { RequestExecutor } from "./route/executor.js";
+import { Context } from "effect";
+import { MediaClient } from "./media-client.js";
+import { SpeechTimestampsEvent, SpeechFinishEvent, } from "./speech.js";
 export class SpeechClientService extends Context.Service()("@opencode/SpeechClient") {
 }
 export const Service = SpeechClientService;
-export const generate = (request) => Effect.gen(function* () {
-    const client = yield* Service;
-    return yield* client.generate(request);
-});
-export const stream = (request) => Stream.unwrap(Effect.gen(function* () {
-    const client = yield* Service;
-    return client.stream(request);
-}));
-export const layer = Layer.effect(Service, Effect.gen(function* () {
-    const executor = yield* RequestExecutor.Service;
-    return Service.of({
-        generate: (request) => request.model.route.generate(request, executor.execute),
-        stream: (request) => request.model.route.stream(request, executor.execute),
-    });
-}));
 export const SpeechClient = {
     Service,
-    layer,
-    generate,
-    stream,
+    ...MediaClient.make(Service, {
+        modality: "speech",
+        responseEvents: (response) => [
+            ...(response.timestamps === undefined ? [] : [SpeechTimestampsEvent.make({ items: response.timestamps })]),
+            SpeechFinishEvent.make({
+                audio: response.audio,
+                usage: response.usage,
+                notices: response.notices,
+                providerMetadata: response.providerMetadata,
+            }),
+        ],
+    }),
 };

package/dist/speech.d.ts

@@ -2,21 +2,18 @@ import { Effect, Schema, Stream } from "effect";
 import { Media } from "./media.js";
 import { MediaModel } from "./media-model.js";
 import { MediaRoute } from "./route/media.js";
-import type { MediaProtocol } from "./route/media-protocol.js";
 import { AIError, HttpOptions, type OpenString } from "./schema/index.js";
 import { Service } from "./speech-client.js";
-export type SpeechOptions = Record<string, unknown>;
-export type SpeechRoute<Options extends SpeechOptions = SpeechOptions> = MediaRoute.StreamRoute<SpeechRequestFor<Options>, SpeechEvent, SpeechResponse>;
-export declare class SpeechModel<Options extends SpeechOptions = SpeechOptions> extends MediaModel<SpeechRoute<Options>, Options> {
+export type SpeechOptions = MediaModel.Options;
+export type SpeechRoute = MediaRoute.AnyRoute<SpeechRequestFor, SpeechEvent, SpeechResponse>;
+export declare class SpeechModel<Options extends SpeechOptions = SpeechOptions> extends MediaModel<SpeechRoute, Options> {
     protected readonly _SpeechModel: void;
-    static make<Options extends SpeechOptions = SpeechOptions>(input: MediaModel.Input<SpeechRoute<Options>>): SpeechModel<Options>;
-    /** Compose a streaming speech protocol with its canonical path into a model for one deployment. */
-    static fromRoute<Options extends SpeechOptions = SpeechOptions, Frame = unknown, State = unknown>(route: SpeechModel.RouteInput<Options, Frame, State>, input: MediaRoute.ModelInput): SpeechModel<Options>;
+    /** The number of type arguments selects the kind: `<Options>`, `<Options, Frame, State>`, or `<Options, Token>`. */
+    static fromRoute<Options extends SpeechOptions>(route: MediaModel.InlineRouteInput<SpeechRequestFor<Options>, SpeechResponse>, input: MediaRoute.ModelInput): SpeechModel<Options>;
+    static fromRoute<Options extends SpeechOptions, Frame, State>(route: MediaModel.StreamRouteInput<SpeechRequestFor<Options>, SpeechEvent, Frame, State>, input: MediaRoute.ModelInput): SpeechModel<Options>;
+    static fromRoute<Options extends SpeechOptions, Token>(route: MediaModel.QueuedRouteInput<SpeechRequestFor<Options>, SpeechResponse, Token>, input: MediaRoute.ModelInput): SpeechModel<Options>;
 }
-export declare namespace SpeechModel {
-    type RouteInput<Options extends SpeechOptions = SpeechOptions, Frame = unknown, State = unknown> = MediaModel.RouteInput<MediaProtocol.Addressed<SpeechRequestFor<Options>>, MediaProtocol.Streamed<SpeechRequestFor<Options>, SpeechEvent, Frame, State>>;
-}
-export declare const SpeechModelSchema: Schema.declare<SpeechModel<SpeechOptions>, SpeechModel<SpeechOptions>>;
+export declare const SpeechModelSchema: Schema.declare<SpeechModel<MediaModel.Options>, SpeechModel<MediaModel.Options>>;
 /** Provider-native: a name on OpenAI and Gemini, a voice id on ElevenLabs and Cartesia; `{ id }` is an OpenAI custom voice. */
 export declare const SpeechVoice: Schema.Union<readonly [Schema.String, Schema.Struct<{
     readonly id: Schema.String;
@@ -31,7 +28,7 @@ export declare const SpeechTimestamp: Schema.Struct<{
 }>;
 export type SpeechTimestamp = Schema.Schema.Type<typeof SpeechTimestamp>;
 declare const SpeechRequest_base: Schema.Class<SpeechRequest, Schema.Struct<{
-    readonly model: Schema.declare<SpeechModel<SpeechOptions>, SpeechModel<SpeechOptions>>;
+    readonly model: Schema.declare<SpeechModel<MediaModel.Options>, SpeechModel<MediaModel.Options>>;
     readonly text: Schema.String;
     readonly voice: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
         readonly id: Schema.String;
@@ -197,6 +194,14 @@ export declare const SpeechFinishEvent: Schema.Struct<{
     readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
 }>;
 declare const speechEventTagged: Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
+    readonly type: Schema.tag<"generation-queued">;
+    readonly id: Schema.String;
+    readonly position: Schema.optional<Schema.Number>;
+}>, Schema.Struct<{
+    readonly type: Schema.tag<"generation-progress">;
+    readonly id: Schema.String;
+    readonly progress: Schema.optional<Schema.Number>;
+}>, Schema.Struct<{
     readonly type: Schema.tag<"audio-delta">;
     readonly chunk: Schema.Uint8Array;
 }>, Schema.Struct<{
@@ -266,6 +271,14 @@ declare const speechEventTagged: Schema.toTaggedUnion<"type", readonly [Schema.S
     readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
 }>]>;
 export declare const SpeechEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.tag<"generation-queued">;
+    readonly id: Schema.String;
+    readonly position: Schema.optional<Schema.Number>;
+}>, Schema.Struct<{
+    readonly type: Schema.tag<"generation-progress">;
+    readonly id: Schema.String;
+    readonly progress: Schema.optional<Schema.Number>;
+}>, Schema.Struct<{
     readonly type: Schema.tag<"audio-delta">;
     readonly chunk: Schema.Uint8Array;
 }>, Schema.Struct<{
@@ -334,8 +347,18 @@ export declare const SpeechEvent: Schema.Union<readonly [Schema.Struct<{
     }>>>;
     readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
 }>]> & {
-    readonly discriminants: readonly ["audio-delta", "timestamps", "finish"];
+    readonly discriminants: readonly ["generation-queued", "generation-progress", "audio-delta", "timestamps", "finish"];
     readonly cases: {
+        "generation-queued": Schema.Struct<{
+            readonly type: Schema.tag<"generation-queued">;
+            readonly id: Schema.String;
+            readonly position: Schema.optional<Schema.Number>;
+        }>;
+        "generation-progress": Schema.Struct<{
+            readonly type: Schema.tag<"generation-progress">;
+            readonly id: Schema.String;
+            readonly progress: Schema.optional<Schema.Number>;
+        }>;
         "audio-delta": Schema.Struct<{
             readonly type: Schema.tag<"audio-delta">;
             readonly chunk: Schema.Uint8Array;
@@ -409,6 +432,14 @@ export declare const SpeechEvent: Schema.Union<readonly [Schema.Struct<{
         }>;
     };
     readonly isAnyOf: <const Keys>(keys: readonly Keys[]) => (value: {
+        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>;
     } | {
@@ -457,6 +488,18 @@ export declare const SpeechEvent: Schema.Union<readonly [Schema.Struct<{
             } | undefined;
         }[] | undefined;
     }) => value is Extract<{
+        readonly id: string;
+        readonly type: "generation-queued";
+        readonly position?: number | undefined;
+    }, {
+        readonly type: Keys;
+    }> | Extract<{
+        readonly id: string;
+        readonly type: "generation-progress";
+        readonly progress?: number | undefined;
+    }, {
+        readonly type: Keys;
+    }> | Extract<{
         readonly type: "audio-delta";
         readonly chunk: Uint8Array<ArrayBufferLike>;
     }, {
@@ -512,6 +555,16 @@ export declare const SpeechEvent: Schema.Union<readonly [Schema.Struct<{
         readonly type: Keys;
     }>;
     readonly guards: {
+        "generation-queued": (u: unknown) => u is {
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        };
+        "generation-progress": (u: unknown) => u is {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        };
         "audio-delta": (u: unknown) => u is {
             readonly type: "audio-delta";
             readonly chunk: Uint8Array<ArrayBufferLike>;
@@ -566,6 +619,16 @@ export declare const SpeechEvent: Schema.Union<readonly [Schema.Struct<{
     };
     readonly match: {
         <Cases extends {
+            "generation-queued": (value: {
+                readonly id: string;
+                readonly type: "generation-queued";
+                readonly position?: number | undefined;
+            }) => any;
+            "generation-progress": (value: {
+                readonly id: string;
+                readonly type: "generation-progress";
+                readonly progress?: number | undefined;
+            }) => any;
             "audio-delta": (value: {
                 readonly type: "audio-delta";
                 readonly chunk: Uint8Array<ArrayBufferLike>;
@@ -618,6 +681,14 @@ export declare const SpeechEvent: Schema.Union<readonly [Schema.Struct<{
                 }[] | undefined;
             }) => any;
         }>(value: {
+            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>;
         } | {
@@ -667,6 +738,16 @@ export declare const SpeechEvent: Schema.Union<readonly [Schema.Struct<{
             }[] | undefined;
         }, cases: Cases): Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
         <Cases extends {
+            "generation-queued": (value: {
+                readonly id: string;
+                readonly type: "generation-queued";
+                readonly position?: number | undefined;
+            }) => any;
+            "generation-progress": (value: {
+                readonly id: string;
+                readonly type: "generation-progress";
+                readonly progress?: number | undefined;
+            }) => any;
             "audio-delta": (value: {
                 readonly type: "audio-delta";
                 readonly chunk: Uint8Array<ArrayBufferLike>;
@@ -719,6 +800,14 @@ export declare const SpeechEvent: Schema.Union<readonly [Schema.Struct<{
                 }[] | undefined;
             }) => any;
         }>(cases: Cases): (value: {
+            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>;
         } | {
@@ -770,6 +859,16 @@ export declare const SpeechEvent: Schema.Union<readonly [Schema.Struct<{
     };
     readonly matchOrElse: {
         <Cases extends {
+            "generation-queued"?: ((value: {
+                readonly id: string;
+                readonly type: "generation-queued";
+                readonly position?: number | undefined;
+            }) => any) | undefined;
+            "generation-progress"?: ((value: {
+                readonly id: string;
+                readonly type: "generation-progress";
+                readonly progress?: number | undefined;
+            }) => any) | undefined;
             "audio-delta"?: ((value: {
                 readonly type: "audio-delta";
                 readonly chunk: Uint8Array<ArrayBufferLike>;
@@ -821,7 +920,19 @@ export declare const SpeechEvent: Schema.Union<readonly [Schema.Struct<{
                     } | undefined;
                 }[] | undefined;
             }) => any) | undefined;
-        } & { [K in Exclude<keyof Cases, "finish" | "timestamps" | "audio-delta">]: never; }, OrElse extends (value: Exclude<{
+        } & { [K in Exclude<keyof Cases, "finish" | "generation-queued" | "generation-progress" | "timestamps" | "audio-delta">]: never; }, OrElse extends (value: Exclude<{
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        }, {
+            readonly type: keyof Cases;
+        }> | Exclude<{
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        }, {
+            readonly type: keyof Cases;
+        }> | Exclude<{
             readonly type: "audio-delta";
             readonly chunk: Uint8Array<ArrayBufferLike>;
         }, {
@@ -876,6 +987,14 @@ export declare const SpeechEvent: Schema.Union<readonly [Schema.Struct<{
         }, {
             readonly type: keyof Cases;
         }>) => any>(value: {
+            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>;
         } | {
@@ -925,6 +1044,16 @@ export declare const SpeechEvent: Schema.Union<readonly [Schema.Struct<{
             }[] | undefined;
         }, cases: Cases, orElse: OrElse): import("effect/Unify").Unify<{ [K_1 in keyof Cases]-?: NonNullable<Cases[K_1]> extends (...args: Array<any>) => infer R ? R : never; }[keyof Cases] | ReturnType<OrElse>>;
         <Cases extends {
+            "generation-queued"?: ((value: {
+                readonly id: string;
+                readonly type: "generation-queued";
+                readonly position?: number | undefined;
+            }) => any) | undefined;
+            "generation-progress"?: ((value: {
+                readonly id: string;
+                readonly type: "generation-progress";
+                readonly progress?: number | undefined;
+            }) => any) | undefined;
             "audio-delta"?: ((value: {
                 readonly type: "audio-delta";
                 readonly chunk: Uint8Array<ArrayBufferLike>;
@@ -976,7 +1105,19 @@ export declare const SpeechEvent: Schema.Union<readonly [Schema.Struct<{
                     } | undefined;
                 }[] | undefined;
             }) => any) | undefined;
-        } & { [K in Exclude<keyof Cases, "finish" | "timestamps" | "audio-delta">]: never; }, OrElse extends (value: Exclude<{
+        } & { [K in Exclude<keyof Cases, "finish" | "generation-queued" | "generation-progress" | "timestamps" | "audio-delta">]: never; }, OrElse extends (value: Exclude<{
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        }, {
+            readonly type: keyof Cases;
+        }> | Exclude<{
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        }, {
+            readonly type: keyof Cases;
+        }> | Exclude<{
             readonly type: "audio-delta";
             readonly chunk: Uint8Array<ArrayBufferLike>;
         }, {
@@ -1031,6 +1172,14 @@ export declare const SpeechEvent: Schema.Union<readonly [Schema.Struct<{
         }, {
             readonly type: keyof Cases;
         }>) => any>(cases: Cases, orElse: OrElse): (value: {
+            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>;
         } | {
@@ -1082,6 +1231,16 @@ export declare const SpeechEvent: Schema.Union<readonly [Schema.Struct<{
     };
 } & {
     is: {
+        generationQueued: (u: unknown) => u is {
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        };
+        generationProgress: (u: unknown) => u is {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        };
         audioDelta: (u: unknown) => u is {
             readonly type: "audio-delta";
             readonly chunk: Uint8Array<ArrayBufferLike>;
@@ -1138,10 +1297,8 @@ export declare const SpeechEvent: Schema.Union<readonly [Schema.Struct<{
 export type SpeechEvent = Schema.Schema.Type<typeof speechEventTagged>;
 export declare function request<const Model extends SpeechModel>(input: SpeechRequestInput<Model>): SpeechRequestFor<SpeechModelOptions<Model>>;
 export declare function request(input: SpeechRequest): SpeechRequest;
-export declare function generate<const Model extends SpeechModel>(input: SpeechRequestInput<Model>): Effect.Effect<SpeechResponse, AIError, Service>;
-export declare function generate(input: SpeechRequest): Effect.Effect<SpeechResponse, AIError, Service>;
-export declare function stream<const Model extends SpeechModel>(input: SpeechRequestInput<Model>): Stream.Stream<SpeechEvent, AIError, Service>;
-export declare function stream(input: SpeechRequest): Stream.Stream<SpeechEvent, AIError, Service>;
+export declare function generate<const Model extends SpeechModel>(input: SpeechRequest | SpeechRequestInput<Model>): Effect.Effect<SpeechResponse, AIError, Service>;
+export declare function stream<const Model extends SpeechModel>(input: SpeechRequest | SpeechRequestInput<Model>): Stream.Stream<SpeechEvent, AIError, Service>;
 export declare const Speech: {
     readonly request: typeof request;
     readonly generate: typeof generate;

package/dist/speech.js

@@ -1,20 +1,17 @@
 import { Effect, Schema, Stream } from "effect";
+import { ProgressEvent, QueuedEvent } from "./generation.js";
 import { Media } from "./media.js";
 import { MediaModel, composeRoute, tryRequest } from "./media-model.js";
 import { MediaRoute } from "./route/media.js";
 import { AIError, HttpOptions, MediaUsage, ProviderMetadata } from "./schema/index.js";
 import { SpeechClient, Service } from "./speech-client.js";
 export class SpeechModel extends MediaModel {
-    static make(input) {
-        return new SpeechModel(input);
-    }
-    /** Compose a streaming speech protocol with its canonical path into a model for one deployment. */
     static fromRoute(route, input) {
         return new SpeechModel({
             id: input.id,
             provider: route.protocol.provider,
             http: input.http,
-            route: composeRoute((composition) => MediaRoute.stream({ ...composition, collect: collectResponse }), route, input),
+            route: composeRoute(route, input, collectResponse),
         });
     }
 }
@@ -75,9 +72,17 @@ export const SpeechFinishEvent = Schema.Struct({
     notices: Schema.optional(Schema.Array(Media.Notice)),
     providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "Speech.Event.Finish" });
-const speechEventTagged = Schema.Union([SpeechAudioDeltaEvent, SpeechTimestampsEvent, SpeechFinishEvent]).pipe(Schema.toTaggedUnion("type"));
+const speechEventTagged = Schema.Union([
+    QueuedEvent,
+    ProgressEvent,
+    SpeechAudioDeltaEvent,
+    SpeechTimestampsEvent,
+    SpeechFinishEvent,
+]).pipe(Schema.toTaggedUnion("type"));
 export const SpeechEvent = Object.assign(speechEventTagged, {
     is: {
+        generationQueued: speechEventTagged.guards["generation-queued"],
+        generationProgress: speechEventTagged.guards["generation-progress"],
         audioDelta: speechEventTagged.guards["audio-delta"],
         timestamps: speechEventTagged.guards.timestamps,
         finish: speechEventTagged.guards.finish,