@opencode/ai 0.0.0-dev-20061 → 0.0.0-dev-20065

package/dist/image.d.ts

@@ -1,4 +1,5 @@
 import { Effect, Schema, Stream } from "effect";
+import { Generation, type AwaitOptions } from "./generation.js";
 import { Media } from "./media.js";
 import { MediaModel } from "./media-model.js";
 import { MediaRoute } from "./route/media.js";
@@ -6,15 +7,20 @@ import type { MediaProtocol } from "./route/media-protocol.js";
 import { AIError, HttpOptions } from "./schema/index.js";
 import { Service } from "./image-client.js";
 export type ImageOptions = Record<string, unknown>;
-export type ImageRoute<Options extends ImageOptions = ImageOptions> = MediaRoute.Route<ImageRequestFor<Options>, ImageResponse>;
+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> {
     protected readonly _ImageModel: void;
     static make<Options extends ImageOptions = ImageOptions>(input: MediaModel.Input<ImageRoute<Options>>): ImageModel<Options>;
-    /** Compose an inline image protocol with its canonical path into a model for one deployment. */
-    static fromRoute<Options extends ImageOptions = ImageOptions>(route: ImageModel.RouteInput<Options>, input: MediaRoute.ModelInput): 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>;
 }
 export declare namespace ImageModel {
-    type RouteInput<Options extends ImageOptions = ImageOptions> = MediaModel.RouteInput<ImageRequestFor<Options>, MediaProtocol.Inline<ImageRequestFor<Options>, ImageResponse>>;
+    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 type ImageSize = `${number}x${number}`;
@@ -172,6 +178,42 @@ declare const ImageResponse_base: Schema.Class<ImageResponse, Schema.Struct<{
 export declare class ImageResponse extends ImageResponse_base {
     get image(): Media.Asset;
 }
+/** The `index`-th lower-fidelity preview of an image still generating; the `image` event supersedes it. */
+export declare const ImagePartialEvent: Schema.Struct<{
+    readonly type: Schema.tag<"image-partial">;
+    readonly index: Schema.Number;
+    readonly image: Schema.decodeTo<Schema.declare<Media.Asset, Media.Asset>, Schema.Struct<{
+        readonly source: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"bytes">;
+            readonly data: Schema.Uint8Array;
+            readonly mediaType: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"base64">;
+            readonly data: Schema.String;
+            readonly mediaType: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"url">;
+            readonly url: Schema.String;
+            readonly mediaType: Schema.optional<Schema.String>;
+            readonly expiresAt: Schema.optional<Schema.Number>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"ref">;
+            readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
+            readonly id: Schema.String;
+            readonly mediaType: Schema.optional<Schema.String>;
+        }>]>;
+        readonly info: Schema.optional<Schema.Struct<{
+            readonly width: Schema.optional<Schema.Number>;
+            readonly height: Schema.optional<Schema.Number>;
+            readonly durationSeconds: Schema.optional<Schema.Number>;
+            readonly sampleRate: Schema.optional<Schema.Number>;
+            readonly channels: Schema.optional<Schema.Number>;
+            readonly encoding: Schema.optional<Schema.String>;
+            readonly format: Schema.optional<Schema.String>;
+        }>>;
+        readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    }>, never, never>;
+}>;
 export declare const ImageOutputEvent: Schema.Struct<{
     readonly type: Schema.tag<"image">;
     readonly index: Schema.Number;
@@ -236,6 +278,48 @@ export declare const ImageFinishEvent: Schema.Struct<{
     readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
 }>;
 declare const imageEventTagged: Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
+    readonly type: Schema.tag<"generation-queued">;
+    readonly id: Schema.String;
+    readonly position: Schema.optional<Schema.Number>;
+}>, Schema.Struct<{
+    readonly type: Schema.tag<"generation-progress">;
+    readonly id: Schema.String;
+    readonly progress: Schema.optional<Schema.Number>;
+}>, Schema.Struct<{
+    readonly type: Schema.tag<"image-partial">;
+    readonly index: Schema.Number;
+    readonly image: Schema.decodeTo<Schema.declare<Media.Asset, Media.Asset>, Schema.Struct<{
+        readonly source: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"bytes">;
+            readonly data: Schema.Uint8Array;
+            readonly mediaType: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"base64">;
+            readonly data: Schema.String;
+            readonly mediaType: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"url">;
+            readonly url: Schema.String;
+            readonly mediaType: Schema.optional<Schema.String>;
+            readonly expiresAt: Schema.optional<Schema.Number>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"ref">;
+            readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
+            readonly id: Schema.String;
+            readonly mediaType: Schema.optional<Schema.String>;
+        }>]>;
+        readonly info: Schema.optional<Schema.Struct<{
+            readonly width: Schema.optional<Schema.Number>;
+            readonly height: Schema.optional<Schema.Number>;
+            readonly durationSeconds: Schema.optional<Schema.Number>;
+            readonly sampleRate: Schema.optional<Schema.Number>;
+            readonly channels: Schema.optional<Schema.Number>;
+            readonly encoding: Schema.optional<Schema.String>;
+            readonly format: Schema.optional<Schema.String>;
+        }>>;
+        readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    }>, never, never>;
+}>, Schema.Struct<{
     readonly type: Schema.tag<"image">;
     readonly index: Schema.Number;
     readonly image: Schema.decodeTo<Schema.declare<Media.Asset, Media.Asset>, Schema.Struct<{
@@ -298,6 +382,48 @@ declare const imageEventTagged: Schema.toTaggedUnion<"type", readonly [Schema.St
     readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
 }>]>;
 export declare const ImageEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.tag<"generation-queued">;
+    readonly id: Schema.String;
+    readonly position: Schema.optional<Schema.Number>;
+}>, Schema.Struct<{
+    readonly type: Schema.tag<"generation-progress">;
+    readonly id: Schema.String;
+    readonly progress: Schema.optional<Schema.Number>;
+}>, Schema.Struct<{
+    readonly type: Schema.tag<"image-partial">;
+    readonly index: Schema.Number;
+    readonly image: Schema.decodeTo<Schema.declare<Media.Asset, Media.Asset>, Schema.Struct<{
+        readonly source: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"bytes">;
+            readonly data: Schema.Uint8Array;
+            readonly mediaType: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"base64">;
+            readonly data: Schema.String;
+            readonly mediaType: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"url">;
+            readonly url: Schema.String;
+            readonly mediaType: Schema.optional<Schema.String>;
+            readonly expiresAt: Schema.optional<Schema.Number>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"ref">;
+            readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
+            readonly id: Schema.String;
+            readonly mediaType: Schema.optional<Schema.String>;
+        }>]>;
+        readonly info: Schema.optional<Schema.Struct<{
+            readonly width: Schema.optional<Schema.Number>;
+            readonly height: Schema.optional<Schema.Number>;
+            readonly durationSeconds: Schema.optional<Schema.Number>;
+            readonly sampleRate: Schema.optional<Schema.Number>;
+            readonly channels: Schema.optional<Schema.Number>;
+            readonly encoding: Schema.optional<Schema.String>;
+            readonly format: Schema.optional<Schema.String>;
+        }>>;
+        readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    }>, never, never>;
+}>, Schema.Struct<{
     readonly type: Schema.tag<"image">;
     readonly index: Schema.Number;
     readonly image: Schema.decodeTo<Schema.declare<Media.Asset, Media.Asset>, Schema.Struct<{
@@ -359,8 +485,53 @@ export declare const ImageEvent: Schema.Union<readonly [Schema.Struct<{
     }>>>;
     readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
 }>]> & {
-    readonly discriminants: readonly ["image", "finish"];
+    readonly discriminants: readonly ["generation-queued", "generation-progress", "image-partial", "image", "finish"];
     readonly cases: {
+        "generation-queued": Schema.Struct<{
+            readonly type: Schema.tag<"generation-queued">;
+            readonly id: Schema.String;
+            readonly position: Schema.optional<Schema.Number>;
+        }>;
+        "generation-progress": Schema.Struct<{
+            readonly type: Schema.tag<"generation-progress">;
+            readonly id: Schema.String;
+            readonly progress: Schema.optional<Schema.Number>;
+        }>;
+        "image-partial": Schema.Struct<{
+            readonly type: Schema.tag<"image-partial">;
+            readonly index: Schema.Number;
+            readonly image: Schema.decodeTo<Schema.declare<Media.Asset, Media.Asset>, Schema.Struct<{
+                readonly source: Schema.Union<readonly [Schema.Struct<{
+                    readonly type: Schema.Literal<"bytes">;
+                    readonly data: Schema.Uint8Array;
+                    readonly mediaType: Schema.String;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"base64">;
+                    readonly data: Schema.String;
+                    readonly mediaType: Schema.String;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"url">;
+                    readonly url: Schema.String;
+                    readonly mediaType: Schema.optional<Schema.String>;
+                    readonly expiresAt: Schema.optional<Schema.Number>;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"ref">;
+                    readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
+                    readonly id: Schema.String;
+                    readonly mediaType: Schema.optional<Schema.String>;
+                }>]>;
+                readonly info: Schema.optional<Schema.Struct<{
+                    readonly width: Schema.optional<Schema.Number>;
+                    readonly height: Schema.optional<Schema.Number>;
+                    readonly durationSeconds: Schema.optional<Schema.Number>;
+                    readonly sampleRate: Schema.optional<Schema.Number>;
+                    readonly channels: Schema.optional<Schema.Number>;
+                    readonly encoding: Schema.optional<Schema.String>;
+                    readonly format: Schema.optional<Schema.String>;
+                }>>;
+                readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+            }>, never, never>;
+        }>;
         image: Schema.Struct<{
             readonly type: Schema.tag<"image">;
             readonly index: Schema.Number;
@@ -426,6 +597,18 @@ export declare const ImageEvent: Schema.Union<readonly [Schema.Struct<{
         }>;
     };
     readonly isAnyOf: <const Keys>(keys: readonly Keys[]) => (value: {
+        readonly id: string;
+        readonly type: "generation-queued";
+        readonly position?: number | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "generation-progress";
+        readonly progress?: number | undefined;
+    } | {
+        readonly type: "image-partial";
+        readonly index: number;
+        readonly image: Media.Asset;
+    } | {
         readonly type: "image";
         readonly index: number;
         readonly image: Media.Asset;
@@ -467,6 +650,24 @@ export declare const ImageEvent: Schema.Union<readonly [Schema.Struct<{
             } | undefined;
         }[] | undefined;
     }) => value is Extract<{
+        readonly id: string;
+        readonly type: "generation-queued";
+        readonly position?: number | undefined;
+    }, {
+        readonly type: Keys;
+    }> | Extract<{
+        readonly id: string;
+        readonly type: "generation-progress";
+        readonly progress?: number | undefined;
+    }, {
+        readonly type: Keys;
+    }> | Extract<{
+        readonly type: "image-partial";
+        readonly index: number;
+        readonly image: Media.Asset;
+    }, {
+        readonly type: Keys;
+    }> | Extract<{
         readonly type: "image";
         readonly index: number;
         readonly image: Media.Asset;
@@ -513,6 +714,21 @@ export declare const ImageEvent: Schema.Union<readonly [Schema.Struct<{
         readonly type: Keys;
     }>;
     readonly guards: {
+        "generation-queued": (u: unknown) => u is {
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        };
+        "generation-progress": (u: unknown) => u is {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        };
+        "image-partial": (u: unknown) => u is {
+            readonly type: "image-partial";
+            readonly index: number;
+            readonly image: Media.Asset;
+        };
         image: (u: unknown) => u is {
             readonly type: "image";
             readonly index: number;
@@ -559,6 +775,21 @@ export declare const ImageEvent: Schema.Union<readonly [Schema.Struct<{
     };
     readonly match: {
         <Cases extends {
+            "generation-queued": (value: {
+                readonly id: string;
+                readonly type: "generation-queued";
+                readonly position?: number | undefined;
+            }) => any;
+            "generation-progress": (value: {
+                readonly id: string;
+                readonly type: "generation-progress";
+                readonly progress?: number | undefined;
+            }) => any;
+            "image-partial": (value: {
+                readonly type: "image-partial";
+                readonly index: number;
+                readonly image: Media.Asset;
+            }) => any;
             image: (value: {
                 readonly type: "image";
                 readonly index: number;
@@ -603,6 +834,18 @@ export declare const ImageEvent: Schema.Union<readonly [Schema.Struct<{
                 }[] | undefined;
             }) => any;
         }>(value: {
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        } | {
+            readonly type: "image-partial";
+            readonly index: number;
+            readonly image: Media.Asset;
+        } | {
             readonly type: "image";
             readonly index: number;
             readonly image: Media.Asset;
@@ -645,6 +888,21 @@ export declare const ImageEvent: Schema.Union<readonly [Schema.Struct<{
             }[] | undefined;
         }, cases: Cases): Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
         <Cases extends {
+            "generation-queued": (value: {
+                readonly id: string;
+                readonly type: "generation-queued";
+                readonly position?: number | undefined;
+            }) => any;
+            "generation-progress": (value: {
+                readonly id: string;
+                readonly type: "generation-progress";
+                readonly progress?: number | undefined;
+            }) => any;
+            "image-partial": (value: {
+                readonly type: "image-partial";
+                readonly index: number;
+                readonly image: Media.Asset;
+            }) => any;
             image: (value: {
                 readonly type: "image";
                 readonly index: number;
@@ -689,6 +947,18 @@ export declare const ImageEvent: Schema.Union<readonly [Schema.Struct<{
                 }[] | undefined;
             }) => any;
         }>(cases: Cases): (value: {
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        } | {
+            readonly type: "image-partial";
+            readonly index: number;
+            readonly image: Media.Asset;
+        } | {
             readonly type: "image";
             readonly index: number;
             readonly image: Media.Asset;
@@ -733,6 +1003,21 @@ export declare const ImageEvent: Schema.Union<readonly [Schema.Struct<{
     };
     readonly matchOrElse: {
         <Cases extends {
+            "generation-queued"?: ((value: {
+                readonly id: string;
+                readonly type: "generation-queued";
+                readonly position?: number | undefined;
+            }) => any) | undefined;
+            "generation-progress"?: ((value: {
+                readonly id: string;
+                readonly type: "generation-progress";
+                readonly progress?: number | undefined;
+            }) => any) | undefined;
+            "image-partial"?: ((value: {
+                readonly type: "image-partial";
+                readonly index: number;
+                readonly image: Media.Asset;
+            }) => any) | undefined;
             image?: ((value: {
                 readonly type: "image";
                 readonly index: number;
@@ -776,7 +1061,25 @@ export declare const ImageEvent: Schema.Union<readonly [Schema.Struct<{
                     } | undefined;
                 }[] | undefined;
             }) => any) | undefined;
-        } & { [K in Exclude<keyof Cases, "image" | "finish">]: never; }, OrElse extends (value: Exclude<{
+        } & { [K in Exclude<keyof Cases, "image" | "finish" | "generation-queued" | "generation-progress" | "image-partial">]: never; }, OrElse extends (value: Exclude<{
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        }, {
+            readonly type: keyof Cases;
+        }> | Exclude<{
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        }, {
+            readonly type: keyof Cases;
+        }> | Exclude<{
+            readonly type: "image-partial";
+            readonly index: number;
+            readonly image: Media.Asset;
+        }, {
+            readonly type: keyof Cases;
+        }> | Exclude<{
             readonly type: "image";
             readonly index: number;
             readonly image: Media.Asset;
@@ -822,6 +1125,18 @@ export declare const ImageEvent: Schema.Union<readonly [Schema.Struct<{
         }, {
             readonly type: keyof Cases;
         }>) => any>(value: {
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        } | {
+            readonly type: "image-partial";
+            readonly index: number;
+            readonly image: Media.Asset;
+        } | {
             readonly type: "image";
             readonly index: number;
             readonly image: Media.Asset;
@@ -864,6 +1179,21 @@ export declare const ImageEvent: Schema.Union<readonly [Schema.Struct<{
             }[] | undefined;
         }, cases: Cases, orElse: OrElse): import("effect/Unify").Unify<{ [K_1 in keyof Cases]-?: NonNullable<Cases[K_1]> extends (...args: Array<any>) => infer R ? R : never; }[keyof Cases] | ReturnType<OrElse>>;
         <Cases extends {
+            "generation-queued"?: ((value: {
+                readonly id: string;
+                readonly type: "generation-queued";
+                readonly position?: number | undefined;
+            }) => any) | undefined;
+            "generation-progress"?: ((value: {
+                readonly id: string;
+                readonly type: "generation-progress";
+                readonly progress?: number | undefined;
+            }) => any) | undefined;
+            "image-partial"?: ((value: {
+                readonly type: "image-partial";
+                readonly index: number;
+                readonly image: Media.Asset;
+            }) => any) | undefined;
             image?: ((value: {
                 readonly type: "image";
                 readonly index: number;
@@ -907,7 +1237,25 @@ export declare const ImageEvent: Schema.Union<readonly [Schema.Struct<{
                     } | undefined;
                 }[] | undefined;
             }) => any) | undefined;
-        } & { [K in Exclude<keyof Cases, "image" | "finish">]: never; }, OrElse extends (value: Exclude<{
+        } & { [K in Exclude<keyof Cases, "image" | "finish" | "generation-queued" | "generation-progress" | "image-partial">]: never; }, OrElse extends (value: Exclude<{
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        }, {
+            readonly type: keyof Cases;
+        }> | Exclude<{
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        }, {
+            readonly type: keyof Cases;
+        }> | Exclude<{
+            readonly type: "image-partial";
+            readonly index: number;
+            readonly image: Media.Asset;
+        }, {
+            readonly type: keyof Cases;
+        }> | Exclude<{
             readonly type: "image";
             readonly index: number;
             readonly image: Media.Asset;
@@ -953,6 +1301,18 @@ export declare const ImageEvent: Schema.Union<readonly [Schema.Struct<{
         }, {
             readonly type: keyof Cases;
         }>) => any>(cases: Cases, orElse: OrElse): (value: {
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        } | {
+            readonly type: "image-partial";
+            readonly index: number;
+            readonly image: Media.Asset;
+        } | {
             readonly type: "image";
             readonly index: number;
             readonly image: Media.Asset;
@@ -997,6 +1357,21 @@ export declare const ImageEvent: Schema.Union<readonly [Schema.Struct<{
     };
 } & {
     is: {
+        generationQueued: (u: unknown) => u is {
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        };
+        generationProgress: (u: unknown) => u is {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        };
+        imagePartial: (u: unknown) => u is {
+            readonly type: "image-partial";
+            readonly index: number;
+            readonly image: Media.Asset;
+        };
         image: (u: unknown) => u is {
             readonly type: "image";
             readonly index: number;
@@ -1043,17 +1418,22 @@ export declare const ImageEvent: Schema.Union<readonly [Schema.Struct<{
     };
 };
 export type ImageEvent = Schema.Schema.Type<typeof imageEventTagged>;
-/** Inline routes produce every image at once; expand the response into the streaming event shape. */
 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>): Effect.Effect<ImageResponse, AIError, Service>;
-export declare function generate(input: ImageRequest): Effect.Effect<ImageResponse, AIError, Service>;
-export declare function stream<const Model extends ImageModel>(input: ImageRequestInput<Model>): Stream.Stream<ImageEvent, AIError, Service>;
-export declare function stream(input: ImageRequest): Stream.Stream<ImageEvent, AIError, Service>;
+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>;
+/** 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 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>;
 };
 export {};

package/dist/image.js

@@ -1,6 +1,7 @@
 import { Effect, Schema, Stream } from "effect";
+import { Generation, ProgressEvent, QueuedEvent } from "./generation.js";
 import { Media } from "./media.js";
-import { MediaModel, composeRoute, tryRequest } from "./media-model.js";
+import { MediaModel, composeAnyRoute, 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";
@@ -8,13 +9,12 @@ export class ImageModel extends MediaModel {
     static make(input) {
         return new ImageModel(input);
     }
-    /** Compose an inline image protocol with its canonical path into a model for one deployment. */
     static fromRoute(route, input) {
         return new ImageModel({
             id: input.id,
             provider: route.provider,
             http: input.http,
-            route: composeRoute(MediaRoute.inline, route, input),
+            route: composeAnyRoute(route, input, collectResponse),
         });
     }
 }
@@ -52,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,
@@ -63,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({
@@ -79,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;
@@ -88,14 +114,20 @@ export function request(input) {
     });
 }
 const requestEffect = (input) => tryRequest(() => request(input));
-export function generate(input) {
-    return requestEffect(input).pipe(Effect.flatMap((request) => ImageClient.generate(request)));
+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,
 };