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

package/dist/protocols/openai-images.d.ts

@@ -1,6 +1,8 @@
-import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js";
+import { ImageModel, type ImageRequestFor } from "../image.js";
+import { Media } from "../media.js";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
+import { type MediaUsage } from "../schema/index.js";
 export declare const DEFAULT_BASE_URL = "https://api.openai.com/v1";
 export declare const PATH = "/images/generations";
 export declare const EDIT_PATH = "/images/edits";
@@ -11,11 +13,130 @@ export type OpenAIImageOptions = {
     readonly background?: OpenAIImageString<"auto" | "opaque" | "transparent">;
     readonly moderation?: OpenAIImageString<"auto" | "low">;
     readonly outputCompression?: number;
+    /** Previews sent before the final image when streaming (default 2); ignored by `Image.generate`. */
+    readonly partialImages?: number;
 } & Record<string, unknown>;
 export type Request = ImageRequestFor<OpenAIImageOptions>;
-export declare const protocol: MediaProtocol.Inline<Request, ImageResponse>;
+/** `generate` reads the whole JSON response as one frame, with the requested format for responses that omit it. */
+type Frame = string | {
+    readonly document: string;
+    readonly requested: string | undefined;
+};
+interface State {
+    readonly completed: number;
+    readonly format?: string;
+    readonly usage?: MediaUsage;
+}
+export declare const protocol: MediaProtocol.Streamed<Request, {
+    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;
+} | {
+    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;
+}, Frame, State>;
 export declare const model: (input: MediaRoute.ModelInput) => ImageModel<OpenAIImageOptions>;
 export declare const OpenAIImages: {
-    readonly protocol: MediaProtocol.Inline<Request, ImageResponse>;
+    readonly protocol: MediaProtocol.Streamed<Request, {
+        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;
+    } | {
+        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;
+    }, Frame, State>;
     readonly model: (input: MediaRoute.ModelInput) => ImageModel<OpenAIImageOptions>;
 };
+export {};

package/dist/protocols/openai-images.js

@@ -1,6 +1,7 @@
-import { Effect, Schema } from "effect";
-import { ImageModel, ImageResponse } from "../image.js";
+import { Effect, Schema, Stream } from "effect";
+import { ImageFinishEvent, ImageModel, ImageOutputEvent, ImagePartialEvent, } from "../image.js";
 import { Media } from "../media.js";
+import { Framing } from "../route/framing.js";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
 import { ProviderID, mergeJsonRecords } from "../schema/index.js";
@@ -15,6 +16,13 @@ export const EDIT_PATH = "/images/edits";
 // ---------------------------------------------------------------------------
 // 2. Response schema
 // ---------------------------------------------------------------------------
