@opencode/ai 2.0.15 → 2.0.17

package/dist/protocols/utils/gemini-generate-content.js

@@ -0,0 +1,65 @@
+import { Effect, Schema } from "effect";
+import { Framing } from "../../route/framing.js";
+import { AIError, ContentPolicyError, ProviderID } from "../../schema/index.js";
+import { ProviderShared } from "../shared.js";
+import { MediaInput } from "./media-input.js";
+const PROVIDER = ProviderID.make("google");
+const UsageMetadata = Schema.Struct({
+    promptTokenCount: Schema.optional(Schema.Number),
+    candidatesTokenCount: Schema.optional(Schema.Number),
+    totalTokenCount: Schema.optional(Schema.Number),
+});
+export const chunk = (part) => Schema.Struct({
+    candidates: Schema.optional(Schema.Array(Schema.Struct({
+        content: Schema.optional(Schema.Struct({ parts: Schema.optional(Schema.Array(part)) })),
+        finishReason: Schema.optional(Schema.String),
+    }))),
+    promptFeedback: Schema.optional(Schema.Struct({
+        blockReason: Schema.optional(Schema.String),
+        blockReasonMessage: Schema.optional(Schema.String),
+    })),
+    usageMetadata: Schema.optional(UsageMetadata),
+    modelVersion: Schema.optional(Schema.String),
+    responseId: Schema.optional(Schema.String),
+});
+export const track = (state, chunk) => ({
+    ...state,
+    usage: chunk.usageMetadata ?? state.usage,
+    finishReason: chunk.candidates?.[0]?.finishReason ?? state.finishReason,
+    modelVersion: chunk.modelVersion ?? state.modelVersion,
+    responseId: chunk.responseId ?? state.responseId,
+});
+export const blocked = (name, chunk, frame) => {
+    const feedback = chunk.promptFeedback;
+    if (feedback?.blockReason === undefined)
+        return undefined;
+    return new AIError({
+        reason: new ContentPolicyError({
+            message: `${name} blocked the request (${feedback.blockReason})${feedback.blockReasonMessage === undefined ? "" : `: ${feedback.blockReasonMessage}`}`,
+            body: frame,
+        }),
+    });
+};
+export const usage = (usage) => usage === undefined
+    ? undefined
+    : {
+        type: "tokens",
+        input: usage.promptTokenCount,
+        output: usage.candidatesTokenCount,
+        total: ProviderShared.totalTokens(usage.promptTokenCount, usage.candidatesTokenCount, usage.totalTokenCount),
+        details: { google: usage },
+    };
+export const providerMetadata = (state) => ({
+    google: { finishReason: state.finishReason, modelVersion: state.modelVersion, responseId: state.responseId },
+});
+export const path = (model, mode) => mode === "stream" ? `/models/${model}:streamGenerateContent?alt=sse` : `/models/${model}:generateContent`;
+// `generateContent` answers with one document shaped exactly like a streamed chunk, so it is a single frame.
+export const frames = (bytes, mode) => mode === "stream" ? Framing.sse.frame(bytes) : Framing.document.frame(bytes);
+// Gemini does not fetch public URLs; inline payloads and Gemini Files references are the accepted inputs.
+export const mediaPart = (route, asset) => {
+    const fileUri = MediaInput.refID(asset, PROVIDER);
+    if (fileUri !== undefined)
+        return Effect.succeed({ fileData: { mimeType: asset.mediaType, fileUri } });
+    return ProviderShared.requireInlineMedia(route, asset).pipe(Effect.map((media) => ({ inlineData: { mimeType: media.mime, data: media.base64 } })));
+};
+export * as GeminiGenerateContent from "./gemini-generate-content.js";

package/dist/protocols/utils/gemini-json-schema.d.ts

@@ -0,0 +1,3 @@
+import type { JsonSchema } from "../../schema/index.js";
+export declare const normalize: (schema: JsonSchema) => JsonSchema;
+export * as GeminiJsonSchema from "./gemini-json-schema.js";

