@opencode/ai 2.0.15 → 2.0.16

package/dist/image.js

@@ -1,42 +1,20 @@
 import { Effect, Schema, Stream } from "effect";
+import { Generation, ProgressEvent, QueuedEvent } from "./generation.js";
 import { Media } from "./media.js";
-import { Endpoint } from "./route/endpoint.js";
+import { MediaModel, composeAnyRoute, tryRequest } from "./media-model.js";
 import { MediaRoute } from "./route/media.js";
-import { AIError, HttpOptions, InvalidRequestError, MediaUsage, ModelID, ProviderID, ProviderMetadata, } from "./schema/index.js";
+import { AIError, HttpOptions, MediaUsage, ProviderMetadata } from "./schema/index.js";
 import { ImageClient, Service } from "./image-client.js";
-export class ImageModel {
-    id;
-    provider;
-    route;
-    http;
-    constructor(input) {
-        this.id = input.id;
-        this.provider = input.provider;
-        this.route = input.route;
-        this.http = input.http;
-    }
+export class ImageModel extends MediaModel {
     static make(input) {
-        return new ImageModel({
-            id: ModelID.make(input.id),
-            provider: ProviderID.make(input.provider),
-            route: input.route,
-            http: input.http,
-        });
+        return new ImageModel(input);
     }
-    /** Compose an inline image protocol with its canonical path into a model for one deployment. */
     static fromRoute(route, input) {
-        return ImageModel.make({
+        return new ImageModel({
             id: input.id,
             provider: route.provider,
             http: input.http,
-            route: MediaRoute.make({
-                id: route.id,
-                provider: route.provider,
-                protocol: route.protocol,
-                endpoint: Endpoint.path(route.path, { baseURL: input.baseURL ?? route.baseURL }),
-                auth: input.auth,
-                headers: input.headers,
-            }),
+            route: composeAnyRoute(route, input, collectResponse),
         });
     }
 }
@@ -44,7 +22,7 @@ export const ImageModelSchema = Schema.declare((value) => value instanceof Image
     expected: "Image.Model",
 });
 export const ImageSize = Schema.declare((value) => typeof value === "string" && /^\d+x\d+$/.test(value), { title: "ImageSize" });
-export const ImageAspectRatio = Schema.declare((value) => typeof value === "string" && /^\d+(?:\.\d+)?:\d+(?:\.\d+)?$/.test(value), { title: "ImageAspectRatio" });
+export const ImageAspectRatio = Media.AspectRatio;
 export class ImageRequest extends Schema.Class("Image.Request")({
     model: ImageModelSchema,
     prompt: Schema.String,
@@ -74,6 +52,12 @@ export class ImageResponse extends Schema.Class("Image.Response")({
         return this.images[0];
     }
 }
+/** The `index`-th lower-fidelity preview of an image still generating; the `image` event supersedes it. */
+export const ImagePartialEvent = Schema.Struct({
+    type: Schema.tag("image-partial"),
+    index: Schema.Number,
+    image: Media.AssetSchema,
+}).annotate({ identifier: "Image.Event.Partial" });
 export const ImageOutputEvent = Schema.Struct({
     type: Schema.tag("image"),
     index: Schema.Number,
@@ -85,14 +69,22 @@ export const ImageFinishEvent = Schema.Struct({
     notices: Schema.optional(Schema.Array(Media.Notice)),
     providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "Image.Event.Finish" });
-const imageEventTagged = Schema.Union([ImageOutputEvent, ImageFinishEvent]).pipe(Schema.toTaggedUnion("type"));
+const imageEventTagged = Schema.Union([
+    QueuedEvent,
+    ProgressEvent,
+    ImagePartialEvent,
+    ImageOutputEvent,
+    ImageFinishEvent,
+]).pipe(Schema.toTaggedUnion("type"));
 export const ImageEvent = Object.assign(imageEventTagged, {
     is: {
+        generationQueued: imageEventTagged.guards["generation-queued"],
+        generationProgress: imageEventTagged.guards["generation-progress"],
+        imagePartial: imageEventTagged.guards["image-partial"],
         image: imageEventTagged.guards.image,
         finish: imageEventTagged.guards.finish,
     },
 });
-/** Inline routes produce every image at once; expand the response into the streaming event shape. */
 export const responseEvents = (response) => [
     ...response.images.map((image, index) => ImageOutputEvent.make({ index, image })),
     ImageFinishEvent.make({
@@ -101,6 +93,18 @@ export const responseEvents = (response) => [
         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.
+    if (finish === undefined)
+        return Effect.die(new Error("The image stream completed without a finish event"));
+    return Effect.succeed(new ImageResponse({
+        images: events.filter(ImageEvent.is.image).map((event) => event.image),
+        usage: finish.usage,
+        notices: finish.notices,
+        providerMetadata: finish.providerMetadata,
+    }));
+};
 export function request(input) {
     if (input instanceof ImageRequest)
         return input;
@@ -109,23 +113,21 @@ export function request(input) {
         http: input.http === undefined ? undefined : HttpOptions.make(input.http),
     });
 }
-const requestEffect = (input) => Effect.try({
-    try: () => request(input),
-    catch: (error) => new AIError({
-        reason: new InvalidRequestError({
-            message: error instanceof Error ? error.message : String(error),
-            cause: error,
-        }),
-    }),
-});
-export function generate(input) {
-    return requestEffect(input).pipe(Effect.flatMap((request) => ImageClient.generate(request)));
+const requestEffect = (input) => tryRequest(() => request(input));
+export function generate(input, options) {
+    return requestEffect(input).pipe(Effect.flatMap((request) => ImageClient.generate(request, options)));
+}
+export function stream(input, options) {
+    return Stream.unwrap(requestEffect(input).pipe(Effect.map((request) => ImageClient.stream(request, options))));
 }
-export function stream(input) {
-    return Stream.unwrap(requestEffect(input).pipe(Effect.map((request) => ImageClient.stream(request))));
+export function start(input) {
+    return requestEffect(input).pipe(Effect.flatMap((request) => ImageClient.start(request)));
 }
+export const resume = (model, token) => ImageClient.resume(model, token);
 export const Image = {
     request,
     generate,
     stream,
+    start,
+    resume,
 };

package/dist/index.d.ts

@@ -9,9 +9,21 @@ export * from "./schema/index.js";
 export { ImageAspectRatio, ImageEvent, ImageModel, ImageModelSchema, ImageRequest, ImageResponse, ImageSize, } from "./image.js";
 export type { ImageFormat, ImageModelOptions, ImageOptions, ImageRequestFor, ImageRequestInput, ImageRoute, } from "./image.js";
 export { Image } from "./image.js";
+export { VideoClient } from "./video-client.js";
+export { VideoAspectRatio, VideoEvent, VideoFrames, VideoModel, VideoModelSchema, VideoRequest, VideoResponse, } from "./video.js";
+export type { VideoModelOptions, VideoOptions, VideoRequestFor, VideoRequestInput, VideoResolution, VideoRoute, } from "./video.js";
+export { Video } from "./video.js";
+export { SpeechClient } from "./speech-client.js";
+export { SpeechEvent, SpeechModel, SpeechModelSchema, SpeechRequest, SpeechResponse, SpeechTimestamp, SpeechVoice, } from "./speech.js";
+export type { SpeechFormat, SpeechModelOptions, SpeechOptions, SpeechRequestFor, SpeechRequestInput, SpeechRoute, } from "./speech.js";
+export { Speech } from "./speech.js";
+export { TranscriptionClient } from "./transcription-client.js";
+export { TranscriptionEvent, TranscriptionModel, TranscriptionModelSchema, TranscriptionRequest, TranscriptionResponse, TranscriptionSegment, TranscriptionTimestamps, TranscriptionWord, } from "./transcription.js";
+export type { TranscriptionModelOptions, TranscriptionOptions, TranscriptionRequestFor, TranscriptionRequestInput, TranscriptionRoute, } from "./transcription.js";
+export { Transcription } from "./transcription.js";
 export { Media } from "./media.js";
 export { Generation } from "./generation.js";
-export type { Event as GenerationEvent, Poll, Route as GenerationRoute, Snapshot as GenerationSnapshot, Status as GenerationStatus } from "./generation.js";
+export type { AwaitOptions as GenerationAwaitOptions, Event as GenerationEvent, Poll, Route as GenerationRoute, Snapshot as GenerationSnapshot, Status as GenerationStatus, } from "./generation.js";
 export { Tool, ToolFailure, toDefinitions } from "./tool.js";
 export { ToolRuntime } from "./tool-runtime.js";
 export type { DispatchResult as ToolDispatchResult, ToolSettlement } from "./tool-runtime.js";

package/dist/index.js

@@ -7,6 +7,15 @@ export { isContextOverflow, isContextOverflowFailure } from "./provider-error.js
 export * from "./schema/index.js";
 export { ImageAspectRatio, ImageEvent, ImageModel, ImageModelSchema, ImageRequest, ImageResponse, ImageSize, } from "./image.js";
 export { Image } from "./image.js";
+export { VideoClient } from "./video-client.js";
+export { VideoAspectRatio, VideoEvent, VideoFrames, VideoModel, VideoModelSchema, VideoRequest, VideoResponse, } from "./video.js";
+export { Video } from "./video.js";
+export { SpeechClient } from "./speech-client.js";
+export { SpeechEvent, SpeechModel, SpeechModelSchema, SpeechRequest, SpeechResponse, SpeechTimestamp, SpeechVoice, } from "./speech.js";
+export { Speech } from "./speech.js";
+export { TranscriptionClient } from "./transcription-client.js";
+export { TranscriptionEvent, TranscriptionModel, TranscriptionModelSchema, TranscriptionRequest, TranscriptionResponse, TranscriptionSegment, TranscriptionTimestamps, TranscriptionWord, } from "./transcription.js";
+export { Transcription } from "./transcription.js";
 export { Media } from "./media.js";
 export { Generation } from "./generation.js";
 export { Tool, ToolFailure, toDefinitions } from "./tool.js";

package/dist/media-model.d.ts

@@ -0,0 +1,44 @@
+import { Effect } from "effect";
+import { Endpoint } from "./route/endpoint.js";
+import { MediaRoute } from "./route/media.js";
+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.
+ */
+export declare class MediaModel<Route, Options> {
+    protected readonly _Options: (options: Options) => Options;
+    readonly id: ModelID;
+    readonly provider: ProviderID;
+    readonly route: Route;
+    readonly http?: HttpOptions;
+    constructor(input: MediaModel.Input<Route>);
+}
+export declare namespace MediaModel {
+    interface Input<Route> {
+        readonly id: string | ModelID;
+        readonly provider: string | ProviderID;
+        readonly route: Route;
+        readonly http?: HttpOptions;
+    }
+    /** A protocol plus its canonical start path; `ModelInput.baseURL` overrides `baseURL` per deployment. */
+    interface RouteInput<Request extends MediaRoute.MediaRequest, Protocol> {
+        readonly id: string;
+        readonly provider: string | ProviderID;
+        readonly protocol: Protocol;
+        readonly path: Endpoint.EndpointPart<MediaProtocol.Body, Request>;
+        readonly baseURL?: string;
+        /** 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>>;
+}
+/** 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>;
+/** 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

@@ -0,0 +1,49 @@
+import { Effect } from "effect";
+import { Endpoint } from "./route/endpoint.js";
+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.
+ */
+export class MediaModel {
+    id;
+    provider;
+    route;
+    http;
+    constructor(input) {
+        this.id = ModelID.make(input.id);
+        this.provider = ProviderID.make(input.provider);
+        this.route = input.route;
+        this.http = input.http;
+    }
+}
+/** Compose a protocol route input with one deployment through `MediaRoute.inline`, `queued`, or `stream`. */
+export const composeRoute = (compose, route, input) => compose({
+    id: route.id,
+    provider: route.provider,
+    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. */
+export const tryRequest = (make) => Effect.try({
+    try: make,
+    catch: (error) => new AIError({
+        reason: new InvalidRequestError({
+            message: error instanceof Error ? error.message : String(error),
+            cause: error,
+        }),
+    }),
+});

package/dist/media.d.ts

@@ -19,8 +19,6 @@ export declare const Source: Schema.Union<readonly [Schema.Struct<{
     readonly mediaType: Schema.optional<Schema.String>;
     /** Epoch milliseconds after which the provider no longer serves the URL. */
     readonly expiresAt: Schema.optional<Schema.Number>;
-    /** Headers required to fetch the URL, such as provider auth for Veo downloads. */
-    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
 }>, Schema.Struct<{
     readonly type: Schema.Literal<"ref">;
     readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
@@ -28,6 +26,8 @@ export declare const Source: Schema.Union<readonly [Schema.Struct<{
     readonly mediaType: Schema.optional<Schema.String>;
 }>]>;
 export type Source = Schema.Schema.Type<typeof Source>;
+export type AspectRatio = `${number}:${number}`;
+export declare const AspectRatio: Schema.declare<`${number}:${number}`, `${number}:${number}`>;
 export declare const Kind: Schema.Literals<readonly ["image", "video", "audio", "document", "other"]>;
 export type Kind = Schema.Schema.Type<typeof Kind>;
 export declare const kindOf: (mediaType: string) => Kind;
@@ -65,6 +65,8 @@ export declare class Asset {
     /** Epoch milliseconds after which a `url` source stops resolving. */
     readonly expiresAt?: number;
     readonly providerMetadata?: ProviderMetadata;
+    /** Transient download credentials for `url` sources; see `Asset.Input.headers`. */
+    readonly headers?: Record<string, string>;
     constructor(input: Asset.Input);
     /** Inline payload without effects, for protocols that embed base64 or data URLs directly. */
     inline(): Inline | undefined;
@@ -84,9 +86,6 @@ export declare class Asset {
         } | {
             readonly type: "url";
             readonly url: string;
-            readonly headers?: {
-                readonly [x: string]: string;
-            } | undefined;
             readonly mediaType?: string | undefined;
             readonly expiresAt?: number | undefined;
         } | {
@@ -122,6 +121,12 @@ export declare namespace Asset {
         readonly source: Source;
         readonly info?: Info;
         readonly providerMetadata?: ProviderMetadata;
+        /**
+         * Headers required to download a `url` source, such as the provider API key Veo demands for its file URIs.
+         * They are runtime-only: never part of `source`, `toJSON()`, or `AssetSchema`, so a persisted asset cannot leak
+         * credentials and cannot be downloaded again after a round-trip. Call `materialize()` before persisting.
+         */
+        readonly headers?: Record<string, string>;
     }
 }
 /** JSON form of an asset: the serializable `Source` plus caller-supplied metadata. `bytes` sources encode as base64. */
@@ -140,8 +145,6 @@ export declare const AssetEncoded: Schema.Struct<{
         readonly mediaType: Schema.optional<Schema.String>;
         /** Epoch milliseconds after which the provider no longer serves the URL. */
         readonly expiresAt: Schema.optional<Schema.Number>;
-        /** Headers required to fetch the URL, such as provider auth for Veo downloads. */
-        readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"ref">;
         readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
@@ -175,8 +178,6 @@ export declare const AssetSchema: Schema.decodeTo<Schema.declare<Asset, Asset>,
         readonly mediaType: Schema.optional<Schema.String>;
         /** Epoch milliseconds after which the provider no longer serves the URL. */
         readonly expiresAt: Schema.optional<Schema.Number>;
-        /** Headers required to fetch the URL, such as provider auth for Veo downloads. */
-        readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"ref">;
         readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;

package/dist/media.js

@@ -27,8 +27,6 @@ const UrlSource = Schema.Struct({
     mediaType: Schema.optional(Schema.String),
     /** Epoch milliseconds after which the provider no longer serves the URL. */
     expiresAt: Schema.optional(Schema.Number),
-    /** Headers required to fetch the URL, such as provider auth for Veo downloads. */
-    headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
 });
 /** A provider-side handle: OpenAI `file_id`, Gemini file URI, `gs://`, `runway://`, or a prior generation id. */
 const RefSource = Schema.Struct({
@@ -40,9 +38,7 @@ const RefSource = Schema.Struct({
 export const Source = Schema.Union([BytesSource, Base64Source, UrlSource, RefSource])
     .pipe(Schema.toTaggedUnion("type"))
     .annotate({ identifier: "Media.Source" });
-// ---------------------------------------------------------------------------
-// Kind, Info, Notice
-// ---------------------------------------------------------------------------
+export const AspectRatio = Schema.declare((value) => typeof value === "string" && /^\d+(?:\.\d+)?:\d+(?:\.\d+)?$/.test(value), { title: "Media.AspectRatio" });
 export const Kind = Schema.Literals(["image", "video", "audio", "document", "other"]);
 export const kindOf = (mediaType) => {
     const lower = mediaType.toLowerCase();
@@ -85,6 +81,8 @@ export class Asset {
     /** Epoch milliseconds after which a `url` source stops resolving. */
     expiresAt;
     providerMetadata;
+    /** Transient download credentials for `url` sources; see `Asset.Input.headers`. */
+    headers;
     // Derived payload forms are cached on the instance because every protocol lowering re-reads the same payload. The
     // cache is check-then-set (concurrent first reads of a `url` source may both download) and is never observable
     // through `source`, so round-tripping through `Media.from(asset.source)` stays lossless.
@@ -100,6 +98,7 @@ export class Asset {
         this.info = input.info;
         this.expiresAt = input.source.type === "url" ? input.source.expiresAt : undefined;
         this.providerMetadata = input.providerMetadata;
+        this.headers = input.source.type === "url" ? input.headers : undefined;
     }
     /** Inline payload without effects, for protocols that embed base64 or data URLs directly. */
     inline() {
@@ -122,7 +121,7 @@ export class Asset {
                 return Effect.fail(invalid(`Cannot materialize provider ref ${source.provider}:${source.id}`));
             const decoded = source.type === "base64"
                 ? Effect.fromResult(Encoding.decodeBase64(source.data)).pipe(Effect.mapError((cause) => invalid(`Media asset contains invalid base64 data`, cause)))
-                : download(source);
+                : download(source, this.headers);
             return decoded.pipe(Effect.tap((data) => Effect.sync(() => (this.#bytes = data))));
         });
     }
@@ -177,9 +176,9 @@ export const AssetSchema = AssetEncoded.pipe(Schema.decodeTo(AssetInstance, {
     decode: SchemaGetter.transform((encoded) => new Asset(encoded)),
     encode: SchemaGetter.transform(encodeAsset),
 }));
-const download = Effect.fn("Media.download")(function* (source) {
+const download = Effect.fn("Media.download")(function* (source, headers) {
     const executor = yield* Service;
-    const response = yield* executor.execute(HttpClientRequest.get(source.url).pipe(HttpClientRequest.setHeaders(source.headers ?? {})));
+    const response = yield* executor.execute(HttpClientRequest.get(source.url).pipe(HttpClientRequest.setHeaders(headers ?? {})));
     const buffer = yield* response.arrayBuffer.pipe(Effect.mapError((cause) => new AIError({
         reason: new InvalidProviderOutputError({
             message: `Failed to read media from ${source.url}`,
@@ -193,8 +192,8 @@ export const from = (source, options) => new Asset({ ...options, source });
 export const bytes = (data, mediaType, options) => from({ type: "bytes", data, mediaType: mediaType ?? detectMediaType(data) ?? OCTET_STREAM }, options);
 export const base64 = (data, mediaType, options) => from({ type: "base64", data, mediaType }, options);
 export const url = (value, options) => {
-    const { mediaType, expiresAt, headers, ...rest } = options ?? {};
-    return from({ type: "url", url: value, mediaType, expiresAt, headers }, rest);
+    const { mediaType, expiresAt, ...rest } = options ?? {};
+    return from({ type: "url", url: value, mediaType, expiresAt }, rest);
 };
 export const ref = (provider, id, mediaType, options) => from({ type: "ref", provider: ProviderID.make(provider), id, mediaType }, options);
 const DATA_URL = /^data:([^;,]+)(?:;[^,]*)*;base64,(.*)$/s;