+const Usage = Schema.Struct({
+    input_tokens: Schema.optional(Schema.Number),
+    output_tokens: Schema.optional(Schema.Number),
+    total_tokens: Schema.optional(Schema.Number),
+    input_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    output_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+});
 const OpenAIImageResponse = Schema.Struct({
     data: Schema.Array(Schema.Struct({
         b64_json: Schema.optional(Schema.String),
@@ -22,15 +30,28 @@ const OpenAIImageResponse = Schema.Struct({
         revised_prompt: Schema.optional(Schema.String),
     })),
     output_format: Schema.optional(Schema.String),
-    usage: Schema.optional(Schema.Struct({
-        input_tokens: Schema.optional(Schema.Number),
-        output_tokens: Schema.optional(Schema.Number),
-        total_tokens: Schema.optional(Schema.Number),
-        input_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-        output_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-    })),
+    usage: Schema.optional(Usage),
 });
 // ---------------------------------------------------------------------------
+// 3. Streaming event schema
+// ---------------------------------------------------------------------------
+const StreamEvent = Schema.Union([
+    Schema.Struct({
+        type: Schema.Literals(["image_generation.partial_image", "image_edit.partial_image"]),
+        b64_json: Schema.String,
+        partial_image_index: Schema.Number,
+        output_format: Schema.String,
+    }),
+    Schema.Struct({
+        type: Schema.Literals(["image_generation.completed", "image_edit.completed"]),
+        b64_json: Schema.String,
+        output_format: Schema.String,
+        usage: Schema.optional(Usage),
+    }),
+]);
+const decodeEvent = MediaProtocol.decodeFrame(ADAPTER, NAME, StreamEvent);
+const decodeDocument = Schema.decodeUnknownEffect(Schema.fromJsonString(OpenAIImageResponse));
+// ---------------------------------------------------------------------------
 // 5. Request body construction
 // ---------------------------------------------------------------------------
 /** Multipart field names the route owns; `http.body` overlays cannot smuggle replacements for them. */
@@ -38,18 +59,37 @@ const RESERVED_FORM_FIELDS = new Set(["model", "prompt", "image", "image[]", "im
 const nativeOptions = (options) => {
     if (!options)
         return undefined;
-    const { outputCompression, ...native } = options;
+    const { outputCompression, partialImages: _, ...native } = options;
     return { output_compression: outputCompression, ...native };
 };
+const streamOptions = (request) => {
+    if (request.mode !== "stream")
+        return Effect.succeed(undefined);
+    if (request.model.id.startsWith("dall-e"))
+        return Effect.fail(ProviderShared.unsupportedOperation({
+            operation: "media.stream",
+            provider: PROVIDER,
+            route: ADAPTER,
+            message: `${request.model.id} does not stream; use Image.generate or a GPT image model`,
+        }));
+    if (request.n !== undefined && request.n > 1)
+        return Effect.fail(ProviderShared.unsupportedOperation({
+            operation: "media.n",
+            provider: PROVIDER,
+            route: ADAPTER,
+            message: `${NAME} streams one image; use Image.generate for n=${request.n}`,
+        }));
+    return Effect.succeed({ stream: true, partial_images: request.providerOptions?.partialImages ?? 2 });
+};
 const isEdit = (request) => (request.images?.length ?? 0) > 0;
-const isInline = (asset) => asset.inline() !== undefined;
+const isInline = (asset) => asset.source.type === "bytes" || asset.source.type === "base64";
 const reference = (asset) => ProviderShared.mediaReference(asset, PROVIDER, NAME).pipe(Effect.map((item) => (item.type === "ref" ? { file_id: item.value } : { image_url: item.value })));
 const fromRequest = Effect.fn("OpenAIImages.fromRequest")(function* (request) {
     const images = request.images ?? [];
     const mask = request.mask;
     if (mask !== undefined && images.length === 0)
         return yield* ProviderShared.invalidRequest("An OpenAI image mask requires at least one input image");
-    const fields = mergeJsonRecords({ n: request.n, size: request.size, output_format: request.format }, nativeOptions(request.providerOptions), request.http?.body);
+    const fields = mergeJsonRecords({ n: request.n, size: request.size, output_format: request.format, ...(yield* streamOptions(request)) }, nativeOptions(request.providerOptions), request.http?.body);
     // Owned bytes go through multipart edits; remote URLs and file IDs use the JSON edits body instead.
     if (images.length > 0 && images.every(isInline) && (mask === undefined || isInline(mask))) {
         const form = new FormData();
@@ -76,7 +116,7 @@ const fromRequest = Effect.fn("OpenAIImages.fromRequest")(function* (request) {
     }, fields) ?? {});
 });
 // ---------------------------------------------------------------------------
-// 6. Response decoding
+// 6. Stream parsing
 // ---------------------------------------------------------------------------
 const requestedFormat = (body) => {
     if (body.type === "binary")
@@ -84,47 +124,74 @@ const requestedFormat = (body) => {
     const value = body.type === "json" ? body.value.output_format : body.value.get("output_format");
     return typeof value === "string" ? value : undefined;
 };
-const decodeResponse = Effect.fn("OpenAIImages.decodeResponse")(function* (response, context) {
-    const output = yield* MediaProtocol.decodeJson(ADAPTER, NAME, OpenAIImageResponse)(response);
-    const decoded = output.value;
-    const format = decoded.output_format ?? requestedFormat(context.body) ?? "png";
+const usage = (value) => value === undefined
+    ? undefined
+    : {
+        type: "tokens",
+        input: value.input_tokens,
+        output: value.output_tokens,
+        total: value.total_tokens,
+        details: { openai: value },
+    };
+const eventImage = (frame, label, data, format) => MediaInput.decodedAsset((message, cause) => MediaProtocol.frameError(ADAPTER, message, frame, cause), label, data, `image/${format}`, { info: { format } });
+const onEvent = Effect.fn("OpenAIImages.onEvent")(function* (state, frame) {
+    const event = yield* decodeEvent(frame);
+    const format = event.output_format;
+    if ("partial_image_index" in event) {
+        const image = yield* eventImage(frame, `${NAME} partial image`, event.b64_json, format);
+        return [state, [ImagePartialEvent.make({ index: event.partial_image_index, image })]];
+    }
+    const image = yield* eventImage(frame, `${NAME} result ${state.completed}`, event.b64_json, format);
+    return [
+        { ...state, completed: state.completed + 1, format, usage: usage(event.usage) },
+        [ImageOutputEvent.make({ index: state.completed, image })],
+    ];
+});
+const onDocument = Effect.fn("OpenAIImages.onDocument")(function* (frame) {
+    const invalid = (message, cause) => MediaProtocol.frameError(ADAPTER, message, frame.document, cause);
+    const decoded = yield* decodeDocument(frame.document).pipe(Effect.mapError((cause) => invalid(`${NAME} returned an invalid response`, cause)));
+    const format = decoded.output_format ?? frame.requested ?? "png";
     const mediaType = `image/${format}`;
     const images = yield* Effect.forEach(decoded.data, (item, index) => {
         const providerMetadata = item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } };
         if (item.b64_json)
-            return MediaInput.decodedAsset(output.invalid, `${NAME} result ${index}`, item.b64_json, mediaType, {
+            return MediaInput.decodedAsset(invalid, `${NAME} result ${index}`, item.b64_json, mediaType, {
                 info: { format },
                 providerMetadata,
             });
         if (item.url)
             return Effect.succeed(Media.url(item.url, { mediaType, info: { format }, providerMetadata }));
-        return Effect.fail(output.invalid(`${NAME} result ${index} has neither image data nor a URL`));
+        return Effect.fail(invalid(`${NAME} result ${index} has neither image data nor a URL`));
     });
     if (images.length === 0)
-        return yield* output.invalid(`${NAME} returned no images`);
-    return new ImageResponse({
-        images,
-        usage: decoded.usage === undefined
-            ? undefined
-            : {
-                type: "tokens",
-                input: decoded.usage.input_tokens,
-                output: decoded.usage.output_tokens,
-                total: decoded.usage.total_tokens,
-                details: { openai: decoded.usage },
-            },
-        providerMetadata: { openai: { outputFormat: format } },
-    });
+        return yield* invalid(`${NAME} returned no images`);
+    const state = { completed: images.length, format, usage: usage(decoded.usage) };
+    return [state, images.map((image, index) => ImageOutputEvent.make({ index, image }))];
 });
+const step = (state, frame) => (typeof frame === "string" ? onEvent(state, frame) : onDocument(frame));
+const finish = (state) => {
+    if (state.completed === 0)
+        return Effect.fail(MediaProtocol.incomplete(ADAPTER));
+    return Effect.succeed([
+        ImageFinishEvent.make({ usage: state.usage, providerMetadata: { openai: { outputFormat: state.format } } }),
+    ]);
+};
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.inline({
+export const protocol = MediaProtocol.stream({
     id: ADAPTER,
     name: NAME,
     unsupported: ["aspectRatio", "seed"],
     body: { from: fromRequest },
-    response: { decode: decodeResponse },
+    frames: (bytes, context) => context.request.mode === "stream"
+        ? Framing.sse.frame(bytes)
+        : Framing.document
+            .frame(bytes)
+            .pipe(Stream.map((document) => ({ document, requested: requestedFormat(context.body) }))),
+    initial: () => ({ completed: 0 }),
+    step,
+    finish,
 });
 export const model = (input) => ImageModel.fromRoute({
     id: ADAPTER,

package/dist/protocols/openai-responses.d.ts

@@ -390,11 +390,11 @@ export declare const protocol: Protocol<{
         readonly size?: string | undefined;
         readonly action?: "generate" | "auto" | "edit" | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+        readonly partial_images?: number | undefined;
         readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
         readonly background?: "auto" | "opaque" | "transparent" | undefined;
         readonly output_compression?: number | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
-        readonly partial_images?: number | undefined;
     } | {
         readonly type: "namespace";
         readonly name: string;
@@ -673,11 +673,11 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         readonly size?: string | undefined;
         readonly action?: "generate" | "auto" | "edit" | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+        readonly partial_images?: number | undefined;
         readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
         readonly background?: "auto" | "opaque" | "transparent" | undefined;
         readonly output_compression?: number | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
-        readonly partial_images?: number | undefined;
     } | {
         readonly type: "namespace";
         readonly name: string;
@@ -901,11 +901,11 @@ export declare const channelTransport: (options: import("./open-responses-channe
         readonly size?: string | undefined;
         readonly action?: "generate" | "auto" | "edit" | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+        readonly partial_images?: number | undefined;
         readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
         readonly background?: "auto" | "opaque" | "transparent" | undefined;
         readonly output_compression?: number | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
-        readonly partial_images?: number | undefined;
     } | {
         readonly type: "namespace";
         readonly name: string;
@@ -1129,11 +1129,11 @@ export declare const transport: import("../route/transport/index.js").Transport<
         readonly size?: string | undefined;
         readonly action?: "generate" | "auto" | "edit" | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+        readonly partial_images?: number | undefined;
         readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
         readonly background?: "auto" | "opaque" | "transparent" | undefined;
         readonly output_compression?: number | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
-        readonly partial_images?: number | undefined;
     } | {
         readonly type: "namespace";
         readonly name: string;
@@ -1357,11 +1357,11 @@ export declare const route: Route<{
         readonly size?: string | undefined;
         readonly action?: "generate" | "auto" | "edit" | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+        readonly partial_images?: number | undefined;
         readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
         readonly background?: "auto" | "opaque" | "transparent" | undefined;
         readonly output_compression?: number | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
-        readonly partial_images?: number | undefined;
     } | {
         readonly type: "namespace";
         readonly name: string;

package/dist/protocols/replicate-images.d.ts

@@ -0,0 +1,28 @@
+import { Schema } from "effect";
+import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+export declare const DEFAULT_BASE_URL = "https://api.replicate.com";
+/** Model-defined `input` fields under the model's own names; `Media.Asset` values lower to URLs or data URLs. */
+export type ReplicateImageOptions = Record<string, unknown>;
+export type Request = ImageRequestFor<ReplicateImageOptions>;
+export declare const Token: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly getURL: Schema.String;
+    readonly cancelURL: Schema.String;
+}>;
+export type Token = Schema.Schema.Type<typeof Token>;
+export declare const protocol: MediaProtocol.Queued<Request, ImageResponse, {
+    readonly id: string;
+    readonly getURL: string;
+    readonly cancelURL: string;
+}>;
+export declare const model: (input: MediaRoute.ModelInput) => ImageModel<ReplicateImageOptions>;
+export declare const ReplicateImages: {
+    readonly protocol: MediaProtocol.Queued<Request, ImageResponse, {
+        readonly id: string;
+        readonly getURL: string;
+        readonly cancelURL: string;
+    }>;
+    readonly model: (input: MediaRoute.ModelInput) => ImageModel<ReplicateImageOptions>;
+};

package/dist/protocols/replicate-images.js

@@ -0,0 +1,133 @@
+import { Duration, Effect, Schema } from "effect";
+import { ImageModel, ImageResponse } from "../image.js";
+import { Media } from "../media.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { ProviderShared, optionalNull } from "./shared.js";
+const ADAPTER = "replicate-images";
+const NAME = "Replicate";
+const PROVIDER = ProviderID.make("replicate");
+export const DEFAULT_BASE_URL = "https://api.replicate.com";
+const OUTPUT_RETENTION = Duration.hours(1);
+const MAX_DATA_URL_BYTES = 256 * 1024;
+// ---------------------------------------------------------------------------
+// 2. Token and response schemas
+// ---------------------------------------------------------------------------
+export const Token = Schema.Struct({ id: Schema.String, getURL: Schema.String, cancelURL: Schema.String });
+const Prediction = Schema.Struct({
+    id: Schema.String,
+    status: Schema.String,
+    output: optionalNull(Schema.Unknown),
+    error: optionalNull(Schema.Unknown),
+    data_removed: optionalNull(Schema.Boolean),
+    completed_at: optionalNull(Schema.String),
+    metrics: optionalNull(Schema.Struct({ predict_time: optionalNull(Schema.Number) })),
+    urls: Schema.Struct({ get: Schema.String, cancel: Schema.String }),
+});
+const Output = Schema.Union([Schema.String, Schema.Array(Schema.String)]);
+const isOutput = Schema.is(Output);
+const STATUS = {
+    starting: "queued",
+    processing: "running",
+    succeeded: "completed",
+    failed: "failed",
+    canceled: "cancelled",
+    // The prediction hit its `Cancel-After` deadline before it started running.
+    aborted: "expired",
+};
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+// Official models run by `owner/name`; anything else (`owner/name:version` or a bare version id) is a pinned version.
+const isOfficial = (model) => /^[^/:]+\/[^/:]+$/.test(model);
+const inlineSize = (source) => {
+    if (source.type === "bytes")
+        return source.data.byteLength;
+    if (source.type === "base64")
+        return source.data.length * 0.75;
+    return 0;
+};
+const fileInput = (asset) => {
+    if (inlineSize(asset.source) > MAX_DATA_URL_BYTES)
+        return Effect.fail(ProviderShared.invalidRequest(`${NAME} data URL inputs are limited to 256 KB; pass a larger file by https URL`));
+    return ProviderShared.mediaReference(asset, undefined, NAME).pipe(Effect.map((reference) => reference.value));
+};
+const inputValue = (value) => {
+    if (value instanceof Media.Asset)
+        return fileInput(value);
+    if (Array.isArray(value) && value.some((item) => item instanceof Media.Asset))
+        return Effect.forEach(value, (item) => (item instanceof Media.Asset ? fileInput(item) : Effect.succeed(item)));
+    return Effect.succeed(value);
+};
+const fromRequest = Effect.fn("ReplicateImages.fromRequest")(function* (request) {
+    const native = yield* Effect.forEach(Object.entries(request.providerOptions ?? {}), ([key, value]) => inputValue(value).pipe(Effect.map((lowered) => [key, lowered])));
+    const input = mergeJsonRecords({ prompt: request.prompt }, Object.fromEntries(native));
+    const model = request.model.id;
+    return MediaProtocol.json(mergeJsonRecords(isOfficial(model) ? { input } : { version: model, input }, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodePrediction = MediaProtocol.decodeJson(ADAPTER, NAME, Prediction);
+const decodeStart = Effect.fn("ReplicateImages.decodeStart")(function* (response) {
+    const output = yield* decodePrediction(response);
+    const prediction = output.value;
+    return {
+        token: { id: prediction.id, getURL: prediction.urls.get, cancelURL: prediction.urls.cancel },
+        // `Prefer: wait` can return an already-finished prediction, so `await` skips straight to the result.
+        snapshot: { id: prediction.id, status: yield* MediaProtocol.status(STATUS, prediction.status, output) },
+    };
+});
+const decodeStatus = Effect.fn("ReplicateImages.decodeStatus")(function* (response, context) {
+    const output = yield* decodePrediction(response);
+    return { id: context.token.id, status: yield* MediaProtocol.status(STATUS, output.value.status, output) };
+});
+const decodeResult = Effect.fn("ReplicateImages.decodeResult")(function* (response, context) {
+    const output = yield* decodePrediction(response);
+    const prediction = output.value;
+    const status = yield* MediaProtocol.status(STATUS, prediction.status, output);
+    if (status === "failed" || status === "cancelled" || status === "expired")
+        return yield* output.ended(status, `${NAME} prediction ${context.token.id} ${prediction.status}${typeof prediction.error === "string" ? `: ${prediction.error}` : ""}`);
+    if (status !== "completed")
+        return yield* output.invalid(`${NAME} prediction ${context.token.id} has not finished`);
+    if (prediction.data_removed === true)
+        return yield* output.ended("expired", `${NAME} removed the output of prediction ${context.token.id}`);
+    if (!isOutput(prediction.output))
+        return yield* output.invalid(`${NAME} prediction ${context.token.id} returned output that is not image URLs`);
+    const urls = typeof prediction.output === "string" ? [prediction.output] : prediction.output;
+    if (urls.length === 0)
+        return yield* output.invalid(`${NAME} prediction ${context.token.id} returned no images`);
+    const predictTime = prediction.metrics?.predict_time ?? undefined;
+    const completedAt = prediction.completed_at ?? undefined;
+    const expiresAt = completedAt === undefined ? undefined : Date.parse(completedAt) + Duration.toMillis(OUTPUT_RETENTION);
+    return new ImageResponse({
+        images: urls.map((url) => Media.url(url, { expiresAt })),
+        usage: predictTime === undefined ? undefined : { type: "compute", seconds: predictTime },
+        providerMetadata: { replicate: { predictionId: prediction.id } },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.queued({
+    id: ADAPTER,
+    name: NAME,
+    token: Token,
+    unsupported: ["images", "mask", "n", "size", "aspectRatio", "seed", "format"],
+    start: { body: { from: fromRequest }, decode: decodeStart },
+    status: { path: (token) => token.getURL, decode: decodeStatus },
+    result: { path: (token) => token.getURL, decode: decodeResult },
+    cancel: { method: "POST", path: (token) => token.cancelURL },
+});
+export const model = (input) => ImageModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: DEFAULT_BASE_URL,
+    path: ({ request }) => isOfficial(request.model.id) ? `/v1/models/${request.model.id}/predictions` : "/v1/predictions",
+}, input);
+export const ReplicateImages = {
+    protocol,
+    model,
+};

package/dist/protocols/stability-images.d.ts

@@ -0,0 +1,38 @@
+import { Schema } from "effect";
+import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+export declare const DEFAULT_BASE_URL = "https://api.stability.ai";
+export type StabilityStylePreset = "enhance" | "anime" | "photographic" | "digital-art" | "comic-book" | "fantasy-art" | "line-art" | "analog-film" | "neon-punk" | "isometric" | "low-poly" | "origami" | "modeling-compound" | "cinematic" | "3d-model" | "pixel-art" | "tile-texture" | (string & {});
+export type StabilityImageOptions = {
+    readonly negative_prompt?: string;
+    readonly style_preset?: StabilityStylePreset;
+    readonly strength?: number;
+    readonly cfg_scale?: number;
+} & Record<string, unknown>;
+/** Creative upscale options; the one `images` source is the image to upscale. */
+export type StabilityUpscaleOptions = {
+    readonly negative_prompt?: string;
+    readonly style_preset?: StabilityStylePreset;
+    readonly creativity?: number;
+} & Record<string, unknown>;
+export type Request = ImageRequestFor<StabilityImageOptions>;
+export type UpscaleRequest = ImageRequestFor<StabilityUpscaleOptions>;
+export declare const Token: Schema.Struct<{
+    readonly id: Schema.String;
+}>;
+export type Token = Schema.Schema.Type<typeof Token>;
+export declare const protocol: MediaProtocol.Inline<Request, ImageResponse>;
+export declare const upscaleProtocol: MediaProtocol.Queued<UpscaleRequest, ImageResponse, {
+    readonly id: string;
+}>;
+export declare const model: (input: MediaRoute.ModelInput) => ImageModel<StabilityImageOptions>;
+export declare const upscaleModel: (input: Omit<MediaRoute.ModelInput, "id">) => ImageModel<StabilityUpscaleOptions>;
+export declare const StabilityImages: {
+    readonly protocol: MediaProtocol.Inline<Request, ImageResponse>;
+    readonly upscaleProtocol: MediaProtocol.Queued<UpscaleRequest, ImageResponse, {
+        readonly id: string;
+    }>;
+    readonly model: (input: MediaRoute.ModelInput) => ImageModel<StabilityImageOptions>;
+    readonly upscaleModel: (input: Omit<MediaRoute.ModelInput, "id">) => ImageModel<StabilityUpscaleOptions>;
+};