@opencode/ai 2.0.14 → 2.0.15

package/dist/protocols/openai-images.js

@@ -1,15 +1,20 @@
-import { Effect, Encoding, Schema } from "effect";
-import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
-import { ImageModel, GeneratedImage, ImageResponse, } from "../image.js";
-import { Auth } from "../route/auth.js";
-import { Usage, mergeHttpOptions, mergeJsonRecords } from "../schema/index.js";
+import { 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 } from "./shared.js";
-import { ImageInputs } from "./utils/image-input.js";
-import { OpenAIImage } from "./utils/openai-image.js";
+import { MediaInput } from "./utils/media-input.js";
 const ADAPTER = "openai-images";
+const NAME = "OpenAI Images";
+const PROVIDER = ProviderID.make("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),
@@ -25,159 +30,124 @@ const OpenAIImageResponse = Schema.Struct({
         output_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
     })),
 });
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+/** Multipart field names the route owns; `http.body` overlays cannot smuggle replacements for them. */
+const RESERVED_FORM_FIELDS = new Set(["model", "prompt", "image", "image[]", "images", "mask"]);
 const nativeOptions = (options) => {
     if (!options)
         return undefined;
-    const { mask: _, outputFormat, outputCompression, ...native } = options;
-    return {
-        output_format: outputFormat,
-        output_compression: outputCompression,
-        ...native,
-    };
+    const { outputCompression, ...native } = options;
+    return { output_compression: outputCompression, ...native };
 };
-const applyQuery = (url, query) => {
-    if (!query)
-        return url;
-    const next = new URL(url);
-    Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value));
-    return next.toString();
+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 });
 };
