@opencode/ai 2.0.16 → 2.0.17

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.pending(context.token.id);
     }
     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/responses-checkpoint.js

@@ -1,7 +1,7 @@
 import { Effect, Schema, Stream } from "effect";
 import { Route } from "../../route/client.js";
 import { Protocol } from "../../route/protocol.js";
-import { CompactionCheckpointResponse, HttpOptions, LLMEvent, LLMRequest } from "../../schema/index.js";
+import { CompactionCheckpointResponse, LLMEvent, LLMRequest } from "../../schema/index.js";
 import { OpenResponses } from "../open-responses.js";
 import { ProviderShared } from "../shared.js";
 const onOutputItem = Effect.fn("ResponsesCheckpoint.onOutputItem")(function* (state, input) {
@@ -94,12 +94,8 @@ export const make = (body) => Effect.fn("ResponsesCheckpoint.execute")(function*
         transport: source.transport,
     });
     const native = yield* body.from(request);
-    // The body builder already applied and validated overlays. Do not let transport reapply them.
-    const preparedRequest = LLMRequest.update(request, {
-        http: request.http === undefined ? undefined : new HttpOptions({ ...request.http, body: undefined }),
-    });
-    const prepared = yield* route.prepareTransport(native, preparedRequest, options);
-    yield* route.streamPrepared(prepared, preparedRequest, { http: executor }, options).pipe(Stream.runDrain);
+    const prepared = yield* route.prepareTransport(native, request, options);
+    yield* route.streamPrepared(prepared, request, { http: executor }, options).pipe(Stream.runDrain);
     if (!result)
         return yield* ProviderShared.eventError(source.id, "Compaction response ended without a checkpoint");
     return result;

package/dist/protocols/utils/responses-compaction.d.ts

@@ -1,4 +1,6 @@
+import { Effect } from "effect";
+import { AIError, LLMRequest } from "../../schema/index.js";
 import type { CompactOperation } from "../../route/client.js";
 import { OpenResponses } from "../open-responses.js";
-export declare const make: (adapter: OpenResponses.ProviderAdapter) => CompactOperation;
+export declare const make: (adapter: OpenResponses.ProviderAdapter, lowerTools: (request: LLMRequest) => Effect.Effect<ReadonlyArray<Record<string, unknown>>, AIError>) => CompactOperation;
 export * as ResponsesCompaction from "./responses-compaction.js";

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

@@ -7,12 +7,18 @@ 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";
+// /compact has a smaller wire contract than /responses; keep the request controls it accepts.
 const Body = Schema.Struct({
     model: Schema.String,
     input: Schema.Array(Schema.Unknown),
     instructions: optionalNull(Schema.String),
     previous_response_id: optionalNull(Schema.String),
     service_tier: optionalNull(Schema.String),
+    reasoning: Schema.optional(JsonObject),
+    text: Schema.optional(JsonObject),
+    include: OpenResponses.coreFields.include,
+    parallel_tool_calls: OpenResponses.coreFields.parallel_tool_calls,
+    tools: Schema.optional(Schema.Array(JsonObject)),
     prompt_cache_key: optionalNull(Schema.String),
     prompt_cache_retention: optionalNull(Schema.String),
     prompt_cache_options: optionalNull(Schema.Struct({ mode: Schema.optional(Schema.String), ttl: Schema.optional(Schema.String) })),
@@ -54,14 +60,21 @@ const Response = Schema.Struct({
     ])),
     usage: Schema.optional(Schema.StructWithRest(OpenResponses.OpenResponsesUsage, [JsonObject])),
 });
-export const make = (adapter) => Effect.fn("ResponsesCompaction.execute")(function* (request, executor, options) {
+export const make = (adapter, lowerTools) => Effect.fn("ResponsesCompaction.execute")(function* (request, executor, options) {
     const route = request.model.route;
     // The standalone compaction endpoint rejects histories containing configuration updates.
     const native = yield* OpenResponses.lowerConversation(stripEffortUpdates(request), adapter);
+    const generation = OpenResponses.lowerGeneration(request);
+    const tools = request.tools.length === 0 ? undefined : yield* lowerTools(request);
     const body = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))(mergeJsonRecords({
         ...native,
-        service_tier: request.providerOptions?.serviceTier,
-        prompt_cache_key: ProviderShared.promptCacheKey(request),
+        service_tier: generation.service_tier,
+        reasoning: generation.reasoning,
+        text: generation.text,
+        include: generation.include,
+        parallel_tool_calls: generation.parallel_tool_calls,
+        tools,
+        prompt_cache_key: generation.prompt_cache_key,
     }, request.http?.body));
     const url = Endpoint.render(route.endpoint, { request, body: native });
     url.pathname = `${url.pathname.replace(/\/$/, "")}/compact`;

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.d.ts

@@ -1,8 +1,8 @@
-import type { JsonSchema, LanguageModel, LanguageModelSanitizerCompatibility } from "../../schema/index.js";
+import { type JsonSchema, type LanguageModel, type LLMRequest } from "../../schema/index.js";
 export declare const ToolSchemaProjection: {
     readonly gemini: (schema: JsonSchema) => JsonSchema;
-    readonly modelCompatibility: (schema: JsonSchema, model: LanguageModel, protocolDefault?: LanguageModelSanitizerCompatibility) => JsonSchema;
     readonly moonshot: (schema: JsonSchema) => JsonSchema;
     readonly openAI: (schema: JsonSchema) => JsonSchema;
     readonly responses: (schema: JsonSchema) => JsonSchema;
+    readonly tools: (entries: LLMRequest["tools"], model: LanguageModel) => LLMRequest["tools"];
 };

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

@@ -1,3 +1,4 @@
+import { ToolDefinition } from "../../schema/index.js";
 import { isRecord } from "../../utils/record.js";
 import { GeminiJsonSchema } from "./gemini-json-schema.js";
 const tupleItemsSchema = (items) => {
@@ -54,24 +55,43 @@ 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.
-const modelCompatibility = (schema, model, protocolDefault) => {
-    switch (model.compatibility?.sanitizer ?? protocolDefault ?? MODEL_NAMES.find(([name]) => name.test(model.id))?.[1]) {
+// 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) => {
+    const root = objectRoot(schema);
+    switch (model.compatibility?.sanitizer ??
+        model.route.sanitizer ??
+        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;
     }
 };
+// Applied once to every request before any protocol builds its body, including tools in namespaces.
+const tools = (entries, model) => entries.map((tool) => tool.type === "tool"
+    ? new ToolDefinition({ ...tool, inputSchema: modelCompatibility(tool.inputSchema, model) })
+    : { ...tool, tools: tools(tool.tools, model) });
 export const ToolSchemaProjection = {
     gemini,
-    modelCompatibility,
     moonshot,
     openAI,
     responses,
+    tools,
 };

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,25 +48,20 @@ 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.
+    // xAI reports a USD cost (`cost_in_usd_ticks`) rather than tokens, seconds, or credits; the raw record stays in
+    // provider metadata.
     return new ImageResponse({
         images,
         providerMetadata: usage === undefined ? undefined : { xai: { usage } },
@@ -77,20 +70,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,

package/dist/protocols/xai-responses.js

@@ -77,5 +77,5 @@ export const protocol = Protocol.make({
         terminal: OpenResponses.terminal,
     },
 });
-export const compact = ResponsesCompaction.make(adapter);
+export const compact = ResponsesCompaction.make(adapter, (request) => OpenResponses.lowerTools(ProviderShared.flattenTools(request.tools), adapter));
 export * as XAIResponses from "./xai-responses.js";