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

package/dist/transcription-client.d.ts

@@ -1,30 +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 {
 }
 export declare const Service: typeof TranscriptionClientService;
 export type Service = TranscriptionClientService;
-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 TranscriptionClient: {
+    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;
-    readonly layer: Layer.Layer<TranscriptionClientService, never, import("./route/executor-service.js").RequestExecutorService>;
-    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>;
 };
 export {};

package/dist/transcription-client.js

@@ -1,45 +1,13 @@
-import { Context, Effect, Layer, Stream } from "effect";
-import { RequestExecutor } from "./route/executor.js";
-import { MediaRoute } from "./route/media.js";
-import { responseEvents, } from "./transcription.js";
+import { Context } from "effect";
+import { MediaClient } from "./media-client.js";
+import { TranscriptionFinishEvent, } from "./transcription.js";
 export class TranscriptionClientService extends Context.Service()("@opencode/TranscriptionClient") {
 }
 export const Service = TranscriptionClientService;
-export const generate = (request, options) => Effect.gen(function* () {
-    const client = yield* Service;
-    return yield* client.generate(request, options);
-});
-export const stream = (request, options) => Stream.unwrap(Effect.gen(function* () {
-    const client = yield* Service;
-    return client.stream(request, options);
-}));
-export const start = (request) => Effect.gen(function* () {
-    const client = yield* Service;
-    return yield* client.start(request);
-});
-export const resume = (model, token) => Effect.gen(function* () {
-    const client = yield* Service;
-    return yield* client.resume(model, token);
-});
-export const layer = Layer.effect(Service, Effect.gen(function* () {
-    const executor = yield* RequestExecutor.Service;
-    const dispatch = MediaRoute.dispatch({
-        modality: "transcription",
-        execute: executor.execute,
-        responseEvents,
-    });
-    return Service.of({
-        start: (request) => dispatch.start(request.model.route, request),
-        resume: (model, token) => dispatch.resume(model.route, model, token),
-        generate: (request, options) => dispatch.generate(request.model.route, request, options),
-        stream: (request, options) => dispatch.stream(request.model.route, request, options),
-    });
-}));
 export const TranscriptionClient = {
     Service,
-    layer,
-    generate,
-    stream,
-    start,
-    resume,
+    ...MediaClient.make(Service, {
+        modality: "transcription",
+        responseEvents: (response) => [TranscriptionFinishEvent.make({ ...response })],
+    }),
 };

package/dist/transcription.d.ts

@@ -3,30 +3,22 @@ import { Generation, type AwaitOptions } from "./generation.js";
 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 { Service } from "./transcription-client.js";