-export const model = (input) => {
-    const route = {
-        id: ADAPTER,
-        generate: Effect.fn("OpenAIImages.generate")(function* (request, execute) {
-            const mask = request.options?.mask;
-            if (mask !== undefined && (request.images?.length ?? 0) === 0)
-                return yield* ImageInputs.invalid("An OpenAI image mask requires at least one input image");
-            const http = mergeHttpOptions(request.model.http, request.http);
-            const sourceImages = request.images ?? [];
-            const multipartImages = yield* Effect.forEach(sourceImages, (image) => {
-                if (image.type === "bytes")
-                    return Effect.succeed({ data: image.data, mediaType: image.mediaType });
-                if (image.type === "url")
-                    return ImageInputs.decodeDataUrl(image.url);
-                return Effect.undefined;
-            });
-            const multipartMask = mask === undefined
-                ? undefined
-                : mask.type === "bytes"
-                    ? { data: mask.data, mediaType: mask.mediaType }
-                    : mask.type === "url"
-                        ? yield* ImageInputs.decodeDataUrl(mask.url)
-                        : undefined;
-            const useMultipart = sourceImages.length > 0 &&
-                multipartImages.every((image) => image !== undefined) &&
-                (mask === undefined || multipartMask !== undefined);
-            const path = sourceImages.length === 0 ? PATH : EDIT_PATH;
-            const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}${path}`, http?.query);
-            if (useMultipart) {
-                const form = new FormData();
-                form.append("model", request.model.id);
-                form.append("prompt", request.prompt);
-                Object.entries(mergeJsonRecords(nativeOptions(request.options), http?.body) ?? {}).forEach(([key, value]) => {
-                    if (["model", "prompt", "image", "image[]", "images", "mask"].includes(key))
-                        return;
-                    form.append(key, typeof value === "string" ? value : ProviderShared.encodeJson(value));
-                });
-                multipartImages.forEach((image, index) => {
-                    if (image === undefined)
-                        return;
-                    form.append("image[]", imageBlob(image.data, image.mediaType), `image-${index}`);
-                });
-                if (multipartMask !== undefined)
-                    form.append("mask", imageBlob(multipartMask.data, multipartMask.mediaType), "mask");
-                const headers = yield* Auth.toEffect(input.auth)({
-                    request,
-                    method: "POST",
-                    url,
-                    body: "[multipart/form-data]",
-                    headers: Headers.remove(Headers.fromInput({ ...input.headers, ...http?.headers }), "content-type"),
-                });
-                const response = yield* execute(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyFormData(form)));
-                return yield* parseResponse(response, request.options, http?.body);
-            }
-            const references = sourceImages.map((image) => {
-                if (image.type === "bytes")
-                    return { image_url: ImageInputs.dataUrl(image) };
-                if (image.type === "url")
-                    return { image_url: image.url };
-                if (image.type === "file-id")
-                    return { file_id: image.id };
-                return undefined;
-            });
-            if (references.some((image) => image === undefined))
-                return yield* ImageInputs.invalid("OpenAI Images accepts image URLs, data URLs, bytes, and file IDs");
-            const maskReference = mask === undefined
-                ? undefined
-                : mask.type === "bytes"
-                    ? { image_url: ImageInputs.dataUrl(mask) }
-                    : mask.type === "url"
-                        ? { image_url: mask.url }
-                        : mask.type === "file-id"
-                            ? { file_id: mask.id }
-                            : undefined;
-            if (mask !== undefined && maskReference === undefined)
-                return yield* ImageInputs.invalid("OpenAI Images accepts masks as URLs, data URLs, bytes, or file IDs");
-            const requestBody = mergeJsonRecords({
-                model: request.model.id,
-                prompt: request.prompt,
-                images: references.length === 0 ? undefined : references,
-                mask: maskReference,
-            }, nativeOptions(request.options), http?.body);
-            const text = ProviderShared.encodeJson(requestBody);
-            const headers = yield* Auth.toEffect(input.auth)({
-                request,
-                method: "POST",
-                url,
-                body: text,
-                headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
-            });
-            const response = yield* execute(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(text, "application/json")));
-            return yield* parseResponse(response, request.options, http?.body);
-        }),
-    };
-    return ImageModel.make({ id: input.id, provider: "openai", route, http: input.http });
+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 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);
+    // 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}`));
+        if (mask !== undefined)
+            form.append("mask", blob(yield* MediaInput.inlineBytes(ADAPTER, mask), mask.mediaType), "mask");
+        return MediaProtocol.multipart(form);
+    }
+    const references = yield* Effect.forEach(images, reference);
+    const maskReference = mask === undefined ? undefined : yield* reference(mask);
+    return MediaProtocol.json(mergeJsonRecords({
+        model: request.model.id,
+        prompt: request.prompt,
+        images: references.length === 0 ? undefined : references,
+        mask: maskReference,
+    }, fields) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const requestedFormat = (body) => {
+    const value = body.type === "json" ? body.value.output_format : body.value.get("output_format");
+    return typeof value === "string" ? value : undefined;
 };
-const parseResponse = Effect.fn("OpenAIImages.parseResponse")(function* (response, options, overlay) {
-    const output = yield* ProviderShared.imageResponse(ADAPTER, "OpenAI Images", response);
-    const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(OpenAIImageResponse))(output.body).pipe(Effect.mapError((cause) => output.invalid("OpenAI Images returned an invalid response", cause)));
-    const requestBody = mergeJsonRecords(nativeOptions(options), overlay);
-    const format = decoded.output_format ?? (typeof requestBody?.output_format === "string" ? requestBody.output_format : "png");
+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 Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(Effect.mapError((cause) => output.invalid(`OpenAI Images result ${index} contains invalid base64 data`, cause)), Effect.map((data) => new GeneratedImage({
-                mediaType: `image/${format}`,
-                data,
-                providerMetadata: item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } },
-            })));
+            return MediaInput.decodedAsset(output.invalid, `${NAME} result ${index}`, item.b64_json, mediaType, {
+                info: { format },
+                providerMetadata,
+            });
         if (item.url)
-            return Effect.succeed(new GeneratedImage({
-                mediaType: `image/${format}`,
-                data: item.url,
-                providerMetadata: item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } },
-            }));
-        return Effect.fail(output.invalid(`OpenAI Images result ${index} has neither image data nor a 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`));
     });
     if (images.length === 0)
-        return yield* output.invalid("OpenAI Images returned no images");
+        return yield* output.invalid(`${NAME} returned no images`);
     return new ImageResponse({
         images,
         usage: decoded.usage === undefined
             ? undefined
-            : new Usage({
-                inputTokens: decoded.usage.input_tokens,
-                outputTokens: decoded.usage.output_tokens,
-                totalTokens: decoded.usage.total_tokens,
-                providerMetadata: { openai: decoded.usage },
-            }),
+            : {
+                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 } },
     });
 });