package/dist/protocols/utils/gemini-json-schema.js

@@ -0,0 +1,76 @@
+import { isRecord } from "../../utils/record.js";
+// Gemini's `parametersJsonSchema` accepts standard JSON Schema, but rejects a few shapes that
+// published tool schemas commonly contain. Rewrite only those and send everything else unchanged.
+const SCHEMA_MAPS = new Set([
+    "properties",
+    "patternProperties",
+    "$defs",
+    "definitions",
+    "dependentSchemas",
+    "dependencies",
+]);
+const VALUES = new Set(["const", "default", "enum", "examples", "dependentRequired"]);
+const mapValues = (record, map) => Object.fromEntries(Object.entries(record).map(([key, value]) => [key, map(value, key)]));
+const normalizeNode = (schema) => {
+    if (Array.isArray(schema))
+        return schema.map(normalizeNode);
+    if (!isRecord(schema))
+        return schema;
+    const properties = isRecord(schema.properties) ? schema.properties : undefined;
+    return Object.fromEntries(Object.entries(schema).flatMap(([key, value]) => {
+        if (VALUES.has(key))
+            return [[key, value]];
+        if (SCHEMA_MAPS.has(key) && isRecord(value))
+            return [[key, mapValues(value, normalizeNode)]];
+        // `required` may only name declared properties.
+        if (key === "required" && properties && Array.isArray(value))
+            return [[key, value.filter((name) => typeof name === "string" && Object.hasOwn(properties, name))]];
+        // Draft-04 boolean exclusive bounds become the numeric form.
+        if (key === "exclusiveMinimum" && typeof value === "boolean")
+            return value && typeof schema.minimum === "number" ? [[key, schema.minimum]] : [];
+        if (key === "exclusiveMaximum" && typeof value === "boolean")
+            return value && typeof schema.maximum === "number" ? [[key, schema.maximum]] : [];
+        if (key === "minimum" && schema.exclusiveMinimum === true)
+            return [];
+        if (key === "maximum" && schema.exclusiveMaximum === true)
+            return [];
+        // Draft-07 tuples (`items` array plus `additionalItems`) are `prefixItems` plus `items` in 2020-12.
+        if (key === "items" && Array.isArray(value))
+            return [["prefixItems", value.map(normalizeNode)]];
+        if (key === "additionalItems" && Array.isArray(schema.items))
+            return [["items", normalizeNode(value)]];
+        return [[key, normalizeNode(value)]];
+    }));
+};
+// Gemini accepts a recursive `$ref` only when the loop passes through an optional property or
+// potentially empty array `items`. Replace other self-references with an unconstrained schema.
+const cutLoops = (schema, target, safe) => {
+    if (Array.isArray(schema))
+        return schema.map((item) => cutLoops(item, target, safe));
+    if (!isRecord(schema))
+        return schema;
+    if (schema.$ref === target && !safe)
+        return {};
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    return mapValues(schema, (value, key) => {
+        if (VALUES.has(key))
+            return value;
+        if (key === "items")
+            return cutLoops(value, target, safe || !(Number(schema.minItems) > 0));
+        if (key === "properties" && isRecord(value))
+            return mapValues(value, (child, name) => cutLoops(child, target, safe || !required.includes(name)));
+        if (SCHEMA_MAPS.has(key) && isRecord(value))
+            return mapValues(value, (child) => cutLoops(child, target, safe));
+        return cutLoops(value, target, safe);
+    });
+};
+export const normalize = (schema) => {
+    const normalized = normalizeNode(schema);
+    if (!isRecord(normalized))
+        return {};
+    const result = cutLoops(mapValues(normalized, (value, key) => (key === "$defs" || key === "definitions") && isRecord(value)
+        ? mapValues(value, (def, name) => cutLoops(def, `#/${key}/${name}`, false))
+        : value), "#", false);
+    return isRecord(result) ? result : {};
+};
+export * as GeminiJsonSchema from "./gemini-json-schema.js";

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

