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

package/dist/image-client.d.ts

@@ -1,30 +1,63 @@
-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 ImageEvent, type ImageModel, type ImageOptions, type ImageRequestFor, type ImageResponse } from "./image.js";
-export interface Interface {
-    readonly generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<ImageResponse, AIError>;
-    readonly stream: <Options extends ImageOptions>(request: ImageRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<ImageEvent, AIError>;
-    readonly start: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Effect.Effect<Generation<ImageResponse>, AIError>;
-    readonly resume: <Options extends ImageOptions>(model: ImageModel<Options>, token: unknown) => Effect.Effect<Generation<ImageResponse>, AIError>;
-}
+import { Context } from "effect";
+import { MediaClient } from "./media-client.js";
+import { type ImageEvent, type ImageRequestFor, type ImageResponse } from "./image.js";
+export type Interface = MediaClient.Interface<ImageRequestFor, ImageEvent, ImageResponse>;
 declare const ImageClientService_base: Context.ServiceClass<ImageClientService, "@opencode/ImageClient", Interface>;
 export declare class ImageClientService extends ImageClientService_base {
 }
 export declare const Service: typeof ImageClientService;
 export type Service = ImageClientService;
-export declare const generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<ImageResponse, AIError, Service>;
-export declare const stream: <Options extends ImageOptions>(request: ImageRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<ImageEvent, AIError, Service>;
-export declare const start: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Effect.Effect<Generation<ImageResponse>, AIError, Service>;
-export declare const resume: <Options extends ImageOptions>(model: ImageModel<Options>, token: unknown) => Effect.Effect<Generation<ImageResponse>, AIError, Service>;
-export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
 export declare const ImageClient: {
+    readonly layer: import("effect/Layer").Layer<ImageClientService, never, import("./route/executor-service.js").RequestExecutorService>;
+    readonly generate: (request: ImageRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Effect").Effect<ImageResponse, import("./index.js").AIError, ImageClientService>;
+    readonly stream: (request: ImageRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Stream").Stream<import("./generation.js").Observation | {
+        readonly type: "image-partial";
+        readonly index: number;
+        readonly image: import("./media.js").Asset;
+    } | {
+        readonly type: "image";
+        readonly index: number;
+        readonly image: import("./media.js").Asset;
+    } | {
+        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, ImageClientService>;
+    readonly start: (request: ImageRequestFor) => import("effect/Effect").Effect<import("./generation.js").Generation<ImageResponse>, import("./index.js").AIError, ImageClientService>;
+    readonly resume: (model: import("./image.js").ImageModel<import("./media-model.js").MediaModel.Options>, token: unknown) => import("effect/Effect").Effect<import("./generation.js").Generation<ImageResponse>, import("./index.js").AIError, ImageClientService>;
     readonly Service: typeof ImageClientService;
-    readonly layer: Layer.Layer<ImageClientService, never, import("./route/executor-service.js").RequestExecutorService>;
-    readonly generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<ImageResponse, AIError, Service>;
-    readonly stream: <Options extends ImageOptions>(request: ImageRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<ImageEvent, AIError, Service>;
-    readonly start: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Effect.Effect<Generation<ImageResponse>, AIError, Service>;
-    readonly resume: <Options extends ImageOptions>(model: ImageModel<Options>, token: unknown) => Effect.Effect<Generation<ImageResponse>, AIError, Service>;
 };
 export {};

package/dist/image-client.js

@@ -1,45 +1,20 @@
-import { Context, Effect, Layer, Stream } from "effect";
-import { RequestExecutor } from "./route/executor.js";
-import { MediaRoute } from "./route/media.js";
-import { responseEvents, } from "./image.js";
+import { Context } from "effect";
+import { MediaClient } from "./media-client.js";
+import { ImageOutputEvent, ImageFinishEvent, } from "./image.js";
 export class ImageClientService extends Context.Service()("@opencode/ImageClient") {
 }
 export const Service = ImageClientService;
-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: "image",
-        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 ImageClient = {
     Service,
-    layer,
-    generate,
-    stream,
-    start,
-    resume,
+    ...MediaClient.make(Service, {
+        modality: "image",
+        responseEvents: (response) => [
+            ...response.images.map((image, index) => ImageOutputEvent.make({ index, image })),
+            ImageFinishEvent.make({
+                usage: response.usage,
+                notices: response.notices,
+                providerMetadata: response.providerMetadata,
+            }),
+        ],
+    }),
 };

package/dist/image.d.ts

@@ -3,33 +3,25 @@ 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 "./image-client.js";
-export type ImageOptions = Record<string, unknown>;
-export type ImageRoute<Options extends ImageOptions = ImageOptions> = MediaRoute.AnyRoute<ImageRequestFor<Options>, ImageEvent, ImageResponse>;
-export declare class ImageModel<Options extends ImageOptions = ImageOptions> extends MediaModel<ImageRoute<Options>, Options> {
+export type ImageOptions = MediaModel.Options;
+export type ImageRoute = MediaRoute.AnyRoute<ImageRequestFor, ImageEvent, ImageResponse>;
+export declare class ImageModel<Options extends ImageOptions = ImageOptions> extends MediaModel<ImageRoute, Options> {
     protected readonly _ImageModel: void;
-    static make<Options extends ImageOptions = ImageOptions>(input: MediaModel.Input<ImageRoute<Options>>): ImageModel<Options>;
     /** The number of type arguments selects the kind: `<Options>`, `<Options, Frame, State>`, or `<Options, Token>`. */
-    static fromRoute<Options extends ImageOptions>(route: ImageModel.InlineRouteInput<Options>, input: MediaRoute.ModelInput): ImageModel<Options>;
-    static fromRoute<Options extends ImageOptions, Frame, State>(route: ImageModel.StreamRouteInput<Options, Frame, State>, input: MediaRoute.ModelInput): ImageModel<Options>;
-    static fromRoute<Options extends ImageOptions, Token>(route: ImageModel.QueuedRouteInput<Options, Token>, input: MediaRoute.ModelInput): ImageModel<Options>;
+    static fromRoute<Options extends ImageOptions>(route: MediaModel.InlineRouteInput<ImageRequestFor<Options>, ImageResponse>, input: MediaRoute.ModelInput): ImageModel<Options>;
+    static fromRoute<Options extends ImageOptions, Frame, State>(route: MediaModel.StreamRouteInput<ImageRequestFor<Options>, ImageEvent, Frame, State>, input: MediaRoute.ModelInput): ImageModel<Options>;
+    static fromRoute<Options extends ImageOptions, Token>(route: MediaModel.QueuedRouteInput<ImageRequestFor<Options>, ImageResponse, Token>, input: MediaRoute.ModelInput): ImageModel<Options>;
 }
-export declare namespace ImageModel {
-    type InlineRouteInput<Options extends ImageOptions = ImageOptions> = MediaModel.RouteInput<ImageRequestFor<Options>, MediaProtocol.Inline<ImageRequestFor<Options>, ImageResponse>>;
-    type StreamRouteInput<Options extends ImageOptions = ImageOptions, Frame = unknown, State = unknown> = MediaModel.RouteInput<MediaProtocol.Addressed<ImageRequestFor<Options>>, MediaProtocol.Streamed<ImageRequestFor<Options>, ImageEvent, Frame, State>>;
-    type QueuedRouteInput<Options extends ImageOptions = ImageOptions, Token = unknown> = MediaModel.RouteInput<ImageRequestFor<Options>, MediaProtocol.Queued<ImageRequestFor<Options>, ImageResponse, Token>>;
-    type RouteInput<Options extends ImageOptions = ImageOptions, Frame = unknown, State = unknown, Token = unknown> = MediaModel.AnyRouteInput<ImageRequestFor<Options>, ImageEvent, ImageResponse, Frame, State, Token>;
-}
-export declare const ImageModelSchema: Schema.declare<ImageModel<ImageOptions>, ImageModel<ImageOptions>>;
+export declare const ImageModelSchema: Schema.declare<ImageModel<MediaModel.Options>, ImageModel<MediaModel.Options>>;
 export type ImageSize = `${number}x${number}`;
 export declare const ImageSize: Schema.declare<`${number}x${number}`, `${number}x${number}`>;
 export type ImageAspectRatio = Media.AspectRatio;
 export declare const ImageAspectRatio: Schema.declare<`${number}:${number}`, `${number}:${number}`>;
 export type ImageFormat = OpenString<"png" | "jpeg" | "webp">;
 declare const ImageRequest_base: Schema.Class<ImageRequest, Schema.Struct<{
-    readonly model: Schema.declare<ImageModel<ImageOptions>, ImageModel<ImageOptions>>;
+    readonly model: Schema.declare<ImageModel<MediaModel.Options>, ImageModel<MediaModel.Options>>;
     readonly prompt: Schema.String;
     /** Edit sources or style/subject references, in order. */
     readonly images: Schema.optional<Schema.$Array<Schema.decodeTo<Schema.declare<Media.Asset, Media.Asset>, Schema.Struct<{
@@ -1418,22 +1410,18 @@ export declare const ImageEvent: Schema.Union<readonly [Schema.Struct<{
     };
 };
 export type ImageEvent = Schema.Schema.Type<typeof imageEventTagged>;
-export declare const responseEvents: (response: ImageResponse) => ReadonlyArray<ImageEvent>;
 export declare function request<const Model extends ImageModel>(input: ImageRequestInput<Model>): ImageRequestFor<ImageModelOptions<Model>>;
 export declare function request(input: ImageRequest): ImageRequest;
-export declare function generate<const Model extends ImageModel>(input: ImageRequestInput<Model>, options?: AwaitOptions): Effect.Effect<ImageResponse, AIError, Service>;
-export declare function generate(input: ImageRequest, options?: AwaitOptions): Effect.Effect<ImageResponse, AIError, Service>;
-export declare function stream<const Model extends ImageModel>(input: ImageRequestInput<Model>, options?: AwaitOptions): Stream.Stream<ImageEvent, AIError, Service>;
-export declare function stream(input: ImageRequest, options?: AwaitOptions): Stream.Stream<ImageEvent, AIError, Service>;
+export declare function generate<const Model extends ImageModel>(input: ImageRequest | ImageRequestInput<Model>, options?: AwaitOptions): Effect.Effect<ImageResponse, AIError, Service>;
+export declare function stream<const Model extends ImageModel>(input: ImageRequest | ImageRequestInput<Model>, options?: AwaitOptions): Stream.Stream<ImageEvent, AIError, Service>;
 /** Inline and streaming routes fail with `UnsupportedOperation`. */
-export declare function start<const Model extends ImageModel>(input: ImageRequestInput<Model>): Effect.Effect<Generation<ImageResponse>, AIError, Service>;
-export declare function start(input: ImageRequest): Effect.Effect<Generation<ImageResponse>, AIError, Service>;
-export declare const resume: <Options extends ImageOptions>(model: ImageModel<Options>, token: unknown) => Effect.Effect<Generation<ImageResponse>, AIError, Service>;
+export declare function start<const Model extends ImageModel>(input: ImageRequest | ImageRequestInput<Model>): Effect.Effect<Generation<ImageResponse>, AIError, Service>;
+export declare const resume: (model: ImageModel, token: unknown) => Effect.Effect<Generation<ImageResponse>, AIError, Service>;
 export declare const Image: {
     readonly request: typeof request;
     readonly generate: typeof generate;
     readonly stream: typeof stream;
     readonly start: typeof start;
-    readonly resume: <Options extends ImageOptions>(model: ImageModel<Options>, token: unknown) => Effect.Effect<Generation<ImageResponse>, AIError, Service>;
+    readonly resume: (model: ImageModel, token: unknown) => Effect.Effect<Generation<ImageResponse>, AIError, Service>;
 };
 export {};

package/dist/image.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 { ImageClient, Service } from "./image-client.js";
 export class ImageModel extends MediaModel {
-    static make(input) {
-        return new ImageModel(input);
-    }
     static fromRoute(route, input) {
         return new ImageModel({
             id: input.id,
             provider: route.protocol.provider,
             http: input.http,
-            route: composeAnyRoute(route, input, collectResponse),
+            route: composeRoute(route, input, collectResponse),
         });
     }
 }
@@ -85,14 +82,6 @@ export const ImageEvent = Object.assign(imageEventTagged, {
         finish: imageEventTagged.guards.finish,
     },
 });
-export const responseEvents = (response) => [
-    ...response.images.map((image, index) => ImageOutputEvent.make({ index, image })),
-    ImageFinishEvent.make({
-        usage: response.usage,
-        notices: response.notices,
-        providerMetadata: response.providerMetadata,
-    }),
-];
 const collectResponse = (events) => {
     const finish = events.find(ImageEvent.is.finish);
     // Every image protocol's `finish` emits the terminal event or fails, so a completed stream always has one.

package/dist/media-client.d.ts

@@ -0,0 +1,30 @@
+import { type Context, Effect, Layer, Stream } from "effect";
+import { type AwaitOptions, type Generation, type Observation } from "./generation.js";
+import type { MediaRoute } from "./route/media.js";
+import { AIError } from "./schema/index.js";
+/** A media request whose model carries the route that executes it. */
+export interface RoutedRequest<Self extends MediaRoute.MediaRequest, Event, Response> extends MediaRoute.MediaRequest {
+    readonly model: MediaRoute.MediaRequest["model"] & {
+        readonly route: MediaRoute.AnyRoute<Self, Event, Response>;
+    };
+}
+/** `start` and `resume` fail with `UnsupportedOperation` on inline and stream routes. */
+export interface Interface<Req extends RoutedRequest<Req, Event, Response>, Event, Response> {
+    readonly generate: (request: Req, options?: AwaitOptions) => Effect.Effect<Response, AIError>;
+    readonly stream: (request: Req, options?: AwaitOptions) => Stream.Stream<Event | Observation, AIError>;
+    readonly start: (request: Req) => Effect.Effect<Generation<Response>, AIError>;
+    readonly resume: (model: Req["model"], token: unknown) => Effect.Effect<Generation<Response>, AIError>;
+}
+/** One modality's layer and service accessors, dispatching each request on its route's `kind`. */
+export declare const make: <Self, Req extends RoutedRequest<Req, Event, Response>, Event, Response>(service: Context.Service<Self, Interface<Req, Event, Response>>, input: {
+    readonly modality: string;
+    /** A completed response expanded into the streaming event shape. */
+    readonly responseEvents: (response: Response) => ReadonlyArray<Event>;
+}) => {
+    layer: Layer.Layer<Self, never, import("./route/executor-service.js").RequestExecutorService>;
+    generate: (request: Req, options?: AwaitOptions) => Effect.Effect<Response, AIError, Self>;
+    stream: (request: Req, options?: AwaitOptions) => Stream.Stream<Observation | Event, AIError, Exclude<Self, import("effect/Scope").Scope>>;
+    start: (request: Req) => Effect.Effect<Generation<Response>, AIError, Self>;
+    resume: (model: Req["model"], token: unknown) => Effect.Effect<Generation<Response>, AIError, Self>;
+};
+export * as MediaClient from "./media-client.js";

package/dist/media-client.js

@@ -0,0 +1,51 @@
+import { Effect, Layer, Stream } from "effect";
+import { resultEvents } from "./generation.js";
+import { RequestExecutor } from "./route/executor.js";
+import { AIError, UnsupportedOperationError } from "./schema/index.js";
+/** One modality's layer and service accessors, dispatching each request on its route's `kind`. */
+export const make = (service, input) => ({
+    layer: Layer.effect(service, Effect.gen(function* () {
+        const executor = yield* RequestExecutor.Service;
+        const notQueued = (route, operation) => new AIError({
+            reason: new UnsupportedOperationError({
+                operation: `${input.modality}.${operation}`,
+                provider: route.provider,
+                route: route.id,
+                message: `${route.provider}/${route.id} is not a queued route; use generate or stream`,
+            }),
+        });
+        const start = (request) => {
+            const route = request.model.route;
+            if (route.kind !== "queued")
+                return Effect.fail(notQueued(route, "start"));
+            return route.start(request, executor.execute);
+        };
+        return service.of({
+            start,
+            resume: (model, token) => {
+                if (model.route.kind !== "queued")
+                    return Effect.fail(notQueued(model.route, "resume"));
+                return model.route.resume(model, token, executor.execute);
+            },
+            generate: (request, options) => {
+                const route = request.model.route;
+                if (route.kind !== "queued")
+                    return route.generate(request, executor.execute);
+                return start(request).pipe(Effect.flatMap((generation) => generation.await(options)));
+            },
+            stream: (request, options) => {
+                const route = request.model.route;
+                if (route.kind === "stream")
+                    return route.stream(request, executor.execute);
+                if (route.kind === "queued")
+                    return Stream.unwrap(start(request).pipe(Effect.map((generation) => resultEvents(generation, input.responseEvents, options))));
+                return Stream.fromIterableEffect(Effect.map(route.generate(request, executor.execute), input.responseEvents));
+            },
+        });
+    })),
+    generate: (request, options) => service.use((client) => client.generate(request, options)),
+    stream: (request, options) => Stream.unwrap(service.useSync((client) => client.stream(request, options))),
+    start: (request) => service.use((client) => client.start(request)),
+    resume: (model, token) => service.use((client) => client.resume(model, token)),
+});
+export * as MediaClient from "./media-client.js";

package/dist/media-model.d.ts

@@ -5,11 +5,11 @@ import type { MediaProtocol } from "./route/media-protocol.js";
 import { AIError, HttpOptions, ModelID, ProviderID } from "./schema/index.js";
 /**
  * What every media model carries: ids, the configured route, and deployment `http` overlays. Modality classes
- * (`ImageModel`, `VideoModel`, `SpeechModel`) extend it with their route type and a nominal marker so one cannot stand
- * in for the other in requests.
+ * (`ImageModel`, `VideoModel`, `SpeechModel`, `TranscriptionModel`) extend it with their route type and a nominal
+ * marker so one cannot stand in for the other in requests.
  */
 export declare class MediaModel<Route, Options> {
-    protected readonly _Options: (options: Options) => Options;
+    protected readonly _Options: Options;
     readonly id: ModelID;
     readonly provider: ProviderID;
     readonly route: Route;
@@ -17,6 +17,7 @@ export declare class MediaModel<Route, Options> {
     constructor(input: MediaModel.Input<Route>);
 }
 export declare namespace MediaModel {
+    type Options = Record<string, unknown>;
     interface Input<Route> {
         readonly id: string | ModelID;
         readonly provider: string | ProviderID;
@@ -31,12 +32,12 @@ export declare namespace MediaModel {
         /** Headers the protocol requires on every call, such as a pinned API version; deployment headers win. */
         readonly headers?: Record<string, string>;
     }
-    type AnyRouteInput<Request extends MediaRoute.MediaRequest, Event, Response, Frame, State, Token> = RouteInput<Request, MediaProtocol.Inline<Request, Response>> | RouteInput<MediaProtocol.Addressed<Request>, MediaProtocol.Streamed<Request, Event, Frame, State>> | RouteInput<Request, MediaProtocol.Queued<Request, Response, Token>>;
+    type InlineRouteInput<Request extends MediaRoute.MediaRequest, Response> = RouteInput<Request, MediaProtocol.Inline<Request, Response>>;
+    type StreamRouteInput<Request extends MediaRoute.MediaRequest, Event, Frame, State> = RouteInput<MediaProtocol.Addressed<Request>, MediaProtocol.Streamed<Request, Event, Frame, State>>;
+    type QueuedRouteInput<Request extends MediaRoute.MediaRequest, Response, Token> = RouteInput<Request, MediaProtocol.Queued<Request, Response, Token>>;
+    type AnyRouteInput<Request extends MediaRoute.MediaRequest, Event, Response, Frame, State, Token> = InlineRouteInput<Request, Response> | StreamRouteInput<Request, Event, Frame, State> | QueuedRouteInput<Request, Response, Token>;
 }
 /** Compose a protocol route input with one deployment through `MediaRoute.inline`, `queued`, or `stream`. */
-export declare const composeRoute: <Request extends MediaRoute.MediaRequest, Protocol, Route>(compose: (input: MediaRoute.Composition<Request> & {
-    readonly protocol: Protocol;
-}) => Route, route: MediaModel.RouteInput<Request, Protocol>, input: MediaRoute.ModelInput) => Route;
-export declare const composeAnyRoute: <Request extends MediaRoute.MediaRequest, Event, Response, Frame, State, Token>(route: MediaModel.AnyRouteInput<Request, Event, Response, Frame, State, Token>, input: MediaRoute.ModelInput, collect: (events: ReadonlyArray<Event>) => Effect.Effect<Response, AIError>) => MediaRoute.AnyRoute<Request, Event, Response>;
+export declare const composeRoute: <Request extends MediaRoute.MediaRequest, Event, Response, Frame, State, Token>(route: MediaModel.AnyRouteInput<Request, Event, Response, Frame, State, Token>, input: MediaRoute.ModelInput, collect: (events: ReadonlyArray<Event>) => Effect.Effect<Response, AIError>) => MediaRoute.AnyRoute<Request, Event, Response>;
 /** Lift a synchronous Schema-class constructor into a typed `InvalidRequest` failure. */
 export declare const tryRequest: <A>(make: () => A) => Effect.Effect<A, AIError>;

package/dist/media-model.js

@@ -4,8 +4,8 @@ import { MediaRoute } from "./route/media.js";
 import { AIError, HttpOptions, InvalidRequestError, ModelID, ProviderID } from "./schema/index.js";
 /**
  * What every media model carries: ids, the configured route, and deployment `http` overlays. Modality classes
- * (`ImageModel`, `VideoModel`, `SpeechModel`) extend it with their route type and a nominal marker so one cannot stand
- * in for the other in requests.
+ * (`ImageModel`, `VideoModel`, `SpeechModel`, `TranscriptionModel`) extend it with their route type and a nominal
+ * marker so one cannot stand in for the other in requests.
  */
 export class MediaModel {
     id;
@@ -20,19 +20,19 @@ export class MediaModel {
     }
 }
 /** Compose a protocol route input with one deployment through `MediaRoute.inline`, `queued`, or `stream`. */
-export const composeRoute = (compose, route, input) => compose({
+export const composeRoute = (route, input, collect) => {
+    if (isStreamInput(route))
+        return MediaRoute.stream({ ...composition(route, input), collect });
+    if (isQueuedInput(route))
+        return MediaRoute.queued(composition(route, input));
+    return MediaRoute.inline(composition(route, input));
+};
+const composition = (route, input) => ({
     protocol: route.protocol,
     endpoint: Endpoint.path(route.path, { baseURL: input.baseURL ?? route.baseURL }),
     auth: input.auth,
     headers: route.headers === undefined && input.headers === undefined ? undefined : { ...route.headers, ...input.headers },
 });
-export const composeAnyRoute = (route, input, collect) => {
-    if (isStreamInput(route))
-        return composeRoute((composition) => MediaRoute.stream({ ...composition, collect }), route, input);
-    if (isQueuedInput(route))
-        return composeRoute(MediaRoute.queued, route, input);
-    return composeRoute(MediaRoute.inline, route, input);
-};
 const isStreamInput = (route) => route.protocol.kind === "stream";
 const isQueuedInput = (route) => route.protocol.kind === "queued";
 /** Lift a synchronous Schema-class constructor into a typed `InvalidRequest` failure. */

package/dist/promise.d.ts

@@ -1,14 +1,14 @@
 import { Effect, Layer } from "effect";
 import { AIClient } from "./ai-client.js";
 import type { AwaitOptions, Event, Snapshot } from "./generation.js";
-import { ImageModel, ImageRequest, type ImageOptions, type ImageRequestInput } from "./image.js";
+import { type ImageModel, type ImageRequest, type ImageRequestInput } from "./image.js";
 import { Media } from "./media.js";
 import { RequestExecutor } from "./route/executor.js";
 import { LanguageModel, LLMRequest } from "./schema/index.js";
 import type { RequestInput } from "./llm.js";
-import { SpeechModel, SpeechRequest, type SpeechRequestInput } from "./speech.js";
-import { TranscriptionModel, TranscriptionRequest, type TranscriptionOptions, type TranscriptionRequestInput } from "./transcription.js";
-import { VideoModel, VideoRequest, type VideoOptions, type VideoRequestInput } from "./video.js";
+import { type SpeechModel, type SpeechRequest, type SpeechRequestInput } from "./speech.js";
+import { type TranscriptionModel, type TranscriptionRequest, type TranscriptionRequestInput } from "./transcription.js";
+import { type VideoModel, type VideoRequest, type VideoRequestInput } from "./video.js";
 /**
  * Promise-first entrypoint for scripts and non-Effect callers. One `ManagedRuntime` hosts the LLM, image, video, speech,
  * and transcription clients over a request executor; every method runs the corresponding Effect API and rethrows
@@ -322,13 +322,13 @@ export declare const make: (options?: Options) => {
             }[] | undefined;
         }>;
         start: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
-        resume: <Options extends ImageOptions>(model: ImageModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
+        resume: (model: ImageModel, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
     };
     video: {
         request: typeof import("./video.js").request;
         start: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
         generate: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: AwaitOptions & RunOptions) => Promise<import("./video.js").VideoResponse>;
-        resume: <Options extends VideoOptions>(model: VideoModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
+        resume: (model: VideoModel, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
         stream: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: AwaitOptions & RunOptions) => AsyncIterable<{
             readonly id: string;
             readonly type: "generation-queued";
@@ -384,6 +384,14 @@ export declare const make: (options?: Options) => {
         request: typeof import("./speech.js").request;
         generate: <const Model extends SpeechModel>(input: SpeechRequestInput<Model> | SpeechRequest, options?: RunOptions) => Promise<import("./speech.js").SpeechResponse>;
         stream: <const Model extends SpeechModel>(input: SpeechRequestInput<Model> | SpeechRequest, options?: RunOptions) => AsyncIterable<{
+            readonly 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>;
         } | {
@@ -510,7 +518,7 @@ export declare const make: (options?: Options) => {
             }[] | undefined;
         }>;
         start: <const Model extends TranscriptionModel>(input: TranscriptionRequestInput<Model> | TranscriptionRequest, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
-        resume: <Options extends TranscriptionOptions>(model: TranscriptionModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
+        resume: (model: TranscriptionModel, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
     };
     dispose: () => Promise<void>;
 };
@@ -801,13 +809,13 @@ export declare const ai: {
             }[] | undefined;
         }>;
         start: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
-        resume: <Options extends ImageOptions>(model: ImageModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
+        resume: (model: ImageModel, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
     };
     video: {
         request: typeof import("./video.js").request;
         start: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
         generate: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: AwaitOptions & RunOptions) => Promise<import("./video.js").VideoResponse>;
-        resume: <Options extends VideoOptions>(model: VideoModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
+        resume: (model: VideoModel, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
         stream: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: AwaitOptions & RunOptions) => AsyncIterable<{
             readonly id: string;
             readonly type: "generation-queued";
@@ -863,6 +871,14 @@ export declare const ai: {
         request: typeof import("./speech.js").request;
         generate: <const Model extends SpeechModel>(input: SpeechRequestInput<Model> | SpeechRequest, options?: RunOptions) => Promise<import("./speech.js").SpeechResponse>;
         stream: <const Model extends SpeechModel>(input: SpeechRequestInput<Model> | SpeechRequest, options?: RunOptions) => AsyncIterable<{
+            readonly 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>;
         } | {
@@ -989,7 +1005,7 @@ export declare const ai: {
             }[] | undefined;
         }>;
         start: <const Model extends TranscriptionModel>(input: TranscriptionRequestInput<Model> | TranscriptionRequest, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
-        resume: <Options extends TranscriptionOptions>(model: TranscriptionModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
+        resume: (model: TranscriptionModel, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
     };
     dispose: () => Promise<void>;
 };

package/dist/promise.js

@@ -1,15 +1,15 @@
 import { Effect, Layer, ManagedRuntime, Stream } from "effect";
 import { AIClient } from "./ai-client.js";
-import { Image, ImageModel, ImageRequest } from "./image.js";
+import { Image } from "./image.js";
 import { LLM } from "./index.js";
 import { Media } from "./media.js";
 import { tryRequest } from "./media-model.js";
 import { RequestExecutor } from "./route/executor.js";
 import { AIError, InvalidRequestError, LanguageModel, LLMRequest } from "./schema/index.js";
-import { Speech, SpeechModel, SpeechRequest } from "./speech.js";
-import { Transcription, TranscriptionModel, TranscriptionRequest, } from "./transcription.js";
+import { Speech } from "./speech.js";
+import { Transcription, } from "./transcription.js";
 import { fileMediaType } from "./utils/media-type.js";
-import { Video, VideoModel, VideoRequest } from "./video.js";
+import { Video } from "./video.js";
 const abortEffect = (signal) => signal === undefined
     ? Effect.never
     : Effect.callback((resume) => {
@@ -35,12 +35,7 @@ export const make = (options = {}) => {
         refresh: (options) => run(generation.refresh(), options).then(handle),
         cancel: (options) => run(generation.cancel(), options),
     });
-    // The typed `generate`/`stream` overloads take a concrete input or a request, not the union; normalize once here.
     const llmRequest = (input) => input instanceof LLMRequest ? Effect.succeed(input) : tryRequest(() => LLM.request(input));
-    const imageRequest = (input) => input instanceof ImageRequest ? input : Image.request(input);
-    const videoRequest = (input) => input instanceof VideoRequest ? input : Video.request(input);
-    const speechRequest = (input) => input instanceof SpeechRequest ? input : Speech.request(input);
-    const transcriptionRequest = (input) => input instanceof TranscriptionRequest ? input : Transcription.request(input);
     return {
         run,
         /** Decoded asset bytes, downloading `url` sources through the executor. */
@@ -74,28 +69,28 @@ export const make = (options = {}) => {
         },
         image: {
             request: Image.request,
-            generate: (input, options) => run(Image.generate(imageRequest(input), { poll: options?.poll }), options),
-            stream: (input, options) => iterate(Image.stream(imageRequest(input), { poll: options?.poll }), options),
-            start: (input, options) => run(Image.start(imageRequest(input)), options).then(handle),
+            generate: (input, options) => run(Image.generate(input, { poll: options?.poll }), options),
+            stream: (input, options) => iterate(Image.stream(input, { poll: options?.poll }), options),
+            start: (input, options) => run(Image.start(input), options).then(handle),
             resume: (model, token, options) => run(Image.resume(model, token), options).then(handle),
         },
         video: {
             request: Video.request,
-            start: (input, options) => run(Video.start(videoRequest(input)), options).then(handle),
-            generate: (input, options) => run(Video.generate(videoRequest(input), { poll: options?.poll }), options),
+            start: (input, options) => run(Video.start(input), options).then(handle),
+            generate: (input, options) => run(Video.generate(input, { poll: options?.poll }), options),
             resume: (model, token, options) => run(Video.resume(model, token), options).then(handle),
-            stream: (input, options) => iterate(Video.stream(videoRequest(input), { poll: options?.poll }), options),
+            stream: (input, options) => iterate(Video.stream(input, { poll: options?.poll }), options),
         },
         speech: {
             request: Speech.request,
-            generate: (input, options) => run(Speech.generate(speechRequest(input)), options),
-            stream: (input, options) => iterate(Speech.stream(speechRequest(input)), options),
+            generate: (input, options) => run(Speech.generate(input), options),
+            stream: (input, options) => iterate(Speech.stream(input), options),
         },
         transcription: {
             request: Transcription.request,
-            generate: (input, options) => run(Transcription.generate(transcriptionRequest(input), { poll: options?.poll }), options),
-            stream: (input, options) => iterate(Transcription.stream(transcriptionRequest(input), { poll: options?.poll }), options),
-            start: (input, options) => run(Transcription.start(transcriptionRequest(input)), options).then(handle),
+            generate: (input, options) => run(Transcription.generate(input, { poll: options?.poll }), options),
+            stream: (input, options) => iterate(Transcription.stream(input, { poll: options?.poll }), options),
+            start: (input, options) => run(Transcription.start(input), options).then(handle),
             resume: (model, token, options) => run(Transcription.resume(model, token), options).then(handle),
         },
         dispose: () => runtime.dispose(),