-export type TranscriptionOptions = Record<string, unknown>;
-export type TranscriptionRoute<Options extends TranscriptionOptions = TranscriptionOptions> = MediaRoute.AnyRoute<TranscriptionRequestFor<Options>, TranscriptionEvent, TranscriptionResponse>;
-export declare class TranscriptionModel<Options extends TranscriptionOptions = TranscriptionOptions> extends MediaModel<TranscriptionRoute<Options>, Options> {
+export type TranscriptionOptions = MediaModel.Options;
+export type TranscriptionRoute = MediaRoute.AnyRoute<TranscriptionRequestFor, TranscriptionEvent, TranscriptionResponse>;
+export declare class TranscriptionModel<Options extends TranscriptionOptions = TranscriptionOptions> extends MediaModel<TranscriptionRoute, Options> {
     protected readonly _TranscriptionModel: void;
-    static make<Options extends TranscriptionOptions = TranscriptionOptions>(input: MediaModel.Input<TranscriptionRoute<Options>>): TranscriptionModel<Options>;
     /** The number of type arguments selects the kind: `<Options>`, `<Options, Frame, State>`, or `<Options, Token>`. */
-    static fromRoute<Options extends TranscriptionOptions>(route: TranscriptionModel.InlineRouteInput<Options>, input: MediaRoute.ModelInput): TranscriptionModel<Options>;
-    static fromRoute<Options extends TranscriptionOptions, Frame, State>(route: TranscriptionModel.StreamRouteInput<Options, Frame, State>, input: MediaRoute.ModelInput): TranscriptionModel<Options>;
-    static fromRoute<Options extends TranscriptionOptions, Token>(route: TranscriptionModel.QueuedRouteInput<Options, Token>, input: MediaRoute.ModelInput): TranscriptionModel<Options>;
+    static fromRoute<Options extends TranscriptionOptions>(route: MediaModel.InlineRouteInput<TranscriptionRequestFor<Options>, TranscriptionResponse>, input: MediaRoute.ModelInput): TranscriptionModel<Options>;
+    static fromRoute<Options extends TranscriptionOptions, Frame, State>(route: MediaModel.StreamRouteInput<TranscriptionRequestFor<Options>, TranscriptionEvent, Frame, State>, input: MediaRoute.ModelInput): TranscriptionModel<Options>;
+    static fromRoute<Options extends TranscriptionOptions, Token>(route: MediaModel.QueuedRouteInput<TranscriptionRequestFor<Options>, TranscriptionResponse, Token>, input: MediaRoute.ModelInput): TranscriptionModel<Options>;
 }
-export declare namespace TranscriptionModel {
-    type InlineRouteInput<Options extends TranscriptionOptions = TranscriptionOptions> = MediaModel.RouteInput<TranscriptionRequestFor<Options>, MediaProtocol.Inline<TranscriptionRequestFor<Options>, TranscriptionResponse>>;
-    type StreamRouteInput<Options extends TranscriptionOptions = TranscriptionOptions, Frame = unknown, State = unknown> = MediaModel.RouteInput<MediaProtocol.Addressed<TranscriptionRequestFor<Options>>, MediaProtocol.Streamed<TranscriptionRequestFor<Options>, TranscriptionEvent, Frame, State>>;
-    type QueuedRouteInput<Options extends TranscriptionOptions = TranscriptionOptions, Token = unknown> = MediaModel.RouteInput<TranscriptionRequestFor<Options>, MediaProtocol.Queued<TranscriptionRequestFor<Options>, TranscriptionResponse, Token>>;
-    type RouteInput<Options extends TranscriptionOptions = TranscriptionOptions, Frame = unknown, State = unknown, Token = unknown> = MediaModel.AnyRouteInput<TranscriptionRequestFor<Options>, TranscriptionEvent, TranscriptionResponse, Frame, State, Token>;
-}
-export declare const TranscriptionModelSchema: Schema.declare<TranscriptionModel<TranscriptionOptions>, TranscriptionModel<TranscriptionOptions>>;
+export declare const TranscriptionModelSchema: Schema.declare<TranscriptionModel<MediaModel.Options>, TranscriptionModel<MediaModel.Options>>;
 export declare const TranscriptionTimestamps: Schema.Literals<readonly ["none", "segment", "word"]>;
 export type TranscriptionTimestamps = Schema.Schema.Type<typeof TranscriptionTimestamps>;
 declare const TranscriptionRequest_base: Schema.Class<TranscriptionRequest, Schema.Struct<{
-    readonly model: Schema.declare<TranscriptionModel<TranscriptionOptions>, TranscriptionModel<TranscriptionOptions>>;
+    readonly model: Schema.declare<TranscriptionModel<MediaModel.Options>, TranscriptionModel<MediaModel.Options>>;
     readonly audio: Schema.decodeTo<Schema.declare<Media.Asset, Media.Asset>, Schema.Struct<{
         readonly source: Schema.Union<readonly [Schema.Struct<{
             readonly type: Schema.Literal<"bytes">;
@@ -1483,22 +1475,18 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
     };
 };
 export type TranscriptionEvent = Schema.Schema.Type<typeof transcriptionEventTagged>;
-export declare const responseEvents: (response: TranscriptionResponse) => ReadonlyArray<TranscriptionEvent>;
 export declare function request<const Model extends TranscriptionModel>(input: TranscriptionRequestInput<Model>): TranscriptionRequestFor<TranscriptionModelOptions<Model>>;
 export declare function request(input: TranscriptionRequest): TranscriptionRequest;
-export declare function generate<const Model extends TranscriptionModel>(input: TranscriptionRequestInput<Model>, options?: AwaitOptions): Effect.Effect<TranscriptionResponse, AIError, Service>;
-export declare function generate(input: TranscriptionRequest, options?: AwaitOptions): Effect.Effect<TranscriptionResponse, AIError, Service>;
-export declare function stream<const Model extends TranscriptionModel>(input: TranscriptionRequestInput<Model>, options?: AwaitOptions): Stream.Stream<TranscriptionEvent, AIError, Service>;
-export declare function stream(input: TranscriptionRequest, options?: AwaitOptions): Stream.Stream<TranscriptionEvent, AIError, Service>;
+export declare function generate<const Model extends TranscriptionModel>(input: TranscriptionRequest | TranscriptionRequestInput<Model>, options?: AwaitOptions): Effect.Effect<TranscriptionResponse, AIError, Service>;
+export declare function stream<const Model extends TranscriptionModel>(input: TranscriptionRequest | TranscriptionRequestInput<Model>, options?: AwaitOptions): Stream.Stream<TranscriptionEvent, AIError, Service>;
 /** Inline and streaming routes fail with `UnsupportedOperation`. */
-export declare function start<const Model extends TranscriptionModel>(input: TranscriptionRequestInput<Model>): Effect.Effect<Generation<TranscriptionResponse>, AIError, Service>;
-export declare function start(input: TranscriptionRequest): 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 function start<const Model extends TranscriptionModel>(input: TranscriptionRequest | TranscriptionRequestInput<Model>): Effect.Effect<Generation<TranscriptionResponse>, AIError, Service>;
+export declare const resume: (model: TranscriptionModel, token: unknown) => Effect.Effect<Generation<TranscriptionResponse>, AIError, Service>;
 export declare const Transcription: {
     readonly request: typeof request;
     readonly generate: typeof generate;
     readonly stream: typeof stream;
     readonly start: typeof start;
-    readonly resume: <Options extends TranscriptionOptions>(model: TranscriptionModel<Options>, token: unknown) => Effect.Effect<Generation<TranscriptionResponse>, AIError, Service>;
+    readonly resume: (model: TranscriptionModel, token: unknown) => Effect.Effect<Generation<TranscriptionResponse>, AIError, Service>;
 };
 export {};

package/dist/transcription.js

@@ -1,20 +1,17 @@
 import { Effect, Schema, Stream } from "effect";
 import { Generation, ProgressEvent, QueuedEvent } from "./generation.js";
 import { Media } from "./media.js";
-import { MediaModel, composeAnyRoute, tryRequest } from "./media-model.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 { TranscriptionClient, Service } from "./transcription-client.js";
 export class TranscriptionModel extends MediaModel {
-    static make(input) {
-        return new TranscriptionModel(input);
-    }
     static fromRoute(route, input) {
         return new TranscriptionModel({
             id: input.id,
             provider: route.protocol.provider,
             http: input.http,
-            route: composeAnyRoute(route, input, collectResponse),
+            route: composeRoute(route, input, collectResponse),
         });
     }
 }
@@ -94,9 +91,6 @@ export const TranscriptionEvent = Object.assign(transcriptionEventTagged, {
         finish: transcriptionEventTagged.guards.finish,
     },
 });
-export const responseEvents = (response) => [
-    TranscriptionFinishEvent.make({ ...response }),
-];
 const collectResponse = (events) => {
     const finish = events.find(TranscriptionEvent.is.finish);
     // Every transcription protocol's `finish` emits the terminal event or fails, so a completed stream always has one.

package/dist/video-client.d.ts

@@ -1,30 +1,59 @@
-import { Context, Effect, Layer, Stream } from "effect";
-import { type AwaitOptions, type Generation } from "./generation.js";
-import { RequestExecutor } from "./route/executor.js";
-import type { AIError } from "./schema/index.js";
-import { type VideoEvent, type VideoModel, type VideoOptions, type VideoRequestFor, type VideoResponse } from "./video.js";
-export interface Interface {
-    readonly start: <Options extends VideoOptions>(request: VideoRequestFor<Options>) => Effect.Effect<Generation<VideoResponse>, AIError>;
-    readonly resume: <Options extends VideoOptions>(model: VideoModel<Options>, token: unknown) => Effect.Effect<Generation<VideoResponse>, AIError>;
-    readonly generate: <Options extends VideoOptions>(request: VideoRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<VideoResponse, AIError>;
-    readonly stream: <Options extends VideoOptions>(request: VideoRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<VideoEvent, AIError>;
-}
+import { Context } from "effect";
+import { MediaClient } from "./media-client.js";
+import { type VideoEvent, type VideoRequestFor, type VideoResponse } from "./video.js";
+export type Interface = MediaClient.Interface<VideoRequestFor, VideoEvent, VideoResponse>;
 declare const VideoClientService_base: Context.ServiceClass<VideoClientService, "@opencode/VideoClient", Interface>;
 export declare class VideoClientService extends VideoClientService_base {
 }
 export declare const Service: typeof VideoClientService;
 export type Service = VideoClientService;
-export declare const start: <Options extends VideoOptions>(request: VideoRequestFor<Options>) => Effect.Effect<Generation<VideoResponse>, AIError, Service>;
-export declare const resume: <Options extends VideoOptions>(model: VideoModel<Options>, token: unknown) => Effect.Effect<Generation<VideoResponse>, AIError, Service>;
-export declare const generate: <Options extends VideoOptions>(request: VideoRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<VideoResponse, AIError, Service>;
-export declare const stream: <Options extends VideoOptions>(request: VideoRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<VideoEvent, AIError, Service>;
-export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
 export declare const VideoClient: {
+    readonly layer: import("effect/Layer").Layer<VideoClientService, never, import("./route/executor-service.js").RequestExecutorService>;
+    readonly generate: (request: VideoRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Effect").Effect<VideoResponse, import("./index.js").AIError, VideoClientService>;
+    readonly stream: (request: VideoRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Stream").Stream<import("./generation.js").Observation | {
+        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;
+    }, import("./index.js").AIError, VideoClientService>;
+    readonly start: (request: VideoRequestFor) => import("effect/Effect").Effect<import("./generation.js").Generation<VideoResponse>, import("./index.js").AIError, VideoClientService>;
+    readonly resume: (model: import("./video.js").VideoModel<import("./media-model.js").MediaModel.Options>, token: unknown) => import("effect/Effect").Effect<import("./generation.js").Generation<VideoResponse>, import("./index.js").AIError, VideoClientService>;
     readonly Service: typeof VideoClientService;
-    readonly layer: Layer.Layer<VideoClientService, never, import("./route/executor-service.js").RequestExecutorService>;
-    readonly start: <Options extends VideoOptions>(request: VideoRequestFor<Options>) => Effect.Effect<Generation<VideoResponse>, AIError, Service>;
-    readonly resume: <Options extends VideoOptions>(model: VideoModel<Options>, token: unknown) => Effect.Effect<Generation<VideoResponse>, AIError, Service>;
-    readonly generate: <Options extends VideoOptions>(request: VideoRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<VideoResponse, AIError, Service>;
-    readonly stream: <Options extends VideoOptions>(request: VideoRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<VideoEvent, AIError, Service>;
 };
 export {};

package/dist/video-client.js

@@ -1,41 +1,20 @@
-import { Context, Effect, Layer, Stream } from "effect";
-import { resultEvents } from "./generation.js";
-import { RequestExecutor } from "./route/executor.js";
-import { responseEvents, } from "./video.js";
+import { Context } from "effect";
+import { MediaClient } from "./media-client.js";
+import { VideoOutputEvent, VideoFinishEvent, } from "./video.js";
 export class VideoClientService extends Context.Service()("@opencode/VideoClient") {
 }
 export const Service = VideoClientService;
-export const start = (request) => Effect.gen(function* () {
-    const client = yield* Service;
-    return yield* client.start(request);
-});
-export const resume = (model, token) => Effect.gen(function* () {
-    const client = yield* Service;
-    return yield* client.resume(model, token);
-});
-export const generate = (request, options) => Effect.gen(function* () {
-    const client = yield* Service;
-    return yield* client.generate(request, options);
-});
-export const stream = (request, options) => Stream.unwrap(Effect.gen(function* () {
-    const client = yield* Service;
-    return client.stream(request, options);
-}));
-export const layer = Layer.effect(Service, Effect.gen(function* () {
-    const executor = yield* RequestExecutor.Service;
-    const start = (request) => request.model.route.start(request, executor.execute);
-    return Service.of({
-        start,
-        resume: (model, token) => model.route.resume(model, token, executor.execute),
-        generate: (request, options) => start(request).pipe(Effect.flatMap((generation) => generation.await(options))),
-        stream: (request, options) => Stream.unwrap(start(request).pipe(Effect.map((generation) => resultEvents(generation, responseEvents, options)))),
-    });
-}));
 export const VideoClient = {
     Service,
-    layer,
-    start,
-    resume,
-    generate,
-    stream,
+    ...MediaClient.make(Service, {
+        modality: "video",
+        responseEvents: (response) => [
+            ...response.videos.map((video, index) => VideoOutputEvent.make({ index, video })),
+            VideoFinishEvent.make({
+                usage: response.usage,
+                notices: response.notices,
+                providerMetadata: response.providerMetadata,
+            }),
+        ],
+    }),
 };

package/dist/video.d.ts

@@ -3,21 +3,18 @@ import { Generation, type AwaitOptions } from "./generation.js";
 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 "./video-client.js";
-export type VideoOptions = Record<string, unknown>;
-export type VideoRoute<Options extends VideoOptions = VideoOptions> = MediaRoute.QueuedRoute<VideoRequestFor<Options>, VideoResponse>;
-export declare class VideoModel<Options extends VideoOptions = VideoOptions> extends MediaModel<VideoRoute<Options>, Options> {
+export type VideoOptions = MediaModel.Options;
+export type VideoRoute = MediaRoute.AnyRoute<VideoRequestFor, VideoEvent, VideoResponse>;
+export declare class VideoModel<Options extends VideoOptions = VideoOptions> extends MediaModel<VideoRoute, Options> {
     protected readonly _VideoModel: void;
-    static make<Options extends VideoOptions = VideoOptions>(input: MediaModel.Input<VideoRoute<Options>>): VideoModel<Options>;
-    /** Compose a queued video protocol with its canonical start path into a model for one deployment. */
-    static fromRoute<Options extends VideoOptions = VideoOptions, Token = unknown>(route: VideoModel.RouteInput<Options, Token>, input: MediaRoute.ModelInput): VideoModel<Options>;
+    /** The number of type arguments selects the kind: `<Options>`, `<Options, Frame, State>`, or `<Options, Token>`. */
+    static fromRoute<Options extends VideoOptions>(route: MediaModel.InlineRouteInput<VideoRequestFor<Options>, VideoResponse>, input: MediaRoute.ModelInput): VideoModel<Options>;
+    static fromRoute<Options extends VideoOptions, Frame, State>(route: MediaModel.StreamRouteInput<VideoRequestFor<Options>, VideoEvent, Frame, State>, input: MediaRoute.ModelInput): VideoModel<Options>;
+    static fromRoute<Options extends VideoOptions, Token>(route: MediaModel.QueuedRouteInput<VideoRequestFor<Options>, VideoResponse, Token>, input: MediaRoute.ModelInput): VideoModel<Options>;
 }
-export declare namespace VideoModel {
-    type RouteInput<Options extends VideoOptions = VideoOptions, Token = unknown> = MediaModel.RouteInput<VideoRequestFor<Options>, MediaProtocol.Queued<VideoRequestFor<Options>, VideoResponse, Token>>;
-}
-export declare const VideoModelSchema: Schema.declare<VideoModel<VideoOptions>, VideoModel<VideoOptions>>;
+export declare const VideoModelSchema: Schema.declare<VideoModel<MediaModel.Options>, VideoModel<MediaModel.Options>>;
 export type VideoAspectRatio = Media.AspectRatio;
 export declare const VideoAspectRatio: Schema.declare<`${number}:${number}`, `${number}:${number}`>;
 export type VideoResolution = OpenString<"480p" | "720p" | "1080p" | "4k">;
@@ -88,7 +85,7 @@ export declare const VideoFrames: Schema.Struct<{
 }>;
 export type VideoFrames = Schema.Schema.Type<typeof VideoFrames>;
 declare const VideoRequest_base: Schema.Class<VideoRequest, Schema.Struct<{
-    readonly model: Schema.declare<VideoModel<VideoOptions>, VideoModel<VideoOptions>>;
+    readonly model: Schema.declare<VideoModel<MediaModel.Options>, VideoModel<MediaModel.Options>>;
     readonly prompt: Schema.String;
     readonly frames: Schema.optional<Schema.Struct<{
         readonly first: Schema.optional<Schema.decodeTo<Schema.declare<Media.Asset, Media.Asset>, Schema.Struct<{
@@ -1337,23 +1334,18 @@ export declare const VideoEvent: Schema.Union<readonly [Schema.Struct<{
     };
 };
 export type VideoEvent = Schema.Schema.Type<typeof videoEventTagged>;
-/** A completed response expanded into the streaming event shape. */
-export declare const responseEvents: (response: VideoResponse) => ReadonlyArray<VideoEvent>;
 export declare function request<const Model extends VideoModel>(input: VideoRequestInput<Model>): VideoRequestFor<VideoModelOptions<Model>>;
 export declare function request(input: VideoRequest): VideoRequest;
-export declare function start<const Model extends VideoModel>(input: VideoRequestInput<Model>): Effect.Effect<Generation<VideoResponse>, AIError, Service>;
-export declare function start(input: VideoRequest): Effect.Effect<Generation<VideoResponse>, AIError, Service>;
-export declare function generate<const Model extends VideoModel>(input: VideoRequestInput<Model>, options?: AwaitOptions): Effect.Effect<VideoResponse, AIError, Service>;
-export declare function generate(input: VideoRequest, options?: AwaitOptions): Effect.Effect<VideoResponse, AIError, Service>;
+export declare function start<const Model extends VideoModel>(input: VideoRequest | VideoRequestInput<Model>): Effect.Effect<Generation<VideoResponse>, AIError, Service>;
+export declare function generate<const Model extends VideoModel>(input: VideoRequest | VideoRequestInput<Model>, options?: AwaitOptions): Effect.Effect<VideoResponse, AIError, Service>;
 /** Rebuild a generation handle from a persisted `Generation.token`, refreshing its status once. */
-export declare const resume: <Options extends VideoOptions>(model: VideoModel<Options>, token: unknown) => Effect.Effect<Generation<VideoResponse>, AIError, Service>;
-export declare function stream<const Model extends VideoModel>(input: VideoRequestInput<Model>, options?: AwaitOptions): Stream.Stream<VideoEvent, AIError, Service>;
-export declare function stream(input: VideoRequest, options?: AwaitOptions): Stream.Stream<VideoEvent, AIError, Service>;
+export declare const resume: (model: VideoModel, token: unknown) => Effect.Effect<Generation<VideoResponse>, AIError, Service>;
+export declare function stream<const Model extends VideoModel>(input: VideoRequest | VideoRequestInput<Model>, options?: AwaitOptions): Stream.Stream<VideoEvent, AIError, Service>;
 export declare const Video: {
     readonly request: typeof request;
     readonly start: typeof start;
     readonly generate: typeof generate;
-    readonly resume: <Options extends VideoOptions>(model: VideoModel<Options>, token: unknown) => Effect.Effect<Generation<VideoResponse>, AIError, Service>;
+    readonly resume: (model: VideoModel, token: unknown) => Effect.Effect<Generation<VideoResponse>, AIError, Service>;
     readonly stream: typeof stream;
 };
 export {};

package/dist/video.js

@@ -6,16 +6,12 @@ import { MediaRoute } from "./route/media.js";
 import { AIError, HttpOptions, MediaUsage, ProviderMetadata } from "./schema/index.js";
 import { VideoClient, Service } from "./video-client.js";
 export class VideoModel extends MediaModel {
-    static make(input) {
-        return new VideoModel(input);
-    }
-    /** Compose a queued video protocol with its canonical start path into a model for one deployment. */
     static fromRoute(route, input) {
         return new VideoModel({
             id: input.id,
             provider: route.protocol.provider,
             http: input.http,
-            route: composeRoute(MediaRoute.queued, route, input),
+            route: composeRoute(route, input, collectResponse),
         });
     }
 }
@@ -81,15 +77,18 @@ export const VideoEvent = Object.assign(videoEventTagged, {
         finish: videoEventTagged.guards.finish,
     },
 });
-/** A completed response expanded into the streaming event shape. */
-export const responseEvents = (response) => [
-    ...response.videos.map((video, index) => VideoOutputEvent.make({ index, video })),
-    VideoFinishEvent.make({
-        usage: response.usage,
-        notices: response.notices,
-        providerMetadata: response.providerMetadata,
-    }),
-];
+const collectResponse = (events) => {
+    const finish = events.find(VideoEvent.is.finish);
+    // A streaming video protocol's `finish` emits the terminal event or fails, so a completed stream always has one.
+    if (finish === undefined)
+        return Effect.die(new Error("The video stream completed without a finish event"));
+    return Effect.succeed(new VideoResponse({
+        videos: events.filter(VideoEvent.is.video).map((event) => event.video),
+        usage: finish.usage,
+        notices: finish.notices,
+        providerMetadata: finish.providerMetadata,
+    }));
+};
 export function request(input) {
     if (input instanceof VideoRequest)
         return input;

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-dev-20138",
+  "version": "0.0.0-dev-20141",
   "name": "@opencode/ai",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode/http-recorder": "0.0.0-dev-20138",
+    "@opencode/http-recorder": "0.0.0-dev-20141",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -44,7 +44,7 @@
     "@aws-sdk/credential-providers": "3.1057.0",
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode/schema": "0.0.0-dev-20138",
+    "@opencode/schema": "0.0.0-dev-20141",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"