@@ -1,10 +1,32 @@
 import { Effect } from "effect";
 import { Media } from "../../media.js";
-import type { AIError, ProviderID } from "../../schema/index.js";
+import type { MediaProtocol } from "../../route/media-protocol.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`. */
+export declare const blob: (data: Uint8Array, mediaType: string) => Blob;
+export declare const query: (route: string, values: Record<string, unknown>) => Effect.Effect<MediaProtocol.Query, AIError>;
+export declare const dimensions: (size: string) => {
+    width: number;
+    height: number;
+};
 /** Provider file handle when the ref belongs to this provider; refs from other providers are never forwarded. */
 export declare const refID: (asset: Media.Asset, provider: ProviderID) => string | undefined;
 /** Decode a provider's base64 output once into an owned `bytes` asset, sniffing the type when it is not declared. */
 export declare const decodedAsset: (invalid: (message: string, cause?: unknown) => AIError, label: string, data: string, mediaType: string | undefined, options?: Media.AssetOptions) => Effect.Effect<Media.Asset, AIError, never>;
+/** 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) => {
@@ -10,8 +12,46 @@ export const inlineBytes = (route, asset) => {
         return Effect.fail(ProviderShared.inlineRequired(route, asset));
     return Effect.fromResult(Encoding.decodeBase64(inline.base64)).pipe(Effect.mapError((cause) => ProviderShared.invalidRequest(`${route} media contains invalid base64 data`, cause)));
 };
+/** Copied because `BlobPart` requires a plain `ArrayBuffer`. */
+export const blob = (data, mediaType) => {
+    const buffer = new ArrayBuffer(data.byteLength);
+    new Uint8Array(buffer).set(data);
+    return new Blob([buffer], { type: mediaType });
+};
+const isScalar = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+export const query = (route, values) => {
+    const entries = Object.entries(values).filter(([, value]) => value !== undefined);
+    const invalid = entries.find(([, value]) => !isScalar(value) && !(Array.isArray(value) && value.every(isScalar)));
+    if (invalid !== undefined)
+        return Effect.fail(ProviderShared.invalidRequest(`${route} cannot send "${invalid[0]}" as a query parameter`));
+    return Effect.succeed(Object.fromEntries(entries.map(([key, value]) => [key, Array.isArray(value) ? value.map(String) : String(value)])));
+};
+export const dimensions = (size) => {
+    const [width, height] = size.split("x").map(Number);
+    return { width, height };
+};
 /** Provider file handle when the ref belongs to this provider; refs from other providers are never forwarded. */
 export const refID = (asset, provider) => asset.source.type === "ref" && asset.source.provider === provider ? asset.source.id : undefined;
 /** Decode a provider's base64 output once into an owned `bytes` asset, sniffing the type when it is not declared. */
 export const decodedAsset = (invalid, label, data, mediaType, options) => Effect.fromResult(Encoding.decodeBase64(data)).pipe(Effect.mapError((cause) => invalid(`${label} contains invalid base64 data`, cause)), Effect.map((bytes) => Media.bytes(bytes, mediaType, options)));
