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

package/dist/protocols/shared.d.ts

@@ -1,20 +1,18 @@
 import { Tool } from "@opencode/schema/tool";
-import { Effect, Schema, Stream } from "effect";
+import { Effect, Schema } from "effect";
 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 { AIError, LLMRequest, Message, ToolDefinition, type ContentPart, type MediaPart, type OpenString, type ProviderID, type ToolEntry, type ToolResultPart } from "../schema/index.js";
+import { Json, decodeJson, encodeJson } from "../utils/json.js";
 import { isRecord } from "../utils/record.js";
-export { isRecord };
-export declare const Json: Schema.fromJsonString<Schema.Unknown>;
-export declare const decodeJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => unknown;
-export declare const encodeJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string;
+export { Json, decodeJson, encodeJson, isRecord };
 export declare const JsonObject: Schema.$Record<Schema.String, Schema.Unknown>;
 export declare const optionalArray: <const S extends Schema.Top>(schema: S) => Schema.optional<Schema.$Array<S>>;
 export declare const optionalNull: <const S extends Schema.Top>(schema: S) => Schema.optional<Schema.NullOr<S>>;
 /** Optional field whose malformed value decodes to `undefined` instead of failing the enclosing struct. */
 export declare const lenient: <const S extends Schema.Top>(schema: S) => Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<S>, S["DecodingServices"]>>;
 /** Provider-defined string enum: known values for autocomplete, any string accepted at runtime. */
-export declare const knownString: <Known extends string>() => Schema.declare<(string & {}) | Known, (string & {}) | Known>;
+export declare const knownString: <Known extends string>() => Schema.declare<OpenString<Known>, OpenString<Known>>;
 export declare const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
 export declare const promptCacheKey: (request: LLMRequest) => string | undefined;
 /**
@@ -131,18 +129,8 @@ export declare const mediaReference: (asset: Media.Asset, provider: ProviderID |
  * `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 and known
- * keepalives that proxies send as data. `[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>;
 /**
  * Canonical invalid-request constructor shared by protocol lowering.
  */

package/dist/protocols/shared.js

@@ -1,14 +1,11 @@
 import { Tool } from "@opencode/schema/tool";
-import { Effect, Option, Schema, Stream } from "effect";
-import * as Sse from "effect/unstable/encoding/Sse";
+import { Effect, Option, Schema } from "effect";
 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 { Json, decodeJson, encodeJson } from "../utils/json.js";
 import { isRecord } from "../utils/record.js";
-export { isRecord };
-export const Json = Schema.fromJsonString(Schema.Unknown);
-export const decodeJson = Schema.decodeUnknownSync(Json);
-export const encodeJson = Schema.encodeSync(Json);
+export { Json, decodeJson, encodeJson, isRecord };
 const isJson = Schema.is(Schema.Json);
 export const JsonObject = Schema.Record(Schema.String, Schema.Unknown);
 export const optionalArray = (schema) => Schema.optional(Schema.Array(schema));
@@ -165,7 +162,6 @@ export const toolFileMedia = (item) => {
             : Media.base64(item.uri, item.mime);
     return Message.media(asset, { filename: item.name });
 };
