@opencode/ai 2.0.16 → 2.0.17

package/dist/speech-client.d.ts

@@ -1,21 +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 {
 }
-declare const Service_base: Context.ServiceClass<Service, "@opencode/SpeechClient", Interface>;
-export declare class Service extends Service_base {
-}
-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 Service: typeof SpeechClientService;
+export type Service = SpeechClientService;
 export declare const SpeechClient: {
-    readonly Service: typeof Service;
-    readonly layer: Layer.Layer<Service, never, RequestExecutor.Service>;
-    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>;
+    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;
 };
 export {};

package/dist/speech-client.js

@@ -1,25 +1,21 @@
-import { Context, Effect, Layer, Stream } from "effect";
-import { RequestExecutor } from "./route/executor.js";
-export class Service extends Context.Service()("@opencode/SpeechClient") {
+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 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 Service = SpeechClientService;
 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,27 +2,24 @@ 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 } from "./schema/index.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;
 }>]>;
 export type SpeechVoice = Schema.Schema.Type<typeof SpeechVoice>;
-export type SpeechFormat = "mp3" | "wav" | "pcm" | "opus" | "aac" | "flac" | (string & {});
+export type SpeechFormat = OpenString<"mp3" | "wav" | "pcm" | "opus" | "aac" | "flac">;
 /** Granularity is provider-native: characters on ElevenLabs, words on Cartesia. */
 export declare const SpeechTimestamp: Schema.Struct<{
     readonly text: 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.provider,
+            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,
@@ -102,7 +107,7 @@ export function request(input) {
         return input;
     return new SpeechRequest({
         ...input,
-        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+        http: HttpOptions.make(input.http),
     });
 }
 const requestEffect = (input) => tryRequest(() => request(input));

package/dist/testing.d.ts

@@ -1743,11 +1743,11 @@ export declare const hangAfter: (...events: readonly LLMEvent[]) => Stream.Strea
     } | undefined;
 }, never, never>;
 /** Provides one shared implementation under the normal client and test-control tags. */
-export declare const testLayer: (options?: LayerOptions) => Layer.Layer<import("./route/client.js").Service | Test, never, never>;
+export declare const testLayer: (options?: LayerOptions) => Layer.Layer<import("./route/client.js").LLMClientService | Test, never, never>;
 /** @deprecated Use testLayer; retained for published callers of the legacy control interface. */
 export declare const layer: (options?: LayerOptions) => Layer.Layer<Service, never, never>;
 /** @deprecated testLayer provides LLMClient.Service directly. */
-export declare const clientLayer: Layer.Layer<import("./route/client.js").Service, never, Service>;
+export declare const clientLayer: Layer.Layer<import("./route/client.js").LLMClientService, never, Service>;
 export declare const push: (...responses: readonly Response[]) => Effect.Effect<void, never, Service>;
 export declare const always: (response: Response) => Effect.Effect<void, never, Service>;
 export declare const wait: (count: number) => Effect.Effect<void, never, Service>;

package/dist/transcription-client.d.ts

@@ -1,28 +1,82 @@
-import { Context, Effect, Layer, Stream } from "effect";
-import type { AwaitOptions, Generation } from "./generation.js";
-import { RequestExecutor } from "./route/executor.js";
-import type { AIError } from "./schema/index.js";
-import { type TranscriptionEvent, type TranscriptionModel, type TranscriptionOptions, type TranscriptionRequestFor, type TranscriptionResponse } from "./transcription.js";
-export interface Interface {
-    readonly generate: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<TranscriptionResponse, AIError>;
-    readonly stream: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<TranscriptionEvent, AIError>;
-    readonly start: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>) => Effect.Effect<Generation<TranscriptionResponse>, AIError>;
-    readonly resume: <Options extends TranscriptionOptions>(model: TranscriptionModel<Options>, token: unknown) => Effect.Effect<Generation<TranscriptionResponse>, AIError>;
+import { Context } from "effect";
+import { MediaClient } from "./media-client.js";
+import { type TranscriptionEvent, type TranscriptionRequestFor, type TranscriptionResponse } from "./transcription.js";
+export type Interface = MediaClient.Interface<TranscriptionRequestFor, TranscriptionEvent, TranscriptionResponse>;
+declare const TranscriptionClientService_base: Context.ServiceClass<TranscriptionClientService, "@opencode/TranscriptionClient", Interface>;
+export declare class TranscriptionClientService extends TranscriptionClientService_base {
 }
-declare const Service_base: Context.ServiceClass<Service, "@opencode/TranscriptionClient", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const generate: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<TranscriptionResponse, AIError, Service>;
-export declare const stream: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<TranscriptionEvent, AIError, Service>;
-export declare const start: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>) => Effect.Effect<Generation<TranscriptionResponse>, AIError, Service>;
-export declare const resume: <Options extends TranscriptionOptions>(model: TranscriptionModel<Options>, token: unknown) => Effect.Effect<Generation<TranscriptionResponse>, AIError, Service>;
-export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
+export declare const Service: typeof TranscriptionClientService;
+export type Service = TranscriptionClientService;
 export declare const TranscriptionClient: {
-    readonly Service: typeof Service;
-    readonly layer: Layer.Layer<Service, never, RequestExecutor.Service>;
-    readonly generate: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<TranscriptionResponse, AIError, Service>;
-    readonly stream: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<TranscriptionEvent, AIError, Service>;
-    readonly start: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>) => Effect.Effect<Generation<TranscriptionResponse>, AIError, Service>;
-    readonly resume: <Options extends TranscriptionOptions>(model: TranscriptionModel<Options>, token: unknown) => Effect.Effect<Generation<TranscriptionResponse>, AIError, Service>;
+    readonly layer: import("effect/Layer").Layer<TranscriptionClientService, never, import("./route/executor-service.js").RequestExecutorService>;
+    readonly generate: (request: TranscriptionRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Effect").Effect<TranscriptionResponse, import("./index.js").AIError, TranscriptionClientService>;
+    readonly stream: (request: TranscriptionRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Stream").Stream<import("./generation.js").Observation | {
+        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;
+    }, import("./index.js").AIError, TranscriptionClientService>;
+    readonly start: (request: TranscriptionRequestFor) => import("effect/Effect").Effect<import("./generation.js").Generation<TranscriptionResponse>, import("./index.js").AIError, TranscriptionClientService>;
+    readonly resume: (model: import("./transcription.js").TranscriptionModel<import("./media-model.js").MediaModel.Options>, token: unknown) => import("effect/Effect").Effect<import("./generation.js").Generation<TranscriptionResponse>, import("./index.js").AIError, TranscriptionClientService>;
+    readonly Service: typeof TranscriptionClientService;
 };
 export {};