+/** 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

@@ -0,0 +1,49 @@
+import { Effect } from "effect";
+import { Media } from "../../media.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`. */
+    readonly chunks: Array<Uint8Array>;
+}
+export type StepResult<State> = readonly [State, ReadonlyArray<SpeechEvent>];
+/** Empty chunks (keep-alive records) emit nothing. */
+export declare const delta: <State extends Audio>(state: State, chunk: Uint8Array) => StepResult<State>;
+export declare const step: <State extends Audio>(onRecord: (state: State, frame: string) => Effect.Effect<StepResult<State>, AIError>) => (state: State, frame: string | Uint8Array) => Effect.Effect<StepResult<State>, AIError, never>;
+export declare const timestamps: (texts: ReadonlyArray<string>, starts: ReadonlyArray<number>, ends: ReadonlyArray<number>) => ReadonlyArray<SpeechEvent>;
+export declare const voiceID: (voice: SpeechVoice | undefined) => string | undefined;
+export declare const container: (format: string, sampleRate?: number) => {
+    mediaType: string;
+    info: {
+        format: string;
+        sampleRate: number | undefined;
+    };
+};
+declare const PCM_MEDIA_TYPES: {
+    readonly pcm_s16le: "audio/pcm";
+    readonly pcm_f32le: "audio/pcm";
+    readonly pcm_mulaw: "audio/mulaw";
+    readonly pcm_alaw: "audio/alaw";
+};
+export type PcmEncoding = keyof typeof PCM_MEDIA_TYPES;
+export declare const pcm: (encoding: PcmEncoding, sampleRate: number | undefined, mediaType?: string) => {
+    mediaType: string;
+    info: {
+        format: string;
+        encoding: "pcm_s16le" | "pcm_f32le" | "pcm_mulaw" | "pcm_alaw";
+        sampleRate: number | undefined;
+        channels: number;
+    };
+};
+export declare const sampleRate: (mediaType: string | undefined) => number | undefined;
+/** A declared `mediaType` wins over sniffing: headerless PCM can start with bytes that look like an MPEG frame sync. */
+export declare const finish: (route: MediaProtocol.Identity, state: Audio, output: {
+    readonly mediaType: string | undefined;
+    readonly info?: Media.Info;
+    readonly usage?: MediaUsage;
+    readonly providerMetadata?: ProviderMetadata;
+    readonly detail?: string;
+}) => Effect.Effect<ReadonlyArray<SpeechEvent>, AIError>;
+export declare const headerUsage: (type: "characters" | "credits", value: string | undefined) => MediaUsage | undefined;
+export * as SpeechStream from "./speech-stream.js";

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

