@opencode/ai 0.0.0-dev-20120 → 0.0.0-dev-20123

package/dist/protocols/meta-responses.js

@@ -6,7 +6,7 @@ import { OpenResponses } from "./open-responses.js";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js";
 import { ToolSchemaProjection } from "./utils/tool-schema.js";
-import { MetaImage } from "./utils/meta-image.js";
+import { detectMediaType } from "../utils/media-type.js";
 const ADAPTER = "meta-responses";
 const NAME = "Meta Responses";
 export const WebSearch = Schema.Struct({
@@ -101,7 +101,10 @@ const HOSTED_TOOLS = {
             if (!item.result)
                 return yield* ProviderShared.eventError(ADAPTER, "Meta returned an image without data", ProviderShared.encodeJson(raw));
             const data = yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe(Effect.mapError((cause) => ProviderShared.eventError(ADAPTER, "Meta returned invalid image base64", ProviderShared.encodeJson(raw), cause)));
-            const mime = MetaImage.mediaType(data, item.output_format);
+            // Responses image items can omit output_format, including when PNG/JPEG was requested.
+            const mime = item.output_format === undefined
+                ? (detectMediaType(data) ?? "application/octet-stream")
+                : `image/${item.output_format}`;
             return {
                 type: "content",
                 value: [{ type: "file", uri: `data:${mime};base64,${item.result}`, mime }],

package/dist/protocols/mistral-chat.js

@@ -10,6 +10,7 @@ import { classifyProviderFailure } from "../provider-error.js";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { MistralToolID } from "./utils/mistral-tool-id.js";
+import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { ToolStream } from "./utils/tool-stream.js";
 const ADAPTER = "mistral-chat";
 const DONE = "[DONE]";
@@ -272,9 +273,9 @@ const lowerMessages = Effect.fn("MistralChat.lowerMessages")(function* (request)
     }
     return messages;
 });
-const lowerTool = (tool) => ({
+const lowerTool = (tool, inputSchema) => ({
     type: "function",
-    function: { name: tool.name, description: tool.description, parameters: tool.inputSchema, strict: false },
+    function: { name: tool.name, description: tool.description, parameters: inputSchema, strict: false },
 });
 export const fromRequest = Effect.fn("MistralChat.fromRequest")(function* (request) {
     const options = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(MistralOptions))(request.providerOptions ?? {});
@@ -295,7 +296,9 @@ export const fromRequest = Effect.fn("MistralChat.fromRequest")(function* (reque
     return {
         model: request.model.id,
         messages: yield* lowerMessages(flattened.request),
-        tools: flattened.tools.length > 0 ? flattened.tools.map(lowerTool) : undefined,
+        tools: flattened.tools.length > 0
+            ? flattened.tools.map((tool) => lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model)))
+            : undefined,
         tool_choice: toolChoice,
         stream: true,
         max_tokens: request.generation?.maxTokens,

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

@@ -2,16 +2,15 @@ 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";
+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;

package/dist/protocols/openai-images.js

@@ -4,12 +4,10 @@ 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";
@@ -49,7 +47,7 @@ const StreamEvent = Schema.Union([
         usage: Schema.optional(Usage),
     }),
 ]);
-const decodeEvent = MediaProtocol.decodeFrame(ADAPTER, NAME, StreamEvent);
+const decodeEvent = route.decodeFrame(StreamEvent);
 const decodeDocument = Schema.decodeUnknownEffect(Schema.fromJsonString(OpenAIImageResponse));
 // ---------------------------------------------------------------------------
 // 5. Request body construction
@@ -66,24 +64,14 @@ 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`,
-        }));
+        return Effect.fail(route.unsupported("media.stream", `${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.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, PROVIDER, NAME).pipe(Effect.map((item) => (item.type === "ref" ? { file_id: item.value } : { image_url: item.value })));
+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;
@@ -93,17 +81,11 @@ const fromRequest = Effect.fn("OpenAIImages.fromRequest")(function* (request) {
     // 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));
+        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", MediaInput.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);
@@ -133,45 +115,40 @@ const usage = (value) => value === undefined
         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 eventImage = (frame, label, data, format) => MediaInput.decodedAsset((message, cause) => route.frameError(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);
+        const image = yield* eventImage(frame, `${route.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);
+    const image = yield* eventImage(frame, `${route.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 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 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(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(invalid(`${NAME} result ${index} has neither image data nor a URL`));
-    });
+    const images = yield* Effect.forEach(decoded.data, (item, index) => MediaInput.imageOutput(invalid, `${route.name} result ${index}`, item, mediaType, {
+        info: { format },
+        providerMetadata: item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } },
+    }));
     if (images.length === 0)
-        return yield* invalid(`${NAME} returned no images`);
+        return yield* invalid(`${route.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.fail(route.incomplete());
     return Effect.succeed([
         ImageFinishEvent.make({ usage: state.usage, providerMetadata: { openai: { outputFormat: state.format } } }),
     ]);
@@ -179,9 +156,7 @@ const finish = (state) => {
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.stream({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.stream(route, {
     unsupported: ["aspectRatio", "seed"],
     body: { from: fromRequest },
     frames: (bytes, context) => context.request.mode === "stream"
@@ -193,13 +168,7 @@ export const protocol = MediaProtocol.stream({
     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,

package/dist/protocols/openai-responses.js

@@ -10,7 +10,6 @@ import { resolveEffortUpdates } from "../effort-updates.js";
 import { OpenResponses } from "./open-responses.js";
 import { OpenResponsesOptions } from "./utils/open-responses-options.js";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
-import { OpenAIImage } from "./utils/openai-image.js";
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js";
 import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { OpenResponsesChannel } from "./open-responses-channel.js";
@@ -35,7 +34,14 @@ const OpenAIResponsesImageGenerationTool = Schema.Struct({
     output_format: Schema.optional(Schema.Literals(["png", "jpeg", "webp"])),
     partial_images: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
     quality: Schema.optional(Schema.Literals(["auto", "low", "medium", "high"])),
-    size: Schema.optional(OpenAIImage.Size),
+    size: Schema.optional(Schema.String.check(Schema.makeFilter((value) => {
+        if (value === "auto")
+            return undefined;
+        const match = /^(\d+)x(\d+)$/.exec(value);
+        if (!match)
+            return "image size must be `auto` or `{width}x{height}`";
+        return Number(match[1]) > 0 && Number(match[2]) > 0 ? undefined : "image dimensions must be positive integers";
+    }))),
 });
 const OpenAIResponsesHostedToolItem = Schema.Union([
     Schema.StructWithRest(Schema.Struct({

package/dist/protocols/openai-speech.js

@@ -2,12 +2,10 @@ import { Effect, Schema } from "effect";
 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 { SpeechModel } from "../speech.js";
 import { SpeechStream } from "./utils/speech-stream.js";
-const ADAPTER = "openai-speech";
-const NAME = "OpenAI Speech";
-const PROVIDER = ProviderID.make("openai");
+const route = MediaProtocol.identity({ id: "openai-speech", name: "OpenAI Speech", provider: "openai" });
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1";
 export const PATH = "/audio/speech";
 /** `pcm` is raw 24 kHz, 16-bit signed little-endian mono samples without a header. */
@@ -26,7 +24,7 @@ const SpeechStreamEvent = Schema.Union([
         })),
     }),
 ]);
-const decodeEvent = MediaProtocol.decodeFrame(ADAPTER, NAME, SpeechStreamEvent);
+const decodeEvent = route.decodeFrame(SpeechStreamEvent);
 // ---------------------------------------------------------------------------
 // 5. Request body construction
 // ---------------------------------------------------------------------------
@@ -71,9 +69,9 @@ const onEvent = Effect.fn("OpenAISpeech.onEvent")(function* (state, frame) {
 });
 const finish = (state, context) => {
     if (isSse(context.body) && !state.done)
-        return Effect.fail(MediaProtocol.incomplete(ADAPTER));
+        return Effect.fail(route.incomplete());
     const format = context.request.format ?? "mp3";
-    return SpeechStream.finish(ADAPTER, state, {
+    return SpeechStream.finish(route, state, {
         ...(format === "pcm" ? SpeechStream.pcm("pcm_s16le", PCM_SAMPLE_RATE) : SpeechStream.container(format)),
         usage: state.usage,
     });
@@ -81,9 +79,7 @@ const finish = (state, context) => {
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.stream({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.stream(route, {
     unsupported: ["language", "timestamps"],
     body: { from: fromRequest },
     frames: (bytes, context) => (isSse(context.body) ? Framing.sse.frame(bytes) : bytes),
@@ -91,7 +87,7 @@ export const protocol = MediaProtocol.stream({
     step: SpeechStream.step(onEvent),
     finish,
 });
-export const model = (input) => SpeechModel.fromRoute({ id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
+export const model = (input) => SpeechModel.fromRoute({ protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
 export const OpenAISpeech = {
     protocol,
     model,

package/dist/protocols/openai-transcription.js

@@ -2,14 +2,12 @@ import { Effect, Schema, Stream } from "effect";
 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 { TranscriptionFinishEvent, TranscriptionModel, TranscriptionSegmentEvent, TranscriptionTextDeltaEvent, } from "../transcription.js";
 import { mediaTypeExtension } from "../utils/media-type.js";
 import { ProviderShared } from "./shared.js";
 import { MediaInput } from "./utils/media-input.js";
-const ADAPTER = "openai-transcription";
-const NAME = "OpenAI Transcription";
-const PROVIDER = ProviderID.make("openai");
+const route = MediaProtocol.identity({ id: "openai-transcription", name: "OpenAI Transcription", provider: "openai" });
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1";
 export const PATH = "/audio/transcriptions";
 // ---------------------------------------------------------------------------
@@ -45,8 +43,8 @@ const Event = Schema.Union([
     Schema.Struct({ type: Schema.Literal("transcript.text.done"), ...transcriptFields }),
 ]);
 const Transcript = Schema.Struct(transcriptFields);
-const decodeEvent = MediaProtocol.decodeFrame(ADAPTER, NAME, Event);
-const decodeTranscript = MediaProtocol.decodeFrame(ADAPTER, NAME, Transcript);
+const decodeEvent = route.decodeFrame(Event);
+const decodeTranscript = route.decodeFrame(Transcript);
 const TRANSCRIBE = { stream: true, timestamps: [], diarize: false, languageField: "language" };
 const capabilities = (model) => {
     if (model.startsWith("whisper"))
@@ -58,20 +56,19 @@ const capabilities = (model) => {
         return { ...TRANSCRIBE, languageField: "languages" };
     return TRANSCRIBE;
 };
-const unsupported = (operation, message) => Effect.fail(ProviderShared.unsupportedOperation({ operation, provider: PROVIDER, route: ADAPTER, message }));
 const validate = (request, model) => {
     const id = request.model.id;
     if (request.mode === "stream" && !model.stream)
-        return unsupported("media.stream", `${id} does not stream; use Transcription.generate`);
+        return Effect.fail(route.unsupported("media.stream", `${id} does not stream; use Transcription.generate`));
     if (request.diarize === true && !model.diarize)
-        return unsupported("media.diarize", `${id} does not diarize; use gpt-4o-transcribe-diarize`);
+        return Effect.fail(route.unsupported("media.diarize", `${id} does not diarize; use gpt-4o-transcribe-diarize`));
     if (request.prompt !== undefined && model.diarize)
-        return unsupported("media.prompt", `${id} does not accept a prompt`);
+        return Effect.fail(route.unsupported("media.prompt", `${id} does not accept a prompt`));
     if (request.timestamps === undefined ||
         request.timestamps === "none" ||
         model.timestamps.includes(request.timestamps))
         return Effect.void;
-    return unsupported("media.timestamps", `${id} does not return ${request.timestamps} timestamps`);
+    return Effect.fail(route.unsupported("media.timestamps", `${id} does not return ${request.timestamps} timestamps`));
 };
 const RESERVED_FORM_FIELDS = new Set([
     "file",
@@ -82,26 +79,22 @@ const RESERVED_FORM_FIELDS = new Set([
     "timestamp_granularities",
     "stream",
 ]);
-const appendField = (form, key, value) => {
-    if (Array.isArray(value))
-        return value.forEach((item) => form.append(`${key}[]`, String(item)));
-    form.append(key, typeof value === "object" && value !== null ? ProviderShared.encodeJson(value) : String(value));
-};
 const fromRequest = Effect.fn("OpenAITranscription.fromRequest")(function* (request) {
     const model = capabilities(request.model.id);
     yield* validate(request, model);
     // The API detects the audio format from the upload's filename extension.
     const extension = mediaTypeExtension(request.audio.mediaType);
     if (extension === undefined)
-        return yield* ProviderShared.invalidRequest(`${NAME} cannot name a ${request.audio.mediaType} upload; send mp3, mp4, m4a, wav, webm, ogg, or flac audio`);
-    const audio = yield* MediaInput.inlineBytes(ADAPTER, request.audio);
+        return yield* ProviderShared.invalidRequest(`${route.name} cannot name a ${request.audio.mediaType} upload; send mp3, mp4, m4a, wav, webm, ogg, or flac audio`);
+    const audio = yield* MediaInput.inlineBytes(route.id, request.audio);
     const responseFormat = model.diarize
         ? "diarized_json"
         : request.timestamps === undefined || request.timestamps === "none"
             ? undefined
             : "verbose_json";
-    const native = Object.entries(mergeJsonRecords(request.providerOptions, request.http?.body) ?? {}).filter(([key]) => !RESERVED_FORM_FIELDS.has(key));
-    const fields = mergeJsonRecords({
+    const form = new FormData();
+    form.append("file", MediaInput.blob(audio, request.audio.mediaType), `audio.${extension}`);
+    MediaInput.appendFields(form, {
         model: request.model.id,
         language: model.languageField === "language" ? request.language : undefined,
         languages: model.languageField === "languages" && request.language !== undefined ? [request.language] : undefined,
@@ -111,10 +104,11 @@ const fromRequest = Effect.fn("OpenAITranscription.fromRequest")(function* (requ
         // Diarizing audio longer than 30 seconds requires a chunking strategy.
         chunking_strategy: model.diarize ? "auto" : undefined,
         stream: request.mode === "stream" ? true : undefined,
-    }, Object.fromEntries(native));
-    const form = new FormData();
-    form.append("file", MediaInput.blob(audio, request.audio.mediaType), `audio.${extension}`);
-    Object.entries(fields ?? {}).forEach(([key, value]) => appendField(form, key, value));
+    }, {
+        overlay: mergeJsonRecords(request.providerOptions, request.http?.body),
+        reserved: RESERVED_FORM_FIELDS,
+        repeatArrays: true,
+    });
     return MediaProtocol.multipart(form);
 });
 // ---------------------------------------------------------------------------
@@ -155,7 +149,7 @@ const usage = (value) => {
 const finish = (state) => {
     const transcript = state.transcript;
     if (transcript === undefined)
-        return Effect.fail(MediaProtocol.incomplete(ADAPTER));
+        return Effect.fail(route.incomplete());
     const segments = transcript.segments?.map(segment) ?? state.segments;
     return Effect.succeed([
         TranscriptionFinishEvent.make({
@@ -171,9 +165,7 @@ const finish = (state) => {
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.stream({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.stream(route, {
     unsupported: ["speakers"],
     body: { from: fromRequest },
     frames: (bytes, context) => context.request.mode === "stream"
@@ -183,7 +175,7 @@ export const protocol = MediaProtocol.stream({
     step,
     finish,
 });
-export const model = (input) => TranscriptionModel.fromRoute({ id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
+export const model = (input) => TranscriptionModel.fromRoute({ protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
 export const OpenAITranscription = {
     protocol,
     model,

package/dist/protocols/replicate-images.js

@@ -3,11 +3,9 @@ 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 { mergeJsonRecords } from "../schema/index.js";
 import { ProviderShared, optionalNull } from "./shared.js";
-const ADAPTER = "replicate-images";
-const NAME = "Replicate";
-const PROVIDER = ProviderID.make("replicate");
+const route = MediaProtocol.identity({ id: "replicate-images", name: "Replicate", provider: "replicate" });
 export const DEFAULT_BASE_URL = "https://api.replicate.com";
 const OUTPUT_RETENTION = Duration.hours(1);
 const MAX_DATA_URL_BYTES = 256 * 1024;
@@ -50,8 +48,8 @@ const inlineSize = (source) => {
 };
 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));
+        return Effect.fail(ProviderShared.invalidRequest(`${route.name} data URL inputs are limited to 256 KB; pass a larger file by https URL`));
+    return ProviderShared.mediaReference(asset, undefined, route.name).pipe(Effect.map((reference) => reference.value));
 };
 const inputValue = (value) => {
     if (value instanceof Media.Asset)
@@ -69,7 +67,7 @@ const fromRequest = Effect.fn("ReplicateImages.fromRequest")(function* (request)
 // ---------------------------------------------------------------------------
 // 6. Response decoding
 // ---------------------------------------------------------------------------
-const decodePrediction = MediaProtocol.decodeJson(ADAPTER, NAME, Prediction);
+const decodePrediction = route.decodeJson(Prediction);
 const decodeStart = Effect.fn("ReplicateImages.decodeStart")(function* (response) {
     const output = yield* decodePrediction(response);
     const prediction = output.value;
@@ -88,16 +86,16 @@ const decodeResult = Effect.fn("ReplicateImages.decodeResult")(function* (respon
     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}` : ""}`);
+        return yield* output.ended(status, `${route.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`);
+        return yield* output.invalid(`${route.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}`);
+        return yield* output.ended("expired", `${route.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`);
+        return yield* output.invalid(`${route.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`);
+        return yield* output.invalid(`${route.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);
@@ -110,9 +108,7 @@ const decodeResult = Effect.fn("ReplicateImages.decodeResult")(function* (respon
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.queued({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.queued(route, {
     token: Token,
     unsupported: ["images", "mask", "n", "size", "aspectRatio", "seed", "format"],
     start: { body: { from: fromRequest }, decode: decodeStart },
@@ -121,8 +117,6 @@ export const protocol = MediaProtocol.queued({
     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",

package/dist/protocols/runway-video.d.ts

@@ -1,6 +1,7 @@
 import { Schema } from "effect";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
+import { type OpenString } from "../schema/index.js";
 import { VideoModel, VideoResponse, type VideoRequestFor } from "../video.js";
 export declare const DEFAULT_BASE_URL = "https://api.dev.runwayml.com/v1";
 /** Every Runway request must pin the API version. */
@@ -9,7 +10,6 @@ export declare const TEXT_TO_VIDEO_PATH = "/text_to_video";
 export declare const IMAGE_TO_VIDEO_PATH = "/image_to_video";
 export declare const VIDEO_TO_VIDEO_PATH = "/video_to_video";
 export declare const TASKS_PATH = "/tasks";
-export type RunwayVideoString<Known extends string> = Known | (string & {});
 /**
  * Provider-native options. Common fields lower to Runway's names: `aspectRatio` → `ratio` (Runway expects pixel
  * ratios such as `1280:720` for most models), `durationSeconds` → `duration`, `audio`, `negativePrompt`,
@@ -17,9 +17,9 @@ export type RunwayVideoString<Known extends string> = Known | (string & {});
  */
 export type RunwayVideoOptions = {
     readonly contentModeration?: {
-        readonly publicFigureThreshold?: RunwayVideoString<"auto" | "low">;
+        readonly publicFigureThreshold?: OpenString<"auto" | "low">;
     };
-    readonly outputFormat?: RunwayVideoString<"mp4" | "prores" | "png_sequence">;
+    readonly outputFormat?: OpenString<"mp4" | "prores" | "png_sequence">;
 } & Record<string, unknown>;
 export type Request = VideoRequestFor<RunwayVideoOptions>;
 export declare const Token: Schema.Struct<{

package/dist/protocols/runway-video.js

@@ -2,12 +2,10 @@ import { Duration, Effect, Schema } from "effect";
 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 { mergeJsonRecords } from "../schema/index.js";
 import { VideoModel, VideoResponse } from "../video.js";
 import { ProviderShared, optionalArray, optionalNull } from "./shared.js";
-const ADAPTER = "runway-video";
-const NAME = "Runway";
-const PROVIDER = ProviderID.make("runway");
+const route = MediaProtocol.identity({ id: "runway-video", name: "Runway", provider: "runway" });
 export const DEFAULT_BASE_URL = "https://api.dev.runwayml.com/v1";
 /** Every Runway request must pin the API version. */
 export const API_VERSION = "2024-11-06";
@@ -44,7 +42,7 @@ const STATUS = {
 // 5. Request body construction
 // ---------------------------------------------------------------------------
 // Runway accepts HTTPS URLs, `runway://` upload URIs, and data URIs, all as one string.
-const mediaUri = (asset) => ProviderShared.mediaReference(asset, PROVIDER, NAME).pipe(Effect.map((reference) => reference.value));
+const mediaUri = (asset) => ProviderShared.mediaReference(asset, route.provider, route.name).pipe(Effect.map((reference) => reference.value));
 const fromRequest = Effect.fn("RunwayVideo.fromRequest")(function* (request) {
     const first = request.frames?.first === undefined ? undefined : yield* mediaUri(request.frames.first);
     const last = request.frames?.last === undefined ? undefined : yield* mediaUri(request.frames.last);
@@ -71,11 +69,11 @@ const fromRequest = Effect.fn("RunwayVideo.fromRequest")(function* (request) {
 // ---------------------------------------------------------------------------
 // 6. Response decoding
 // ---------------------------------------------------------------------------
-const decodeStart = MediaProtocol.decodeStarted(ADAPTER, NAME, StartResponse, (value) => ({
+const decodeStart = route.decodeStarted(StartResponse, (value) => ({
     token: { taskID: value.id },
     snapshot: { id: value.id, status: "queued" },
 }));
-const decodeTask = MediaProtocol.decodeJson(ADAPTER, NAME, Task);
+const decodeTask = route.decodeJson(Task);
 const decodeStatus = Effect.fn("RunwayVideo.decodeStatus")(function* (response, context) {
     const output = yield* decodeTask(response);
     const status = yield* MediaProtocol.status(STATUS, output.value.status, output);
@@ -87,19 +85,19 @@ const decodeResult = Effect.fn("RunwayVideo.decodeResult")(function* (response,
     const status = yield* MediaProtocol.status(STATUS, task.status, output);
     if (status === "failed") {
         const code = task.failureCode ?? undefined;
-        const message = `${NAME} task failed${code === undefined ? "" : ` (${code})`}${task.failure ? `: ${task.failure}` : ""}`;
+        const message = `${route.name} task failed${code === undefined ? "" : ` (${code})`}${task.failure ? `: ${task.failure}` : ""}`;
         // Runway failure codes are dotted paths; every moderation outcome carries a SAFETY segment.
         if (code !== undefined && /(^|\.)SAFETY(\.|$)/.test(code))
             return yield* output.contentPolicy(message);
         return yield* output.ended("failed", message);
     }
     if (status === "cancelled")
-        return yield* output.ended("cancelled", `${NAME} task ${context.token.taskID} was cancelled`);
+        return yield* output.ended("cancelled", `${route.name} task ${context.token.taskID} was cancelled`);
     if (status !== "completed")
-        return yield* output.invalid(`${NAME} task ${context.token.taskID} has not finished`);
+        return yield* output.invalid(`${route.name} task ${context.token.taskID} has not finished`);
     const urls = task.output ?? [];
     if (urls.length === 0)
-        return yield* output.invalid(`${NAME} task succeeded without any output`);
+        return yield* output.invalid(`${route.name} task succeeded without any output`);
     return new VideoResponse({
         videos: yield* Effect.forEach(urls, (url) => MediaProtocol.expiringUrl(url, OUTPUT_RETENTION, { mediaType: "video/mp4" })),
         usage: task.cost === undefined ? undefined : { type: "credits", credits: task.cost.credits },
@@ -115,9 +113,7 @@ const decodeResult = Effect.fn("RunwayVideo.decodeResult")(function* (response,
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
 const taskPath = (token) => `${TASKS_PATH}/${token.taskID}`;
-export const protocol = MediaProtocol.queued({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.queued(route, {
     token: Token,
     unsupported: ["n"],
     start: { body: { from: fromRequest }, decode: decodeStart },
@@ -133,8 +129,6 @@ const startPath = (request) => {
     return TEXT_TO_VIDEO_PATH;
 };
 export const model = (input) => VideoModel.fromRoute({
-    id: ADAPTER,
-    provider: PROVIDER,
     protocol,
     baseURL: DEFAULT_BASE_URL,
     headers: { "X-Runway-Version": API_VERSION },