-export const trimBaseUrl = (value) => value.replace(/\/+$/, "");
 export const toolResultText = (part) => {
     if (part.result.type === "text")
         return String(part.result.value);
@@ -190,38 +186,6 @@ export const errorText = (error) => {
         return "undefined";
     return "Unknown stream error";
 };
-/**
- * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
- * decoder, optionally filters named events, and drops empty events and known
- * keepalives that proxies send as data. `[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 = [];
-    return {
-        output,
-        parser: Sse.makeParser((event) => {
-            if (event._tag === "Event")
-                output.push(event);
-        }),
-    };
-}, (state, chunk) => Effect.gen(function* () {
-    const error = state.parser.feed(chunk);
-    if (error)
-        return yield* eventError("sse", error.message, chunk, error);
-    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" &&
-    // Vertex AI partner models (e.g. `xai/grok-4.6`) send their SSE
-    // keepalive comment as `data: : keepalive` while reasoning.
-    event.data !== ": keepalive" &&
-    (event.data !== "[DONE]" || includeDone || (events !== undefined && event.event !== "message"))), Stream.map((event) => event.data));
 /**
  * Canonical invalid-request constructor shared by protocol lowering.
  */

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

@@ -2,8 +2,9 @@ import { Schema } from "effect";
 import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
+import { type OpenString } from "../schema/index.js";
 export declare const DEFAULT_BASE_URL = "https://api.stability.ai";
-export type StabilityStylePreset = "enhance" | "anime" | "photographic" | "digital-art" | "comic-book" | "fantasy-art" | "line-art" | "analog-film" | "neon-punk" | "isometric" | "low-poly" | "origami" | "modeling-compound" | "cinematic" | "3d-model" | "pixel-art" | "tile-texture" | (string & {});
+export type StabilityStylePreset = OpenString<"enhance" | "anime" | "photographic" | "digital-art" | "comic-book" | "fantasy-art" | "line-art" | "analog-film" | "neon-punk" | "isometric" | "low-poly" | "origami" | "modeling-compound" | "cinematic" | "3d-model" | "pixel-art" | "tile-texture">;
 export type StabilityImageOptions = {
     readonly negative_prompt?: string;
     readonly style_preset?: StabilityStylePreset;

package/dist/protocols/stability-images.js

@@ -2,13 +2,11 @@ import { Effect, Schema } from "effect";
 import { ImageModel, ImageResponse } from "../image.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 = "stability-images";
-const UPSCALE_ADAPTER = "stability-upscale";
-const NAME = "Stability AI";
-const PROVIDER = ProviderID.make("stability");
+const route = MediaProtocol.identity({ id: "stability-images", name: "Stability AI", provider: "stability" });
+const upscaleRoute = MediaProtocol.identity({ id: "stability-upscale", name: "Stability AI", provider: "stability" });
 export const DEFAULT_BASE_URL = "https://api.stability.ai";
 const RESULTS_PATH = "/v2beta/results";
 const UPSCALE_MODEL = "creative";
@@ -32,26 +30,24 @@ const Started = Schema.Struct({ id: Schema.String });
 /** `sd3.5-*` ids share the `sd3` endpoint and select the model with a form field. */
 const endpoint = (model) => (model.startsWith("sd3") ? "sd3" : model);
 const RESERVED_FORM_FIELDS = new Set(["image", "prompt", "mode", "model"]);
-const unsupported = (route, operation, message) => ProviderShared.unsupportedOperation({ operation, provider: PROVIDER, route, message });
-const form = Effect.fn("StabilityImages.form")(function* (route, fields, native, source) {
+const form = Effect.fn("StabilityImages.form")(function* (identity, fields, native, source) {
     if ((source?.length ?? 0) > 1)
-        return yield* unsupported(route, "media.images", `${NAME} takes one source image`);
+        return yield* identity.unsupported("media.images", `${identity.name} takes one source image`);
     const body = new FormData();
-    const overlay = Object.entries(native ?? {}).filter(([key]) => !RESERVED_FORM_FIELDS.has(key));
-    Object.entries(mergeJsonRecords(fields, Object.fromEntries(overlay)) ?? {}).forEach(([key, value]) => body.append(key, typeof value === "string" ? value : ProviderShared.encodeJson(value)));
+    MediaInput.appendFields(body, fields, { overlay: native, reserved: RESERVED_FORM_FIELDS });
     const image = source?.[0];
     if (image !== undefined)
-        body.append("image", MediaInput.blob(yield* MediaInput.inlineBytes(route, image), image.mediaType), "image");
+        body.append("image", MediaInput.blob(yield* MediaInput.inlineBytes(identity.id, image), image.mediaType), "image");
     return MediaProtocol.multipart(body);
 });
 const fromRequest = Effect.fn("StabilityImages.fromRequest")(function* (request) {
     if (request.n !== undefined && request.n > 1)
-        return yield* unsupported(ADAPTER, "media.n", `${NAME} generates one image per request; call it once per image`);
+        return yield* route.unsupported("media.n", `${route.name} generates one image per request; call it once per image`);
     const target = endpoint(request.model.id);
     const edit = (request.images?.length ?? 0) > 0;
     if (edit && target === "core")
-        return yield* unsupported(ADAPTER, "media.images", `${NAME} core is text-to-image only; use ultra or sd3.5-*`);
-    return yield* form(ADAPTER, {
+        return yield* route.unsupported("media.images", `${route.name} core is text-to-image only; use ultra or sd3.5-*`);
+    return yield* form(route, {
         prompt: request.prompt,
         aspect_ratio: request.aspectRatio,
         seed: request.seed,
@@ -62,33 +58,33 @@ const fromRequest = Effect.fn("StabilityImages.fromRequest")(function* (request)
 });
 const fromUpscaleRequest = Effect.fn("StabilityImages.fromUpscaleRequest")(function* (request) {
     if ((request.images?.length ?? 0) === 0)
-        return yield* ProviderShared.invalidRequest(`${NAME} upscale requires the source image in images`);
-    return yield* form(UPSCALE_ADAPTER, { prompt: request.prompt, seed: request.seed, output_format: request.format }, mergeJsonRecords(request.providerOptions, request.http?.body), request.images);
+        return yield* ProviderShared.invalidRequest(`${upscaleRoute.name} upscale requires the source image in images`);
+    return yield* form(upscaleRoute, { prompt: request.prompt, seed: request.seed, output_format: request.format }, mergeJsonRecords(request.providerOptions, request.http?.body), request.images);
 });
 // ---------------------------------------------------------------------------
 // 6. Response decoding
 // ---------------------------------------------------------------------------
-const decodeImageDocument = (route) => {
-    const decode = MediaProtocol.decodeJson(route, NAME, ImageDocument);
+const decodeImageDocument = (identity) => {
+    const decode = identity.decodeJson(ImageDocument);
     return Effect.fn("StabilityImages.decodeImage")(function* (response) {
         const output = yield* decode(response);
         const document = output.value;
         const data = document.image ?? document.result;
         if (data === undefined)
-            return yield* output.invalid(`${NAME} returned no image`);
-        const image = yield* MediaInput.decodedAsset(output.invalid, `${NAME} result`, data, undefined);
+            return yield* output.invalid(`${identity.name} returned no image`);
+        const image = yield* MediaInput.decodedAsset(output.invalid, `${identity.name} result`, data, undefined);
         return new ImageResponse({
             images: [image],
             notices: document.finish_reason === "CONTENT_FILTERED"
-                ? [{ type: "moderated", message: `${NAME} blurred the image for violating its content policy` }]
+                ? [{ type: "moderated", message: `${identity.name} blurred the image for violating its content policy` }]
                 : undefined,
             providerMetadata: { stability: { seed: document.seed, finishReason: document.finish_reason } },
         });
     });
 };
-const decodeResponse = decodeImageDocument(ADAPTER);
-const decodeUpscaleImage = decodeImageDocument(UPSCALE_ADAPTER);
-const decodeStart = MediaProtocol.decodeStarted(UPSCALE_ADAPTER, NAME, Started, (value) => ({
+const decodeResponse = decodeImageDocument(route);
+const decodeUpscaleImage = decodeImageDocument(upscaleRoute);
+const decodeStart = upscaleRoute.decodeStarted(Started, (value) => ({
     token: { id: value.id },
     snapshot: { id: value.id, status: "queued" },
 }));
@@ -99,24 +95,20 @@ const decodeStatus = (response, context) => Effect.succeed({
 });
 const decodeUpscaleResult = Effect.fn("StabilityImages.decodeUpscaleResult")(function* (response, context) {
     if (response.status === 202) {
-        const output = yield* MediaProtocol.text(UPSCALE_ADAPTER, NAME, response);
-        return yield* output.invalid(`${NAME} upscale ${context.token.id} has not finished`);
+        const output = yield* upscaleRoute.text(response);
+        return yield* output.invalid(`${upscaleRoute.name} upscale ${context.token.id} has not finished`);
     }
     return yield* decodeUpscaleImage(response);
 });
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.inline({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.inline(route, {
     unsupported: ["size", "mask"],
     body: { from: fromRequest },
     response: { decode: decodeResponse },
 });
-export const upscaleProtocol = MediaProtocol.queued({
-    id: UPSCALE_ADAPTER,
-    name: NAME,
+export const upscaleProtocol = MediaProtocol.queued(upscaleRoute, {
     token: Token,
     unsupported: ["n", "size", "aspectRatio", "mask"],
     start: { body: { from: fromUpscaleRequest }, decode: decodeStart },
@@ -124,16 +116,12 @@ export const upscaleProtocol = MediaProtocol.queued({
     result: { path: (token) => `${RESULTS_PATH}/${token.id}`, decode: decodeUpscaleResult },
 });
 export const model = (input) => ImageModel.fromRoute({
-    id: ADAPTER,
-    provider: PROVIDER,
     protocol,
     baseURL: DEFAULT_BASE_URL,
     headers: HEADERS,
     path: ({ request }) => `/v2beta/stable-image/generate/${endpoint(request.model.id)}`,
 }, input);
 export const upscaleModel = (input) => ImageModel.fromRoute({
-    id: UPSCALE_ADAPTER,
-    provider: PROVIDER,
     protocol: upscaleProtocol,
     baseURL: DEFAULT_BASE_URL,
     headers: HEADERS,

package/dist/protocols/utils/fal-queue.d.ts

@@ -13,9 +13,7 @@ export declare const Token: Schema.Struct<{
 }>;
 export type Token = Schema.Schema.Type<typeof Token>;
 export declare const mediaUrl: (asset: Media.Asset, name: string) => Effect.Effect<string, AIError, never>;
-export declare const protocol: <Request, Response>(input: {
-    readonly id: string;
-    readonly name: string;
+export declare const protocol: <Request, Response>(route: MediaProtocol.Identity, input: {
     readonly unsupported?: ReadonlyArray<keyof Request & string>;
     readonly from: (request: Request) => Effect.Effect<MediaProtocol.Body, AIError>;
     readonly decodeResult: (response: HttpClientResponse.HttpClientResponse, context: MediaProtocol.PollContext<Token>) => Effect.Effect<Response, AIError>;

package/dist/protocols/utils/fal-queue.js

@@ -28,16 +28,14 @@ const STATUS = {
 };
 // fal accepts public URLs and data URIs; there is no provider file handle to forward.
 export const mediaUrl = (asset, name) => ProviderShared.mediaReference(asset, undefined, name).pipe(Effect.map((reference) => reference.value));
-export const protocol = (input) => {
-    const decodeQueueStatus = MediaProtocol.decodeJson(input.id, input.name, QueueStatus);
-    return MediaProtocol.queued({
-        id: input.id,
-        name: input.name,
+export const protocol = (route, input) => {
+    const decodeQueueStatus = route.decodeJson(QueueStatus);
+    return MediaProtocol.queued(route, {
         token: Token,
         unsupported: input.unsupported,
         start: {
             body: { from: input.from },
-            decode: MediaProtocol.decodeStarted(input.id, input.name, StartResponse, (value) => ({
+            decode: route.decodeStarted(StartResponse, (value) => ({
                 token: {
                     requestID: value.request_id,
                     statusURL: value.status_url,

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

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
 import { Media } from "../../media.js";
 import type { MediaProtocol } from "../../route/media-protocol.js";
-import type { AIError, ProviderID } from "../../schema/index.js";
+import { type AIError, type 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>;
 /** Copied because `BlobPart` requires a plain `ArrayBuffer`. */
@@ -15,4 +15,18 @@ export declare const dimensions: (size: string) => {
 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>;
+/** One image of an OpenAI-shaped `data` array, which carries either `b64_json` or a `url`. */
+export declare const imageOutput: (invalid: (message: string, cause?: unknown) => AIError, label: string, item: {
+    readonly b64_json?: string | null;
+    readonly url?: string | null;
+}, mediaType: string | undefined, options?: Media.AssetOptions) => Effect.Effect<Media.Asset, AIError, never>;
+/**
+ * Append multipart text fields: strings as-is, other values as JSON, or arrays as repeated `key[]` parts with
+ * `repeatArrays`. `overlay` keys in `reserved` are dropped so `http.body` cannot replace route-owned fields.
+ */
+export declare const appendFields: (form: FormData, fields: Record<string, unknown>, options: {
+    readonly overlay?: Record<string, unknown>;
+    readonly reserved: ReadonlySet<string>;
+    readonly repeatArrays?: true;
+}) => void;
 export * as MediaInput from "./media-input.js";

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

@@ -1,5 +1,7 @@
 import { Effect, Encoding } from "effect";
 import { Media } from "../../media.js";
+import { mergeJsonRecords } from "../../schema/index.js";
+import { encodeJson } from "../../utils/json.js";
 import { ProviderShared } from "../shared.js";
 /** Owned bytes for multipart uploads; decodes `base64` sources and rejects remote sources. */
 export const inlineBytes = (route, asset) => {
@@ -32,4 +34,24 @@ export const dimensions = (size) => {
 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)));
+/** One image of an OpenAI-shaped `data` array, which carries either `b64_json` or a `url`. */
+export const imageOutput = (invalid, label, item, mediaType, options) => {
+    if (item.b64_json)
+        return decodedAsset(invalid, label, item.b64_json, mediaType, options);
+    if (item.url)
+        return Effect.succeed(Media.url(item.url, { ...options, mediaType }));
+    return Effect.fail(invalid(`${label} has neither image data nor a URL`));
+};
+/**
+ * Append multipart text fields: strings as-is, other values as JSON, or arrays as repeated `key[]` parts with
+ * `repeatArrays`. `overlay` keys in `reserved` are dropped so `http.body` cannot replace route-owned fields.
+ */
+export const appendFields = (form, fields, options) => {
+    const overlay = Object.entries(options.overlay ?? {}).filter(([key]) => !options.reserved.has(key));
+    Object.entries(mergeJsonRecords(fields, Object.fromEntries(overlay)) ?? {}).forEach(([key, value]) => {
+        if (Array.isArray(value) && options.repeatArrays)
+            return value.forEach((item) => form.append(`${key}[]`, String(item)));
+        form.append(key, typeof value === "string" ? value : encodeJson(value));
+    });
+};
 export * as MediaInput from "./media-input.js";

package/dist/protocols/utils/speech-stream.d.ts

@@ -1,6 +1,7 @@
 import { Effect } from "effect";
 import { Media } from "../../media.js";
-import type { AIError, MediaUsage, ProviderID, ProviderMetadata } from "../../schema/index.js";
+import type { MediaProtocol } from "../../route/media-protocol.js";
+import type { AIError, MediaUsage, ProviderMetadata } from "../../schema/index.js";
 import { type SpeechEvent, type SpeechVoice } from "../../speech.js";
 export interface Audio {
     /** Appended in place: the route creates fresh state for each response through `initial`. */
@@ -36,9 +37,8 @@ export declare const pcm: (encoding: PcmEncoding, sampleRate: number | undefined
     };
 };
 export declare const sampleRate: (mediaType: string | undefined) => number | undefined;
-export declare const unsupportedFormat: (provider: ProviderID, route: string, message: string) => AIError;
 /** A declared `mediaType` wins over sniffing: headerless PCM can start with bytes that look like an MPEG frame sync. */
-export declare const finish: (route: string, state: Audio, output: {
+export declare const finish: (route: MediaProtocol.Identity, state: Audio, output: {
     readonly mediaType: string | undefined;
     readonly info?: Media.Info;
     readonly usage?: MediaUsage;

package/dist/protocols/utils/speech-stream.js

@@ -1,9 +1,7 @@
 import { Effect } from "effect";
 import { Media } from "../../media.js";
-import { MediaProtocol } from "../../route/media-protocol.js";
 import { SpeechAudioDeltaEvent, SpeechFinishEvent, SpeechTimestampsEvent, } from "../../speech.js";
 import { concatBytes } from "../../utils/bytes.js";
-import { ProviderShared } from "../shared.js";
 /** Empty chunks (keep-alive records) emit nothing. */
 export const delta = (state, chunk) => {
     if (chunk.length === 0)
@@ -45,11 +43,10 @@ export const sampleRate = (mediaType) => {
     const rate = /rate=(\d+)/i.exec(mediaType ?? "")?.[1];
     return rate === undefined ? undefined : Number(rate);
 };
-export const unsupportedFormat = (provider, route, message) => ProviderShared.unsupportedOperation({ operation: "media.format", provider, route, message });
 /** A declared `mediaType` wins over sniffing: headerless PCM can start with bytes that look like an MPEG frame sync. */
 export const finish = (route, state, output) => {
     if (state.chunks.length === 0)
-        return Effect.fail(MediaProtocol.frameError(route, `The provider returned no audio${output.detail === undefined ? "" : ` (${output.detail})`}`));
+        return Effect.fail(route.frameError(`The provider returned no audio${output.detail === undefined ? "" : ` (${output.detail})`}`));
     return Effect.succeed([
         SpeechFinishEvent.make({
             audio: Media.bytes(concatBytes(state.chunks), output.mediaType, { info: output.info }),

package/dist/protocols/utils/tool-schema.js

@@ -54,18 +54,31 @@ const MODEL_NAMES = [
     [/gemini/i, "gemini"],
     [/kimi/i, "moonshot"],
 ];
-// An explicit `sanitizer` wins, and `none` opts out. Otherwise the protocol's own default
-// applies (the Gemini API always uses Gemini's rules), then the model name selects the family's rules
-// so models reached through gateways and OpenAI-compatible endpoints get the same handling.
+// Tool arguments are always a JSON object, and most providers reject a tool schema whose root does not
+// declare `type: "object"`, such as `{}` or a bare `properties` map. Effect encodes an empty struct as
+// `anyOf` object or array; every object matches its bare object branch, so that `anyOf` is dropped.
+const objectRoot = (schema) => {
+    if (schema.type !== undefined)
+        return schema;
+    if (Array.isArray(schema.anyOf) &&
+        schema.anyOf.some((branch) => isRecord(branch) && branch.type === "object" && Object.keys(branch).length === 1))
+        return { type: "object", ...Object.fromEntries(Object.entries(schema).filter(([key]) => key !== "anyOf")) };
+    return { type: "object", ...schema };
+};
+// Every tool schema gets an object root. Then an explicit `sanitizer` wins, and `none` opts out.
+// Otherwise the protocol's own default applies (the Gemini API always uses Gemini's rules), then the
+// model name selects the family's rules so models reached through gateways and OpenAI-compatible
+// endpoints get the same handling.
 const modelCompatibility = (schema, model, protocolDefault) => {
+    const root = objectRoot(schema);
     switch (model.compatibility?.sanitizer ?? protocolDefault ?? MODEL_NAMES.find(([name]) => name.test(model.id))?.[1]) {
         case "gemini":
-            return gemini(schema);
+            return gemini(root);
         case "moonshot":
-            return moonshot(schema);
+            return moonshot(root);
         case "none":
         case undefined:
-            return schema;
+            return root;
     }
 };
 export const ToolSchemaProjection = {

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

@@ -1,15 +1,15 @@
 import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
+import { type OpenString } from "../schema/index.js";
 export declare const DEFAULT_BASE_URL = "https://api.x.ai/v1";
 export declare const PATH = "/images/generations";
 export declare const EDIT_PATH = "/images/edits";
-export type XAIImageString<Known extends string> = Known | (string & {});
 /** Provider-native options. Common fields (`n`, `aspectRatio`, `images`) live on the request. */
 export type XAIImageOptions = {
-    readonly resolution?: XAIImageString<"1k" | "2k">;
-    readonly responseFormat?: XAIImageString<"url" | "b64_json">;
-    readonly response_format?: XAIImageString<"url" | "b64_json">;
+    readonly resolution?: OpenString<"1k" | "2k">;
+    readonly responseFormat?: OpenString<"url" | "b64_json">;
+    readonly response_format?: OpenString<"url" | "b64_json">;
 } & Record<string, unknown>;
 export type Request = ImageRequestFor<XAIImageOptions>;
 export declare const protocol: MediaProtocol.Inline<Request, ImageResponse>;

package/dist/protocols/xai-images.js

@@ -3,12 +3,10 @@ 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";
 import { MediaInput } from "./utils/media-input.js";
-const ADAPTER = "xai-images";
-const NAME = "xAI Images";
-const PROVIDER = ProviderID.make("xai");
+const route = MediaProtocol.identity({ id: "xai-images", name: "xAI Images", provider: "xai" });
 export const DEFAULT_BASE_URL = "https://api.x.ai/v1";
 export const PATH = "/images/generations";
 export const EDIT_PATH = "/images/edits";
@@ -34,7 +32,7 @@ const nativeOptions = (options) => {
     return { response_format: responseFormat, ...native };
 };
 const isEdit = (request) => (request.images?.length ?? 0) > 0;
-const reference = (asset) => ProviderShared.mediaReference(asset, PROVIDER, NAME).pipe(Effect.map((item) => item.type === "ref" ? { file_id: item.value } : { url: item.value, type: "image_url" }));
+const reference = (asset) => ProviderShared.mediaReference(asset, route.provider, route.name).pipe(Effect.map((item) => item.type === "ref" ? { file_id: item.value } : { url: item.value, type: "image_url" }));
 const fromRequest = Effect.fn("XAIImages.fromRequest")(function* (request) {
     const references = yield* Effect.forEach(request.images ?? [], reference);
     return MediaProtocol.json(mergeJsonRecords({
@@ -50,23 +48,17 @@ const fromRequest = Effect.fn("XAIImages.fromRequest")(function* (request) {
 // ---------------------------------------------------------------------------
 // 6. Response decoding
 // ---------------------------------------------------------------------------
+const decodeDocument = route.decodeJson(XAIImageResponse);
 const decodeResponse = Effect.fn("XAIImages.decodeResponse")(function* (response) {
-    const output = yield* MediaProtocol.decodeJson(ADAPTER, NAME, XAIImageResponse)(response);
+    const output = yield* decodeDocument(response);
     const decoded = output.value;
-    const images = yield* Effect.forEach(decoded.data, (item, index) => {
-        const providerMetadata = item.revised_prompt === undefined || item.revised_prompt === null
+    const images = yield* Effect.forEach(decoded.data, (item, index) => MediaInput.imageOutput(output.invalid, `${route.name} result ${index}`, item, item.mime_type ?? undefined, {
+        providerMetadata: item.revised_prompt === undefined || item.revised_prompt === null
             ? undefined
-            : { xai: { revisedPrompt: item.revised_prompt } };
-        if (item.b64_json)
-            return MediaInput.decodedAsset(output.invalid, `${NAME} result ${index}`, item.b64_json, item.mime_type ?? undefined, {
-                providerMetadata,
-            });
-        if (item.url)
-            return Effect.succeed(Media.url(item.url, { mediaType: item.mime_type ?? undefined, providerMetadata }));
-        return Effect.fail(output.invalid(`${NAME} result ${index} has neither image data nor a URL`));
-    });
+            : { xai: { revisedPrompt: item.revised_prompt } },
+    }));
     if (images.length === 0)
-        return yield* output.invalid(`${NAME} returned no images`);
+        return yield* output.invalid(`${route.name} returned no images`);
     const usage = ProviderShared.isRecord(decoded.usage) ? decoded.usage : undefined;
     // xAI reports image counts rather than tokens, seconds, or credits; the raw record stays in provider metadata.
     return new ImageResponse({
@@ -77,20 +69,12 @@ const decodeResponse = Effect.fn("XAIImages.decodeResponse")(function* (response
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.inline({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.inline(route, {
     unsupported: ["mask", "size", "seed", "format"],
     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 model = (input) => ImageModel.fromRoute({ protocol, baseURL: DEFAULT_BASE_URL, path: ({ request }) => (isEdit(request) ? EDIT_PATH : PATH) }, input);
 export const XAIImages = {
     protocol,
     model,