@@ -0,0 +1,64 @@
+import { Effect } from "effect";
+import { Media } from "../../media.js";
+import { SpeechAudioDeltaEvent, SpeechFinishEvent, SpeechTimestampsEvent, } from "../../speech.js";
+import { concatBytes } from "../../utils/bytes.js";
+/** Empty chunks (keep-alive records) emit nothing. */
+export const delta = (state, chunk) => {
+    if (chunk.length === 0)
+        return [state, []];
+    state.chunks.push(chunk);
+    return [state, [SpeechAudioDeltaEvent.make({ chunk })]];
+};
+export const step = (onRecord) => (state, frame) => typeof frame === "string" ? onRecord(state, frame) : Effect.succeed(delta(state, frame));
+export const timestamps = (texts, starts, ends) => texts.length === 0
+    ? []
+    : [
+        SpeechTimestampsEvent.make({
+            items: texts.map((text, index) => ({ text, startSeconds: starts[index] ?? 0, endSeconds: ends[index] ?? 0 })),
+        }),
+    ];
+export const voiceID = (voice) => (typeof voice === "object" ? voice.id : voice);
+const CONTAINER_MEDIA_TYPES = {
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    opus: "audio/ogg",
+    aac: "audio/aac",
+    flac: "audio/flac",
+};
+export const container = (format, sampleRate) => ({
+    mediaType: CONTAINER_MEDIA_TYPES[format],
+    info: { format, sampleRate },
+});
+const PCM_MEDIA_TYPES = {
+    pcm_s16le: "audio/pcm",
+    pcm_f32le: "audio/pcm",
+    pcm_mulaw: "audio/mulaw",
+    pcm_alaw: "audio/alaw",
+};
+export const pcm = (encoding, sampleRate, mediaType) => ({
+    mediaType: mediaType ?? PCM_MEDIA_TYPES[encoding],
+    info: { format: "pcm", encoding, sampleRate, channels: 1 },
+});
+export const sampleRate = (mediaType) => {
+    const rate = /rate=(\d+)/i.exec(mediaType ?? "")?.[1];
+    return rate === undefined ? undefined : Number(rate);
+};
+/** 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(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 }),
+            usage: output.usage,
+            providerMetadata: output.providerMetadata,
+        }),
+    ]);
+};
+export const headerUsage = (type, value) => {
+    const amount = Number(value);
+    if (!Number.isFinite(amount))
+        return undefined;
+    return type === "credits" ? { type, credits: amount } : { type, characters: amount };
+};
+export * as SpeechStream from "./speech-stream.js";

package/dist/protocols/utils/tool-schema.d.ts

@@ -1,8 +1,8 @@
-import type { JsonSchema, LanguageModelToolSchemaCompatibility } 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, compatibility: LanguageModelToolSchemaCompatibility | undefined) => 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,5 +1,6 @@
+import { ToolDefinition } from "../../schema/index.js";
 import { isRecord } from "../../utils/record.js";
-import { GeminiToolSchema } from "./gemini-tool-schema.js";
+import { GeminiJsonSchema } from "./gemini-json-schema.js";
 const tupleItemsSchema = (items) => {
     const projected = items.map(moonshotNode);
     if (projected.length === 0)
@@ -8,6 +9,17 @@ const tupleItemsSchema = (items) => {
         return projected[0];
     return { anyOf: projected };
 };
+// Moonshot rejects an `enum` without a sibling `type`. Its `type` may be one type, or one type plus "null".
+const enumType = (values) => {
+    const types = [
+        ...new Set(values.map((value) => (value === null ? "null" : Array.isArray(value) ? "array" : typeof value))),
+    ];
+    if (types.length === 1)
+        return types[0];
+    if (types.length === 2 && types.includes("null"))
+        return [...types.filter((type) => type !== "null"), "null"];
+    return undefined;
+};
 const moonshotNode = (schema) => {
     if (Array.isArray(schema))
         return schema.map(moonshotNode);
@@ -15,18 +27,22 @@ const moonshotNode = (schema) => {
         return schema;
     if (typeof schema.$ref === "string")
         return { $ref: schema.$ref };
-    return Object.fromEntries(Object.entries(schema).flatMap(([key, value]) => {
-        if (key === "items" && Array.isArray(value))
-            return [[key, tupleItemsSchema(value)]];
-        if (key === "prefixItems") {
-            if ("items" in schema)
+    const type = schema.type === undefined && Array.isArray(schema.enum) ? enumType(schema.enum) : undefined;
+    return Object.fromEntries([
+        ...(type === undefined ? [] : [["type", type]]),
+        ...Object.entries(schema).flatMap(([key, value]) => {
+            if (key === "items" && Array.isArray(value))
+                return [[key, tupleItemsSchema(value)]];
+            if (key === "prefixItems") {
+                if ("items" in schema)
+                    return [];
+                return [["items", tupleItemsSchema(Array.isArray(value) ? value : [])]];
+            }
+            if (key === "unevaluatedItems")
                 return [];
-            return [["items", tupleItemsSchema(Array.isArray(value) ? value : [])]];
-        }
-        if (key === "unevaluatedItems")
-            return [];
-        return [[key, moonshotNode(value)]];
-    }));
+            return [[key, moonshotNode(value)]];
+        }),
+    ]);
 };
 const moonshot = (schema) => {
     const projected = moonshotNode(schema);
@@ -34,21 +50,48 @@ const moonshot = (schema) => {
 };
 const openAI = (schema) => schema;
 const responses = openAI;
-const gemini = (schema) => GeminiToolSchema.convert(schema) ?? {};
-const modelCompatibility = (schema, compatibility) => {
-    if (compatibility === undefined)
+const gemini = GeminiJsonSchema.normalize;
+const MODEL_NAMES = [
+    [/gemini/i, "gemini"],
+    [/kimi/i, "moonshot"],
+];
+// 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;
-    switch (compatibility) {
+    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 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>;