@opencode/ai 2.0.15 → 2.0.17

package/dist/protocols/openai-chat.js

@@ -11,7 +11,6 @@ import { classifyProviderFailure } from "../provider-error.js";
 import { isRecord, JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { OpenAIOptions } from "./utils/openai-options.js";
 import { Lifecycle } from "./utils/lifecycle.js";
-import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { ToolStream } from "./utils/tool-stream.js";
 const ADAPTER = "openai-chat";
 const RESERVED_REASONING_FIELDS = new Set(["role", "content", "refusal", "tool_calls"]);
@@ -91,6 +90,10 @@ const OpenAIChatUserContent = Schema.Union([
         type: Schema.Literal("image_url"),
         image_url: Schema.Struct({ url: Schema.String }),
     }),
+    Schema.Struct({
+        type: Schema.Literal("file"),
+        file: Schema.Struct({ filename: Schema.String, file_data: Schema.String }),
+    }),
 ]);
 const OpenAIChatMessage = Schema.Union([
     Schema.Struct({
@@ -205,12 +208,12 @@ export const OpenAIChatEvent = Schema.StructWithRest(Schema.Struct({
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
 const DONE = "[DONE]";
 const OpenAIChatStreamEvent = Schema.Union([Schema.Literal(DONE), Protocol.jsonEvent(OpenAIChatEvent)]);
-const lowerTool = (tool, inputSchema, options, supportsStrictMode) => ({
+const lowerTool = (tool, options, supportsStrictMode) => ({
     type: "function",
     function: {
         name: tool.name,
         description: tool.description,
-        parameters: inputSchema,
+        parameters: tool.inputSchema,
         ...(supportsStrictMode ? { strict: false } : {}),
     },
     cache_control: options.cacheControl?.(tool.cache),
@@ -230,6 +233,15 @@ const lowerToolCall = (part, options) => ({
     },
 });
 const lowerMedia = Effect.fn("OpenAIChat.lowerMedia")(function* (part) {
+    // Chat Completions accepts PDFs, and no other documents, as inline `file` parts; file URLs are not supported.
+    if (part.media.mediaType.toLowerCase() === "application/pdf")
+        return {
+            type: "file",
+            file: {
+                filename: part.filename ?? "document.pdf",
+                file_data: (yield* ProviderShared.requireInlineMedia("OpenAI Chat", part.media)).dataUrl,
+            },
+        };
     if (part.media.kind !== "image")
         return yield* ProviderShared.invalidRequest(`OpenAI Chat does not support media type ${part.media.mediaType}`);
     const url = ProviderShared.mediaUrl(part.media) ?? (yield* ProviderShared.requireInlineMedia("OpenAI Chat", part.media)).dataUrl;
@@ -345,7 +357,7 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
 });
 const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (message, options) {
     const messages = [];
-    const images = [];
+    const attachments = [];
     for (const part of message.content) {
         if (!ProviderShared.supportsContent(part, ["tool-result"]))
             return yield* ProviderShared.unsupportedContent("OpenAI Chat", "tool", ["tool-result"]);
@@ -367,9 +379,9 @@ const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (m
             cache_control: options.cacheControl?.(part.cache),
         });
         const files = content.filter((item) => item.type === "file");
-        images.push(...(yield* Effect.forEach(files, (item) => lowerMedia(ProviderShared.toolFileMedia(item)))));
+        attachments.push(...(yield* Effect.forEach(files, (item) => lowerMedia(ProviderShared.toolFileMedia(item)))));
     }
-    return { messages, images };
+    return { messages, attachments };
 });
 const lowerMessage = Effect.fn("OpenAIChat.lowerMessage")(function* (message, reasoningField, requireReasoning, options) {
     if (message.role === "user")
@@ -423,23 +435,23 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request,
         if (requireAssistantAfterTool && messages.at(-1)?.role === "tool")
             messages.push({ role: "assistant", content: "Done." });
     };
-    const pendingImages = [];
-    const flushImages = () => {
-        if (pendingImages.length === 0)
+    const pendingAttachments = [];
+    const flushAttachments = () => {
+        if (pendingAttachments.length === 0)
             return;
         bridgeTools();
-        messages.push({ role: "user", content: pendingImages.splice(0) });
+        messages.push({ role: "user", content: pendingAttachments.splice(0) });
     };
     for (const message of request.messages) {
         if (message.role === "user")
             bridgeTools();
         if (message.role === "system") {
             const part = yield* ProviderShared.wrappedSystemUpdate("OpenAI Chat", message);
-            if (pendingImages.length > 0) {
+            if (pendingAttachments.length > 0) {
                 messages.push({
                     role: "user",
                     content: [
-                        ...pendingImages.splice(0),
+                        ...pendingAttachments.splice(0),
                         { type: "text", text: part.text, cache_control: options.cacheControl?.(part.cache) },
                     ],
                 });
@@ -479,13 +491,13 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request,
         if (message.role === "tool") {
             const lowered = yield* lowerToolMessages(message, lowering);
             messages.push(...lowered.messages);
-            pendingImages.push(...lowered.images);
+            pendingAttachments.push(...lowered.attachments);
             continue;
         }
-        flushImages();
+        flushAttachments();
         messages.push(...(yield* lowerMessage(message, reasoningField, requireReasoning, lowering)));
     }
-    flushImages();
+    flushAttachments();
     return messages;
 });
 // Anthropic via LiteLLM and Amazon Bedrock require `tools` to be present
@@ -618,7 +630,6 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (reques
     if (reasoningField && RESERVED_REASONING_FIELDS.has(reasoningField))
         return yield* ProviderShared.invalidRequest(`OpenAI Chat reasoning field conflicts with reserved field ${reasoningField}`);
     const generation = request.generation;
-    const toolSchemaCompatibility = request.model.compatibility?.toolSchema;
     const flattened = ProviderShared.flattenToolRequest(request);
     const provider = String(request.model.provider);
     const baseURL = request.model.route.endpoint.baseURL;
@@ -637,7 +648,7 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (reques
             ? hasHistory
                 ? []
                 : undefined
-            : flattened.tools.map((tool) => lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility), options, supportsStrictMode)),
+            : flattened.tools.map((tool) => lowerTool(tool, options, supportsStrictMode)),
         tool_choice: hasActiveTools && request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined,
         stream: true,
         ...(supportsUsageInStreaming ? { stream_options: { include_usage: true } } : {}),

package/dist/protocols/openai-compatible-chat.d.ts

@@ -23,6 +23,12 @@ export declare const route: Route<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly role: "user";
@@ -38,6 +44,12 @@ export declare const route: Route<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly [x: string]: unknown;

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

@@ -72,8 +72,8 @@ export declare const route: Route<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -109,8 +109,8 @@ export declare const route: Route<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";

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

@@ -1,21 +1,144 @@
-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, type OpenString } 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";
-export type OpenAIImageString<Known extends string> = Known | (string & {});
 /** Provider-native options. Common fields (`n`, `size`, `format`, `images`, `mask`) live on the request. */
 export type OpenAIImageOptions = {
-    readonly quality?: OpenAIImageString<"auto" | "low" | "medium" | "high" | "standard" | "hd">;
-    readonly background?: OpenAIImageString<"auto" | "opaque" | "transparent">;
-    readonly moderation?: OpenAIImageString<"auto" | "low">;
+    readonly quality?: OpenString<"auto" | "low" | "medium" | "high" | "standard" | "hd">;
+    readonly background?: OpenString<"auto" | "opaque" | "transparent">;
+    readonly moderation?: OpenString<"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 size?: string;
+    readonly quality?: string;
+    readonly background?: 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,36 +1,60 @@
-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";
+import { mergeJsonRecords } from "../schema/index.js";
 import { ProviderShared } from "./shared.js";
 import { MediaInput } from "./utils/media-input.js";
-const ADAPTER = "openai-images";
-const NAME = "OpenAI Images";
-const PROVIDER = ProviderID.make("openai");
+const route = MediaProtocol.identity({ id: "openai-images", name: "OpenAI Images", provider: "openai" });
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1";
 export const PATH = "/images/generations";
 export const EDIT_PATH = "/images/edits";
 // ---------------------------------------------------------------------------
 // 2. Response schema
 // ---------------------------------------------------------------------------
-const OpenAIImageResponse = Schema.Struct({
-    data: Schema.Array(Schema.Struct({
-        b64_json: Schema.optional(Schema.String),
-        url: Schema.optional(Schema.String),
-        revised_prompt: Schema.optional(Schema.String),
-    })),
+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)),
+});
+/** What the provider actually rendered; it can differ from the request when `auto` or a default applied. */
+const Settings = {
     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)),
-    })),
+    size: Schema.optional(Schema.String),
+    quality: Schema.optional(Schema.String),
+    background: Schema.optional(Schema.String),
+};
+const OpenAIImageResponse = Schema.Struct({
+    data: Schema.Array(Schema.Struct({ b64_json: Schema.String })),
+    ...Settings,
+    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,
+        ...Settings,
+        output_format: Schema.String,
+    }),
+    Schema.Struct({
+        type: Schema.Literals(["image_generation.completed", "image_edit.completed"]),
+        b64_json: Schema.String,
+        ...Settings,
+        output_format: Schema.String,
+        usage: Schema.optional(Usage),
+    }),
+]);
+const decodeEvent = route.decodeFrame(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,48 +62,33 @@ 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 isEdit = (request) => (request.images?.length ?? 0) > 0;
-const isInline = (asset) => asset.inline() !== undefined;
-const blob = (data, mediaType) => {
-    const buffer = new ArrayBuffer(data.byteLength);
-    new Uint8Array(buffer).set(data);
-    return new Blob([buffer], { type: mediaType });
-};
-const reference = (asset) => {
-    const inline = asset.inline();
-    if (inline)
-        return Effect.succeed({ image_url: inline.dataUrl });
-    const url = ProviderShared.mediaUrl(asset);
-    if (url)
-        return Effect.succeed({ image_url: url });
-    const id = MediaInput.refID(asset, PROVIDER);
-    if (id)
-        return Effect.succeed({ file_id: id });
-    return Effect.fail(ProviderShared.invalidRequest("OpenAI Images accepts image URLs, data URLs, bytes, and OpenAI file IDs"));
+const streamOptions = (request) => {
+    if (request.mode !== "stream")
+        return Effect.succeed(undefined);
+    if (request.n !== undefined && request.n > 1)
+        return Effect.fail(route.unsupported("media.n", `${route.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.source.type === "bytes" || asset.source.type === "base64";
+const reference = (asset) => ProviderShared.mediaReference(asset, route.provider, route.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();
-        form.append("model", request.model.id);
-        form.append("prompt", request.prompt);
-        Object.entries(fields ?? {}).forEach(([key, value]) => {
-            if (RESERVED_FORM_FIELDS.has(key))
-                return;
-            form.append(key, typeof value === "string" ? value : ProviderShared.encodeJson(value));
-        });
-        const uploads = yield* Effect.forEach(images, (image) => MediaInput.inlineBytes(ADAPTER, image));
-        uploads.forEach((data, index) => form.append("image[]", blob(data, images[index].mediaType), `image-${index}`));
+        MediaInput.appendFields(form, { model: request.model.id, prompt: request.prompt }, { overlay: fields, reserved: RESERVED_FORM_FIELDS });
+        const uploads = yield* Effect.forEach(images, (image) => MediaInput.inlineBytes(route.id, image));
+        uploads.forEach((data, index) => form.append("image[]", MediaInput.blob(data, images[index].mediaType), `image-${index}`));
         if (mask !== undefined)
-            form.append("mask", blob(yield* MediaInput.inlineBytes(ADAPTER, mask), mask.mediaType), "mask");
+            form.append("mask", MediaInput.blob(yield* MediaInput.inlineBytes(route.id, mask), mask.mediaType), "mask");
         return MediaProtocol.multipart(form);
     }
     const references = yield* Effect.forEach(images, reference);
@@ -92,61 +101,104 @@ const fromRequest = Effect.fn("OpenAIImages.fromRequest")(function* (request) {
     }, fields) ?? {});
 });
 // ---------------------------------------------------------------------------
-// 6. Response decoding
+// 6. Stream parsing
 // ---------------------------------------------------------------------------
 const requestedFormat = (body) => {
+    if (body.type === "binary")
+        return undefined;
     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 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, {
-                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`));
-    });
+const usage = (value) => value === undefined
+    ? undefined
+    : {
+        type: "tokens",
+        input: value.input_tokens,
+        output: value.output_tokens,
+        total: value.total_tokens,
+        details: { openai: value },
+    };
+/** `size` echoes the rendered `WIDTHxHEIGHT`; `auto` or any other value leaves the dimensions unknown. */
+const info = (format, size) => {
+    const match = size?.match(/^(\d+)x(\d+)$/);
+    return match ? { format, width: Number(match[1]), height: Number(match[2]) } : { format };
+};
+const eventImage = (frame, label, data, format, size) => MediaInput.decodedAsset((message, cause) => route.frameError(message, frame, cause), label, data, `image/${format}`, {
+    info: info(format, size),
+});
+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, `${route.name} partial image`, event.b64_json, format, event.size);
+        return [state, [ImagePartialEvent.make({ index: event.partial_image_index, image })]];
+    }
+    const image = yield* eventImage(frame, `${route.name} result ${state.completed}`, event.b64_json, format, event.size);
+    return [
+        {
+            completed: state.completed + 1,
+            format,
+            size: event.size,
+            quality: event.quality,
+            background: event.background,
+            usage: usage(event.usage),
+        },
+        [ImageOutputEvent.make({ index: state.completed, image })],
+    ];
+});
+const onDocument = Effect.fn("OpenAIImages.onDocument")(function* (frame) {
+    const invalid = (message, cause) => route.frameError(message, frame.document, cause);
+    const decoded = yield* decodeDocument(frame.document).pipe(Effect.mapError((cause) => invalid(`${route.name} returned an invalid response`, cause)));
+    const format = decoded.output_format ?? frame.requested ?? "png";
+    const images = yield* Effect.forEach(decoded.data, (item, index) => MediaInput.decodedAsset(invalid, `${route.name} result ${index}`, item.b64_json, `image/${format}`, {
+        info: info(format, decoded.size),
+    }));
     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(`${route.name} returned no images`);
+    const state = {
+        completed: images.length,
+        format,
+        size: decoded.size,
+        quality: decoded.quality,
+        background: decoded.background,
+        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(route.incomplete());
+    return Effect.succeed([
+        ImageFinishEvent.make({
+            usage: state.usage,
+            providerMetadata: {
+                openai: {
+                    outputFormat: state.format,
+                    size: state.size,
+                    quality: state.quality,
+                    background: state.background,
+                },
+            },
+        }),
+    ]);
+};
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.inline({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.stream(route, {
     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,
-    provider: PROVIDER,
-    protocol,
-    baseURL: DEFAULT_BASE_URL,
-    path: ({ request }) => (isEdit(request) ? EDIT_PATH : PATH),
-}, input);
+export const model = (input) => ImageModel.fromRoute({ protocol, baseURL: DEFAULT_BASE_URL, path: ({ request }) => (isEdit(request) ? EDIT_PATH : PATH) }, input);
 export const OpenAIImages = {
     protocol,
     model,