-const imageBlob = (data, mediaType) => {
-    const buffer = new ArrayBuffer(data.byteLength);
-    new Uint8Array(buffer).set(data);
-    return new Blob([buffer], { type: mediaType });
-};
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.inline({
+    id: ADAPTER,
+    name: NAME,
+    unsupported: ["aspectRatio", "seed"],
+    body: { from: fromRequest },
+    response: { decode: decodeResponse },
+});
+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 OpenAIImages = {
+    protocol,
     model,
 };

package/dist/protocols/shared.d.ts

@@ -1,6 +1,7 @@
 import { Tool } from "@opencode/schema/tool";
 import { Effect, Schema, Stream } from "effect";
-import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { Media } from "../media.js";
 import { AIError, LLMRequest, Message, ToolDefinition, type ContentPart, type MediaPart, type ProviderID, type ToolEntry, type ToolResultPart } from "../schema/index.js";
 import { isRecord } from "../utils/record.js";
 export { isRecord };
@@ -110,23 +111,26 @@ export declare const wrappedSystemUpdate: (route: string, message: Message) => E
  * routes: `Invalid JSON input for <route> tool call <name>`.
  */
 export declare const parseToolInput: (route: string, name: string, raw: string) => Effect.Effect<unknown, AIError, never>;
-export interface NormalizedMedia {
-    readonly mime: string;
-    readonly base64: string;
-    readonly dataUrl: string;
-}
-export declare const normalizeMedia: (part: MediaPart) => NormalizedMedia;
-export declare const normalizeToolFile: (part: Tool.FileContent) => NormalizedMedia;
+/** Inline view or a typed `InvalidRequest` for routes that cannot fetch URLs or dereference provider refs. */
+export declare const requireInlineMedia: (route: string, asset: Media.Asset) => Effect.Effect<Media.Inline, AIError>;
+export declare const inlineRequired: (route: string, asset: Media.Asset) => AIError;
+/** The remote URL of a `url` asset, for protocols that accept `http(s)` references natively. */
+export declare const mediaUrl: (asset: Media.Asset) => string | undefined;
+/**
+ * Lift a tool-result file into a `MediaPart`. Tool files carry either a data URL, an `http(s)` URL, or raw base64 in
+ * `uri`; the declared `mime` wins over any data-URL prefix so tool authors control the type the model sees.
+ */
+export declare const toolFileMedia: (item: Tool.FileContent) => MediaPart;
 export declare const trimBaseUrl: (value: string) => string;
 export declare const toolResultText: (part: ToolResultPart) => string;
 export declare const errorText: (error: unknown) => string;
 /**
  * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
- * decoder, optionally filters named events, and drops empty events. `[DONE]`
- * is dropped by default or retained for protocols that use it as their stream
- * boundary. Retry control events are ignored without interrupting the stream.
- * Decoder failures become provider output errors so the public error channel
- * stays `AIError`.
+ * decoder, optionally filters named events, and drops empty and bare `null`
+ * events. `[DONE]` is dropped by default or retained for protocols that use it
+ * as their stream boundary. Retry control events are ignored without
+ * interrupting the stream. Decoder failures become provider output errors so
+ * the public error channel stays `AIError`.
  */
 export declare const sseFraming: (bytes: Stream.Stream<Uint8Array, AIError>, events?: ReadonlySet<string>, includeDone?: boolean) => Stream.Stream<string, AIError>;
 /**
@@ -158,10 +162,6 @@ export declare const flattenToolRequest: (request: LLMRequest) => {
         readonly [x: string]: unknown;
     }, import("../route.js").CompactionOperations | undefined>>;
 };
-export declare const imageResponse: (route: string, name: string, response: HttpClientResponse.HttpClientResponse) => Effect.Effect<{
-    body: string;
-    invalid: (message: string, cause?: unknown) => AIError;
-}, AIError, never>;
 export declare const matchToolChoice: <Auto, None, Required, Tool>(route: string, toolChoice: NonNullable<LLMRequest["toolChoice"]>, cases: {
     readonly auto: () => Auto;
     readonly none: () => None;

package/dist/protocols/shared.js

@@ -1,9 +1,9 @@
-import { Buffer } from "node:buffer";
 import { Tool } from "@opencode/schema/tool";
 import { Effect, Option, Schema, Stream } from "effect";
 import * as Sse from "effect/unstable/encoding/Sse";
-import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
-import { InvalidProviderOutputError, InvalidRequestError, UnsupportedOperationError, AIError, HttpContext, LLMRequest, Message, ToolDefinition, } from "../schema/index.js";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { Media } from "../media.js";
+import { InvalidProviderOutputError, InvalidRequestError, UnsupportedOperationError, AIError, LLMRequest, Message, ToolDefinition, } from "../schema/index.js";
 import { isRecord } from "../utils/record.js";
 export { isRecord };
 export const Json = Schema.fromJsonString(Schema.Unknown);
@@ -126,17 +126,27 @@ export const wrappedSystemUpdate = Effect.fn("ProviderShared.wrappedSystemUpdate
  * routes: `Invalid JSON input for <route> tool call <name>`.
  */
 export const parseToolInput = (route, name, raw) => parseJson(route, raw || "{}", `Invalid JSON input for ${route} tool call ${name}`);
