@opencode/ai 2.0.16 → 2.0.18

package/dist/transcription-client.js

@@ -1,44 +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";
-export class Service extends Context.Service()("@opencode/TranscriptionClient") {
+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 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 Service = TranscriptionClientService;
 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">;
@@ -1012,7 +1004,7 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                     readonly confidence?: number | undefined;
                 }[] | undefined;
             }) => any) | undefined;
-        } & { [K in Exclude<keyof Cases, "finish" | "text-delta" | "generation-queued" | "generation-progress" | "segment">]: never; }, OrElse extends (value: Exclude<{
+        } & { [K in Exclude<keyof Cases, "finish" | "generation-queued" | "generation-progress" | "text-delta" | "segment">]: never; }, OrElse extends (value: Exclude<{
             readonly id: string;
             readonly type: "generation-queued";
             readonly position?: number | undefined;
@@ -1245,7 +1237,7 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                     readonly confidence?: number | undefined;
                 }[] | undefined;
             }) => any) | undefined;
-        } & { [K in Exclude<keyof Cases, "finish" | "text-delta" | "generation-queued" | "generation-progress" | "segment">]: never; }, OrElse extends (value: Exclude<{
+        } & { [K in Exclude<keyof Cases, "finish" | "generation-queued" | "generation-progress" | "text-delta" | "segment">]: never; }, OrElse extends (value: Exclude<{
             readonly id: string;
             readonly type: "generation-queued";
             readonly position?: number | undefined;
@@ -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.provider,
+            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.
@@ -110,7 +104,7 @@ export function request(input) {
         return input;
     return new TranscriptionRequest({
         ...input,
-        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+        http: HttpOptions.make(input.http),
     });
 }
 const requestEffect = (input) => tryRequest(() => request(input));

package/dist/utils/json.d.ts

@@ -0,0 +1,4 @@
+import { Schema } from "effect";
+export declare const Json: Schema.fromJsonString<Schema.Unknown>;
+export declare const decodeJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => unknown;
+export declare const encodeJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string;

package/dist/utils/json.js

@@ -0,0 +1,4 @@
+import { Schema } from "effect";
+export const Json = Schema.fromJsonString(Schema.Unknown);
+export const decodeJson = Schema.decodeUnknownSync(Json);
+export const encodeJson = Schema.encodeSync(Json);

package/dist/utils/media-type.d.ts

@@ -3,5 +3,6 @@
  * `undefined` so callers can fall back to a provider-declared type or `application/octet-stream`.
  */
 export declare const detectMediaType: (bytes: Uint8Array) => string | undefined;
-export declare const extensionMediaType: (path: string) => string | undefined;
+/** Media type of a file's contents: sniffed magic bytes, then the path's extension. */
+export declare const fileMediaType: (bytes: Uint8Array, path: string) => string | undefined;
 export declare const mediaTypeExtension: (mediaType: string) => string | undefined;

package/dist/utils/media-type.js

@@ -54,7 +54,9 @@ const EXTENSIONS = {
     md: "text/markdown",
     csv: "text/csv",
 };
-export const extensionMediaType = (path) => EXTENSIONS[path.slice(path.lastIndexOf(".") + 1).toLowerCase()];
+const extensionMediaType = (path) => EXTENSIONS[path.slice(path.lastIndexOf(".") + 1).toLowerCase()];
+/** Media type of a file's contents: sniffed magic bytes, then the path's extension. */
+export const fileMediaType = (bytes, path) => detectMediaType(bytes) ?? extensionMediaType(path);
 const EXTENSION_ALIASES = {
     "audio/mp3": "mp3",
     "audio/m4a": "m4a",

package/dist/video-client.d.ts

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

package/dist/video-client.js

@@ -1,40 +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";
-export class Service extends Context.Service()("@opencode/VideoClient") {
+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 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 Service = VideoClientService;
 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,24 +3,21 @@ 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 { 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 = "480p" | "720p" | "1080p" | "4k" | (string & {});
+export type VideoResolution = OpenString<"480p" | "720p" | "1080p" | "4k">;
 /** Pinned frames. Routes that accept only a first frame fail typed when `last` is present. */
 export declare const VideoFrames: Schema.Struct<{
     readonly first: Schema.optional<Schema.decodeTo<Schema.declare<Media.Asset, Media.Asset>, Schema.Struct<{
@@ -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<{
@@ -1010,7 +1007,7 @@ export declare const VideoEvent: Schema.Union<readonly [Schema.Struct<{
                     } | undefined;
                 }[] | undefined;
             }) => any) | undefined;
-        } & { [K in Exclude<keyof Cases, "finish" | "video" | "generation-queued" | "generation-progress">]: never; }, OrElse extends (value: Exclude<{
+        } & { [K in Exclude<keyof Cases, "finish" | "generation-queued" | "generation-progress" | "video">]: never; }, OrElse extends (value: Exclude<{
             readonly id: string;
             readonly type: "generation-queued";
             readonly position?: number | undefined;
@@ -1171,7 +1168,7 @@ export declare const VideoEvent: Schema.Union<readonly [Schema.Struct<{
                     } | undefined;
                 }[] | undefined;
             }) => any) | undefined;
-        } & { [K in Exclude<keyof Cases, "finish" | "video" | "generation-queued" | "generation-progress">]: never; }, OrElse extends (value: Exclude<{
+        } & { [K in Exclude<keyof Cases, "finish" | "generation-queued" | "generation-progress" | "video">]: never; }, OrElse extends (value: Exclude<{
             readonly id: string;
             readonly type: "generation-queued";
             readonly position?: number | undefined;
@@ -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.provider,
+            provider: route.protocol.provider,
             http: input.http,
-            route: composeRoute(MediaRoute.queued, route, input),
+            route: composeRoute(route, input, collectResponse),
         });
     }
 }
@@ -81,21 +77,24 @@ 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;
     return new VideoRequest({
         ...input,
-        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+        http: HttpOptions.make(input.http),
     });
 }
 const requestEffect = (input) => tryRequest(() => request(input));

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.0.16",
+  "version": "2.0.18",
   "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": "2.0.16",
+    "@opencode/http-recorder": "2.0.18",
     "@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": "2.0.16",
+    "@opencode/schema": "2.0.18",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"

package/dist/protocols/utils/meta-image.d.ts

@@ -1,2 +0,0 @@
-export declare const mediaType: (data: Uint8Array, format?: string) => string;
-export * as MetaImage from "./meta-image.js";

package/dist/protocols/utils/meta-image.js

@@ -1,13 +0,0 @@
-// Responses image items can omit output_format, including when PNG/JPEG was requested.
-export const mediaType = (data, format) => {
-    if (format !== undefined)
-        return `image/${format}`;
-    if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71)
-        return "image/png";
-    if (data[0] === 255 && data[1] === 216 && data[2] === 255)
-        return "image/jpeg";
-    if (new TextDecoder().decode(data.slice(0, 4)) === "RIFF" && new TextDecoder().decode(data.slice(8, 12)) === "WEBP")
-        return "image/webp";
-    return "application/octet-stream";
-};
-export * as MetaImage from "./meta-image.js";

package/dist/protocols/utils/openai-image.d.ts

@@ -1,5 +0,0 @@
-import { Schema } from "effect";
-export declare const Size: Schema.String;
-export declare const OpenAIImage: {
-    readonly Size: Schema.String;
-};

package/dist/protocols/utils/openai-image.js

@@ -1,18 +0,0 @@
-import { Schema } from "effect";
-const dimensions = (value) => {
-    const match = /^(\d+)x(\d+)$/.exec(value);
-    if (!match)
-        return undefined;
-    return { width: Number(match[1]), height: Number(match[2]) };
-};
-export const Size = Schema.String.check(Schema.makeFilter((value) => {
-    if (value === "auto")
-        return undefined;
-    const parsed = dimensions(value);
-    if (!parsed)
-        return "image size must be `auto` or `{width}x{height}`";
-    return parsed.width > 0 && parsed.height > 0 ? undefined : "image dimensions must be positive integers";
-}));
-export const OpenAIImage = {
-    Size,
-};