-export const normalizeMedia = (part) => {
-    const mime = part.mediaType.toLowerCase();
-    if (typeof part.data !== "string") {
-        const base64 = Buffer.from(part.data).toString("base64");
-        return { mime, base64, dataUrl: `data:${mime};base64,${base64}` };
-    }
-    if (!part.data.startsWith("data:"))
-        return { mime, base64: part.data, dataUrl: `data:${mime};base64,${part.data}` };
-    return { mime, base64: part.data.slice(part.data.indexOf(",") + 1), dataUrl: part.data };
+/** Inline view or a typed `InvalidRequest` for routes that cannot fetch URLs or dereference provider refs. */
+export const requireInlineMedia = (route, asset) => {
+    const inline = asset.inline();
+    return inline ? Effect.succeed(inline) : Effect.fail(inlineRequired(route, asset));
+};
+export const inlineRequired = (route, asset) => invalidRequest(`${route} requires inline media (bytes or base64); ${asset.source.type} sources must be materialized first`);
+/** The remote URL of a `url` asset, for protocols that accept `http(s)` references natively. */
+export const mediaUrl = (asset) => (asset.source.type === "url" ? asset.source.url : undefined);
+/**
+ * Lift a tool-result file into a `MediaPart`. Tool files carry either a data URL, an `http(s)` URL, or raw base64 in
+ * `uri`; the declared `mime` wins over any data-URL prefix so tool authors control the type the model sees.
+ */
+export const toolFileMedia = (item) => {
+    const parsed = Media.parseDataUrl(item.uri);
+    const asset = parsed
+        ? Media.from({ ...parsed.source, mediaType: item.mime })
+        : /^https?:\/\//.test(item.uri)
+            ? Media.url(item.uri, { mediaType: item.mime })
+            : Media.base64(item.uri, item.mime);
+    return Message.media(asset, { filename: item.name });
 };
-export const normalizeToolFile = (part) => normalizeMedia({ type: "media", mediaType: part.mime, data: part.uri, filename: part.name });
 export const trimBaseUrl = (value) => value.replace(/\/+$/, "");
 export const toolResultText = (part) => {
     if (part.result.type === "text")
@@ -164,11 +174,11 @@ export const errorText = (error) => {
 };
 /**
  * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
- * decoder, optionally filters named events, and drops empty events. `[DONE]`
- * is dropped by default or retained for protocols that use it as their stream
- * boundary. Retry control events are ignored without interrupting the stream.
- * Decoder failures become provider output errors so the public error channel
- * stays `AIError`.
+ * decoder, optionally filters named events, and drops empty and bare `null`
+ * events. `[DONE]` is dropped by default or retained for protocols that use it
+ * as their stream boundary. Retry control events are ignored without
+ * interrupting the stream. Decoder failures become provider output errors so
+ * the public error channel stays `AIError`.
  */
 export const sseFraming = (bytes, events, includeDone = false) => bytes.pipe(Stream.decodeText(), Stream.mapAccumEffect(() => {
     const output = [];
@@ -186,6 +196,10 @@ export const sseFraming = (bytes, events, includeDone = false) => bytes.pipe(Str
     return [state, state.output.splice(0)];
 })), Stream.filter((event) => (events === undefined || events.has(event.event)) &&
     event.data.length > 0 &&
+    // Some OpenAI-compatible proxies serialize an empty flush as a bare
+    // `data: null`, between events or after `[DONE]`. No protocol has a
+    // null event, so it carries nothing and must not abort the stream.
+    event.data !== "null" &&
     (event.data !== "[DONE]" || includeDone || (events !== undefined && event.event !== "message"))), Stream.map((event) => event.data));
 /**
  * Canonical invalid-request constructor shared by protocol lowering.
@@ -241,23 +255,6 @@ export const flattenToolRequest = (request) => {
             : LLMRequest.update(request, { messages }),
     };
 };
-export const imageResponse = Effect.fn("ProviderShared.imageResponse")(function* (route, name, response) {
-    const http = new HttpContext({ url: response.request.url, status: response.status, headers: response.headers });
-    const body = yield* response.text.pipe(Effect.mapError((cause) => new AIError({
-        reason: new InvalidProviderOutputError({
-            route,
-            message: `Failed to read the ${name} response`,
-            http,
-            cause,
-        }),
-    })));
-    return {
-        body,
-        invalid: (message, cause) => new AIError({
-            reason: new InvalidProviderOutputError({ route, message, body, http, cause }),
-        }),
-    };
-});
 export const matchToolChoice = (route, toolChoice, cases) => Effect.gen(function* () {
     if (toolChoice.type === "auto")
         return cases.auto();

package/dist/protocols/utils/bedrock-media.d.ts

@@ -23,9 +23,8 @@ export declare const DocumentBlock: Schema.Struct<{
 }>;
 export type DocumentBlock = Schema.Schema.Type<typeof DocumentBlock>;
 export declare const lower: (part: {
-    readonly data: string | Uint8Array<ArrayBufferLike>;
     readonly type: "media";
-    readonly mediaType: string;
+    readonly media: import("../../media.js").Asset;
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
@@ -45,7 +44,7 @@ export declare const lower: (part: {
     };
 }[] | ({
     readonly document: {
-        readonly format: "pdf" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html" | "txt" | "md";
+        readonly format: "pdf" | "txt" | "md" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html";
         readonly name: string;
         readonly source: {
             readonly bytes: string;

package/dist/protocols/utils/bedrock-media.js

@@ -62,7 +62,7 @@ function documentName(filename, names) {
     return name;
 }
 const mediaBase64 = Effect.fn("BedrockMedia.mediaBase64")(function* (part) {
-    const media = ProviderShared.normalizeMedia(part);
+    const media = yield* ProviderShared.requireInlineMedia("Bedrock Converse", part.media);
     const bytes = yield* Effect.fromResult(Encoding.decodeBase64(media.base64)).pipe(Effect.mapError((cause) => ProviderShared.invalidRequest("Bedrock Converse media data must be valid base64", cause)));
     return Encoding.encodeBase64(bytes);
 });
@@ -72,13 +72,13 @@ const mediaBase64 = Effect.fn("BedrockMedia.mediaBase64")(function* (part) {
 // get an image-specific error so the caller knows it's a format-support issue,
 // not a kind-detection issue.
 export const lower = Effect.fn("BedrockMedia.lower")(function* (part, documentNames) {
-    const mime = part.mediaType.toLowerCase();
+    const mime = part.media.mediaType.toLowerCase();
     const imageFormat = IMAGE_FORMATS[mime];
     if (imageFormat) {
         return [{ image: { format: imageFormat, source: { bytes: yield* mediaBase64(part) } } }];
     }
     if (mime.startsWith("image/"))
-        return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support image media type ${part.mediaType}`);
+        return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support image media type ${part.media.mediaType}`);
     const documentFormat = DOCUMENT_FORMATS[mime];
     if (documentFormat) {
         const name = documentName(part.filename, documentNames);
@@ -92,6 +92,6 @@ export const lower = Effect.fn("BedrockMedia.lower")(function* (part, documentNa
             ]
             : [block];
     }
-    return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support media type ${part.mediaType}`);
+    return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support media type ${part.media.mediaType}`);
 });
 export * as BedrockMedia from "./bedrock-media.js";

package/dist/protocols/utils/media-input.d.ts

@@ -0,0 +1,10 @@
+import { Effect } from "effect";
+import { Media } from "../../media.js";
+import type { AIError, ProviderID } from "../../schema/index.js";
+/** Owned bytes for multipart uploads; decodes `base64` sources and rejects remote sources. */
+export declare const inlineBytes: (route: string, asset: Media.Asset) => Effect.Effect<Uint8Array, AIError>;
+/** Provider file handle when the ref belongs to this provider; refs from other providers are never forwarded. */
+export declare const refID: (asset: Media.Asset, provider: ProviderID) => string | undefined;
+/** Decode a provider's base64 output once into an owned `bytes` asset, sniffing the type when it is not declared. */
+export declare const decodedAsset: (invalid: (message: string, cause?: unknown) => AIError, label: string, data: string, mediaType: string | undefined, options?: Media.AssetOptions) => Effect.Effect<Media.Asset, AIError, never>;
+export * as MediaInput from "./media-input.js";

package/dist/protocols/utils/media-input.js

@@ -0,0 +1,17 @@
+import { Effect, Encoding } from "effect";
+import { Media } from "../../media.js";
+import { ProviderShared } from "../shared.js";
+/** Owned bytes for multipart uploads; decodes `base64` sources and rejects remote sources. */
+export const inlineBytes = (route, asset) => {
+    if (asset.source.type === "bytes")
+        return Effect.succeed(asset.source.data);
+    const inline = asset.inline();
+    if (!inline)
+        return Effect.fail(ProviderShared.inlineRequired(route, asset));
+    return Effect.fromResult(Encoding.decodeBase64(inline.base64)).pipe(Effect.mapError((cause) => ProviderShared.invalidRequest(`${route} media contains invalid base64 data`, cause)));
+};
+/** Provider file handle when the ref belongs to this provider; refs from other providers are never forwarded. */
+export const refID = (asset, provider) => asset.source.type === "ref" && asset.source.provider === provider ? asset.source.id : undefined;
+/** Decode a provider's base64 output once into an owned `bytes` asset, sniffing the type when it is not declared. */
+export const decodedAsset = (invalid, label, data, mediaType, options) => Effect.fromResult(Encoding.decodeBase64(data)).pipe(Effect.mapError((cause) => invalid(`${label} contains invalid base64 data`, cause)), Effect.map((bytes) => Media.bytes(bytes, mediaType, options)));
+export * as MediaInput from "./media-input.js";

package/dist/protocols/utils/responses-compaction.js

@@ -6,6 +6,7 @@ import { RequestExecutor } from "../../route/executor.js";
 import { HttpTransport } from "../../route/transport/index.js";
 import { OpenResponses } from "../open-responses.js";
 import { JsonObject, optionalNull, ProviderShared } from "../shared.js";
+import { Media } from "../../media.js";
 const Body = Schema.Struct({
     model: Schema.String,
     input: Schema.Array(Schema.Unknown),
@@ -113,19 +114,19 @@ function toMessage(item, model) {
             if (part.type === "input_image")
                 return {
                     type: "media",
-                    data: part.image_url,
-                    mediaType: /^data:([^;,]+)/.exec(part.image_url)?.[1] ?? "image/*",
+                    media: replayMedia(part.image_url, "image/*"),
                     providerMetadata: part.detail === undefined ? undefined : { [key]: { detail: part.detail } },
                 };
-            const data = part.file_url === undefined ? part.file_data : part.file_url;
             return {
                 type: "media",
-                data,
+                media: replayMedia(part.file_url === undefined ? part.file_data : part.file_url, "application/octet-stream"),
                 filename: part.filename,
-                mediaType: /^data:([^;,]+)/.exec(data)?.[1] ?? "application/octet-stream",
                 providerMetadata: part.detail === undefined ? undefined : { [key]: { detail: part.detail } },
             };
         }),
     });
 }
+/** Replayed compaction items carry either a data URL or a remote URL; the data URL's own type wins when present. */
+const replayMedia = (value, fallbackType) => Media.parseDataUrl(value) ??
+    (/^https?:\/\//.test(value) ? Media.url(value, { mediaType: fallbackType }) : Media.base64(value, fallbackType));
 export * as ResponsesCompaction from "./responses-compaction.js";