@opencode/ai 0.0.0-dev-20138 → 0.0.0-dev-20141

package/dist/protocols/anthropic-messages.js

@@ -14,7 +14,6 @@ import { classifyProviderFailure } from "../provider-error.js";
 import { effortUpdate, resolveEffortUpdates } from "../effort-updates.js";
 import * as Cache from "./utils/cache.js";
 import { Lifecycle } from "./utils/lifecycle.js";
-import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { ToolStream } from "./utils/tool-stream.js";
 const ADAPTER = "anthropic-messages";
 export const DEFAULT_BASE_URL = "https://api.anthropic.com/v1";
@@ -408,10 +407,10 @@ const redactedDataFromMetadata = (metadata, key) => {
         return undefined;
     return typeof provider.redactedData === "string" ? provider.redactedData : undefined;
 };
-const lowerTool = (breakpoints, tool, inputSchema) => ({
+const lowerTool = (breakpoints, tool) => ({
     name: tool.name,
     description: tool.description,
-    input_schema: inputSchema,
+    input_schema: tool.inputSchema,
     cache_control: cacheControl(breakpoints, tool.cache),
 });
 const lowerToolChoice = (toolChoice) => ProviderShared.matchToolChoice("Anthropic Messages", toolChoice, {
@@ -910,9 +909,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
     // over-mark we keep their tool hints and shed the message-tail ones first.
     const breakpoints = Cache.newBreakpoints(ANTHROPIC_BREAKPOINT_CAP);
     const flattened = ProviderShared.flattenToolRequest(updates.request);
-    const tools = flattened.tools.length === 0
-        ? undefined
-        : flattened.tools.map((tool) => lowerTool(breakpoints, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model)));
+    const tools = flattened.tools.length === 0 ? undefined : flattened.tools.map((tool) => lowerTool(breakpoints, tool));
     // Anthropic rejects tool_choice when tools are absent; "none" is only meaningful with tools present.
     const toolChoice = tools === undefined || !request.toolChoice ? undefined : yield* lowerToolChoice(request.toolChoice);
     const systemParts = request.system.filter((part) => part.text.length > 0);

package/dist/protocols/bedrock-converse.js

@@ -11,7 +11,6 @@ import { BedrockCache } from "./utils/bedrock-cache.js";
 import { BedrockMedia } from "./utils/bedrock-media.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { MistralToolID } from "./utils/mistral-tool-id.js";
-import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { ToolStream } from "./utils/tool-stream.js";
 import { concatBytes } from "../utils/bytes.js";
 const ADAPTER = "bedrock-converse";
@@ -156,17 +155,17 @@ const BedrockEvent = Schema.Struct({
 // =============================================================================
 // Request Lowering
 // =============================================================================
-const lowerToolSpec = (tool, inputSchema) => ({
+const lowerToolSpec = (tool) => ({
     toolSpec: {
         name: tool.name,
         ...(tool.description.trim().length > 0 ? { description: tool.description } : {}),
-        inputSchema: { json: inputSchema },
+        inputSchema: { json: tool.inputSchema },
     },
 });
-const lowerTools = (model, breakpoints, tools) => {
+const lowerTools = (breakpoints, tools) => {
     const result = [];
     for (const tool of tools) {
-        result.push(lowerToolSpec(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, model)));
+        result.push(lowerToolSpec(tool));
         const cachePoint = BedrockCache.block(breakpoints, tool.cache);
         if (cachePoint)
             result.push(cachePoint);
@@ -371,7 +370,7 @@ const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request)
         if (flattened.tools.length === 0)
             return undefined;
         return {
-            tools: lowerTools(request.model, breakpoints, flattened.tools),
+            tools: lowerTools(breakpoints, flattened.tools),
             // Converse has no native "none". Keep definitions stable for prompt
             // caching and omit only the unsupported choice.
             toolChoice,

package/dist/protocols/cartesia-speech.d.ts

@@ -23,6 +23,14 @@ interface State extends SpeechStream.Audio {
     readonly done: boolean;
 }
 export declare const protocol: MediaProtocol.Streamed<Request, {
+    readonly id: string;
+    readonly type: "generation-queued";
+    readonly position?: number | undefined;
+} | {
+    readonly id: string;
+    readonly type: "generation-progress";
+    readonly progress?: number | undefined;
+} | {
     readonly type: "audio-delta";
     readonly chunk: Uint8Array<ArrayBufferLike>;
 } | {
@@ -74,6 +82,14 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
 export declare const model: (input: MediaRoute.ModelInput) => SpeechModel<CartesiaSpeechOptions>;
 export declare const CartesiaSpeech: {
     readonly protocol: MediaProtocol.Streamed<Request, {
+        readonly id: string;
+        readonly type: "generation-queued";
+        readonly position?: number | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "generation-progress";
+        readonly progress?: number | undefined;
+    } | {
         readonly type: "audio-delta";
         readonly chunk: Uint8Array<ArrayBufferLike>;
     } | {

package/dist/protocols/deepgram-speech.d.ts

@@ -16,6 +16,14 @@ export type DeepgramSpeechOptions = {
 } & Record<string, unknown>;
 export type Request = SpeechRequestFor<DeepgramSpeechOptions>;
 export declare const protocol: MediaProtocol.Streamed<Request, {
+    readonly id: string;
+    readonly type: "generation-queued";
+    readonly position?: number | undefined;
+} | {
+    readonly id: string;
+    readonly type: "generation-progress";
+    readonly progress?: number | undefined;
+} | {
     readonly type: "audio-delta";
     readonly chunk: Uint8Array<ArrayBufferLike>;
 } | {
@@ -67,6 +75,14 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
 export declare const model: (input: MediaRoute.ModelInput) => SpeechModel<DeepgramSpeechOptions>;
 export declare const DeepgramSpeech: {
     readonly protocol: MediaProtocol.Streamed<Request, {
+        readonly id: string;
+        readonly type: "generation-queued";
+        readonly position?: number | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "generation-progress";
+        readonly progress?: number | undefined;
+    } | {
         readonly type: "audio-delta";
         readonly chunk: Uint8Array<ArrayBufferLike>;
     } | {

package/dist/protocols/elevenlabs-speech.d.ts

@@ -19,6 +19,14 @@ export type ElevenLabsSpeechOptions = {
 } & Record<string, unknown>;
 export type Request = SpeechRequestFor<ElevenLabsSpeechOptions>;
 export declare const protocol: MediaProtocol.Streamed<Request, {
+    readonly id: string;
+    readonly type: "generation-queued";
+    readonly position?: number | undefined;
+} | {
+    readonly id: string;
+    readonly type: "generation-progress";
+    readonly progress?: number | undefined;
+} | {
     readonly type: "audio-delta";
     readonly chunk: Uint8Array<ArrayBufferLike>;
 } | {
@@ -70,6 +78,14 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
 export declare const model: (input: MediaRoute.ModelInput) => SpeechModel<ElevenLabsSpeechOptions>;
 export declare const ElevenLabsSpeech: {
     readonly protocol: MediaProtocol.Streamed<Request, {
+        readonly id: string;
+        readonly type: "generation-queued";
+        readonly position?: number | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "generation-progress";
+        readonly progress?: number | undefined;
+    } | {
         readonly type: "audio-delta";
         readonly chunk: Uint8Array<ArrayBufferLike>;
     } | {

package/dist/protocols/gemini.js

@@ -11,7 +11,6 @@ import { Media } from "../media.js";
 import { JsonObject, knownString, lenient, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { GeminiGenerateContent } from "./utils/gemini-generate-content.js";
 import { Lifecycle } from "./utils/lifecycle.js";
-import { ToolSchemaProjection } from "./utils/tool-schema.js";
 const ADAPTER = "gemini";
 // Google documents this sentinel for replaying Gemini 3 function calls after their original signature was lost.
 const SKIP_THOUGHT_SIGNATURE_VALIDATOR = "skip_thought_signature_validator";
@@ -190,12 +189,11 @@ const GeminiEvent = Schema.Struct({
 // =============================================================================
 // Request Lowering
 // =============================================================================
-// Tool schemas go in `parametersJsonSchema`, which accepts standard JSON Schema. Gemini's schema
-// rules are this API's default, including for tuned endpoints whose IDs do not name Gemini.
-const lowerTool = (tool, model) => ({
+// Tool schemas go in `parametersJsonSchema`, which accepts standard JSON Schema.
+const lowerTool = (tool) => ({
     name: tool.name,
     description: tool.description,
-    parametersJsonSchema: ToolSchemaProjection.modelCompatibility(tool.inputSchema, model, "gemini"),
+    parametersJsonSchema: tool.inputSchema,
 });
 const lowerToolConfig = (toolChoice) => ProviderShared.matchToolChoice("Gemini", toolChoice, {
     auto: () => ({ functionCallingConfig: { mode: "AUTO" } }),
@@ -388,7 +386,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request) {
         tools: hasTools
             ? [
                 {
-                    functionDeclarations: flattened.tools.map((tool) => lowerTool(tool, request.model)),
+                    functionDeclarations: flattened.tools.map(lowerTool),
                 },
             ]
             : undefined,
@@ -654,6 +652,8 @@ export const protocol = Protocol.make({
         schema: GeminiBody,
         from: fromRequest,
     },
+    // Gemini's schema rules are this API's default, including for tuned endpoints whose IDs do not name Gemini.
+    sanitizer: "gemini",
     stream: {
         event: Protocol.jsonEvent(GeminiEvent),
         initial: (request) => ({

package/dist/protocols/google-speech.d.ts

@@ -26,6 +26,14 @@ interface State extends SpeechStream.Audio, GeminiGenerateContent.Metadata {
     readonly mimeType?: string;
 }
 export declare const protocol: MediaProtocol.Streamed<Request, {
+    readonly id: string;
+    readonly type: "generation-queued";
+    readonly position?: number | undefined;
+} | {
+    readonly id: string;
+    readonly type: "generation-progress";
+    readonly progress?: number | undefined;
+} | {
     readonly type: "audio-delta";
     readonly chunk: Uint8Array<ArrayBufferLike>;
 } | {
@@ -77,6 +85,14 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
 export declare const model: (input: MediaRoute.ModelInput) => SpeechModel<GoogleSpeechOptions>;
 export declare const GoogleSpeech: {
     readonly protocol: MediaProtocol.Streamed<Request, {
+        readonly id: string;
+        readonly type: "generation-queued";
+        readonly position?: number | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "generation-progress";
+        readonly progress?: number | undefined;
+    } | {
         readonly type: "audio-delta";
         readonly chunk: Uint8Array<ArrayBufferLike>;
     } | {

package/dist/protocols/meta-responses.js

@@ -5,7 +5,6 @@ import { LLMEvent, LLMRequest, Message, ToolResultPart } from "../schema/index.j
 import { OpenResponses } from "./open-responses.js";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js";
-import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { detectMediaType } from "../utils/media-type.js";
 const ADAPTER = "meta-responses";
 const NAME = "Meta Responses";
@@ -82,7 +81,7 @@ const fromRequest = Effect.fn("MetaResponses.fromRequest")(function* (request) {
             ? undefined
             : yield* Effect.forEach(projected.tools, (tool) => Effect.gen(function* () {
                 if (tool.native === undefined)
-                    return yield* OpenResponses.lowerTool(NAME, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model));
+                    return yield* OpenResponses.lowerTool(NAME, tool);
                 return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(NativeTool))(tool.native.meta);
             })),
         tool_choice: OpenResponses.allowedToolChoice(request) ??

package/dist/protocols/mistral-chat.js

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

package/dist/protocols/open-responses.d.ts

@@ -716,9 +716,7 @@ interface ReasoningStreamItem {
     readonly summaryParts: Readonly<Record<number, ReasoningSummaryStatus>>;
     readonly deltaIndexes: ReadonlySet<number>;
 }
-export declare const lowerTool: (protocolName: string, tool: ToolDefinition, inputSchema: {
-    readonly [x: string]: unknown;
-}) => Effect.Effect<{
+export declare const lowerTool: (protocolName: string, tool: ToolDefinition) => Effect.Effect<{
     type: "function";
     name: string;
     description: string;

package/dist/protocols/open-responses.js

@@ -7,7 +7,6 @@ import { classifyProviderFailure } from "../provider-error.js";
 import { effortUpdate } from "../effort-updates.js";
 import { OpenResponsesOptions } from "./utils/open-responses-options.js";
 import { Lifecycle } from "./utils/lifecycle.js";
-import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { ToolStream } from "./utils/tool-stream.js";
 const ADAPTER = "open-responses";
 const NAME = "Open Responses";
@@ -281,14 +280,14 @@ const BASE_ADAPTER = { id: ADAPTER, name: NAME };
 // =============================================================================
 // Request Lowering
 // =============================================================================
-export const lowerTool = Effect.fn("OpenResponses.lowerTool")(function* (protocolName, tool, inputSchema) {
+export const lowerTool = Effect.fn("OpenResponses.lowerTool")(function* (protocolName, tool) {
     if (tool.native !== undefined)
         return yield* ProviderShared.invalidRequest(`${protocolName} does not support provider-native tool ${tool.name}`);
     return {
         type: "function",
         name: tool.name,
         description: tool.description,
-        parameters: inputSchema,
+        parameters: tool.inputSchema,
         // The common tool definition does not currently express Responses strict-schema policy.
         strict: false,
     };
@@ -610,7 +609,7 @@ export const fromRequestWithAdapter = Effect.fn("OpenResponses.fromRequestWithAd
             ? undefined
             : yield* Effect.forEach(projected.tools, (tool) => tool.native !== undefined && adapter.nativeTool
                 ? adapter.nativeTool(tool.native)
-                : lowerTool(adapter.name, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model))),
+                : lowerTool(adapter.name, tool)),
         tool_choice: allowedToolChoice(request) ??
             (request.toolChoice ? yield* lowerToolChoice(adapter.name, request.toolChoice) : undefined),
     };

package/dist/protocols/openai-chat.js

@@ -11,7 +11,6 @@ import { classifyProviderFailure } from "../provider-error.js";
 import { isRecord, JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { OpenAIOptions } from "./utils/openai-options.js";
 import { Lifecycle } from "./utils/lifecycle.js";
-import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { ToolStream } from "./utils/tool-stream.js";
 const ADAPTER = "openai-chat";
 const RESERVED_REASONING_FIELDS = new Set(["role", "content", "refusal", "tool_calls"]);
@@ -209,12 +208,12 @@ export const OpenAIChatEvent = Schema.StructWithRest(Schema.Struct({
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
 const DONE = "[DONE]";
 const OpenAIChatStreamEvent = Schema.Union([Schema.Literal(DONE), Protocol.jsonEvent(OpenAIChatEvent)]);
-const lowerTool = (tool, inputSchema, options, supportsStrictMode) => ({
+const lowerTool = (tool, options, supportsStrictMode) => ({
     type: "function",
     function: {
         name: tool.name,
         description: tool.description,
-        parameters: inputSchema,
+        parameters: tool.inputSchema,
         ...(supportsStrictMode ? { strict: false } : {}),
     },
     cache_control: options.cacheControl?.(tool.cache),
@@ -649,7 +648,7 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (reques
             ? hasHistory
                 ? []
                 : undefined
-            : flattened.tools.map((tool) => lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model), options, supportsStrictMode)),
+            : flattened.tools.map((tool) => lowerTool(tool, options, supportsStrictMode)),
         tool_choice: hasActiveTools && request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined,
         stream: true,
         ...(supportsUsageInStreaming ? { stream_options: { include_usage: true } } : {}),

package/dist/protocols/openai-responses.js

@@ -5,13 +5,12 @@ import { Auth } from "../route/auth.js";
 import { Endpoint } from "../route/endpoint.js";
 import { Protocol } from "../route/protocol.js";
 import { HttpTransport } from "../route/transport/index.js";
-import { LLMRequest, mergeJsonRecords, } from "../schema/index.js";
+import { LLMRequest, mergeJsonRecords } from "../schema/index.js";
 import { resolveEffortUpdates } from "../effort-updates.js";
 import { OpenResponses } from "./open-responses.js";
 import { OpenResponsesOptions } from "./utils/open-responses-options.js";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js";
-import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { OpenResponsesChannel } from "./open-responses-channel.js";
 import { ResponsesCompaction } from "./utils/responses-compaction.js";
 import { ResponsesCheckpoint } from "./utils/responses-checkpoint.js";
@@ -132,27 +131,27 @@ const nativeImageTool = (tool) => {
     const native = nativeImageToolInput(tool);
     return Schema.is(OpenAIResponsesImageGenerationTool)(native) ? native : undefined;
 };
-const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool, inputSchema) {
+const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool) {
     const native = nativeImageToolInput(tool);
     if (native !== undefined) {
         if (Schema.is(OpenAIResponsesImageGenerationTool)(native))
             return native;
         return yield* ProviderShared.invalidRequest("OpenAI Responses image generation tool options are invalid");
     }
-    return yield* OpenResponses.lowerTool(NAME, tool, inputSchema);
+    return yield* OpenResponses.lowerTool(NAME, tool);
 });
 // Native namespaces hold only function tools, so deeper levels flatten into
 // the leaf names the same way non-native protocols flatten the whole tree.
-const lowerToolEntry = Effect.fn("OpenAIResponses.lowerToolEntry")(function* (tool, model) {
+const lowerToolEntry = Effect.fn("OpenAIResponses.lowerToolEntry")(function* (tool) {
     if (tool.type === "tool")
-        return yield* lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, model));
+        return yield* lowerTool(tool);
     // OpenAI requires a namespace description; fall back to a generic one so a
     // missing description never blocks the request.
     return {
         type: "namespace",
         name: tool.name,
         description: tool.description ?? `Tools in the ${tool.name} namespace.`,
-        tools: yield* Effect.forEach(ProviderShared.flattenTools(tool.tools), (leaf) => OpenResponses.lowerTool(NAME, leaf, ToolSchemaProjection.modelCompatibility(leaf.inputSchema, model))),
+        tools: yield* Effect.forEach(ProviderShared.flattenTools(tool.tools), (leaf) => OpenResponses.lowerTool(NAME, leaf)),
     };
 });
 const lowerToolChoice = (toolChoice, tools) => ProviderShared.matchToolChoice(NAME, toolChoice, {
@@ -172,9 +171,7 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request)
         ...(yield* OpenResponses.lowerConversation(updates.request, adapter)),
         ...OpenResponses.lowerGeneration(request, { ...options, reasoningEffort: updates.effort }),
         context_management: management?.map((edit) => ({ type: edit.type, compact_threshold: edit.compactThreshold })),
-        tools: request.tools.length === 0
-            ? undefined
-            : yield* Effect.forEach(request.tools, (tool) => lowerToolEntry(tool, request.model)),
+        tools: request.tools.length === 0 ? undefined : yield* Effect.forEach(request.tools, lowerToolEntry),
         tool_choice: request.tools.length === 0
             ? undefined
             : (OpenResponses.allowedToolChoice(request) ??

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

@@ -16,6 +16,14 @@ interface State extends SpeechStream.Audio {
     readonly usage?: MediaUsage;
 }
 export declare const protocol: MediaProtocol.Streamed<Request, {
+    readonly id: string;
+    readonly type: "generation-queued";
+    readonly position?: number | undefined;
+} | {
+    readonly id: string;
+    readonly type: "generation-progress";
+    readonly progress?: number | undefined;
+} | {
     readonly type: "audio-delta";
     readonly chunk: Uint8Array<ArrayBufferLike>;
 } | {
@@ -67,6 +75,14 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
 export declare const model: (input: MediaRoute.ModelInput) => SpeechModel<OpenAISpeechOptions>;
 export declare const OpenAISpeech: {
     readonly protocol: MediaProtocol.Streamed<Request, {
+        readonly id: string;
+        readonly type: "generation-queued";
+        readonly position?: number | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "generation-progress";
+        readonly progress?: number | undefined;
+    } | {
         readonly type: "audio-delta";
         readonly chunk: Uint8Array<ArrayBufferLike>;
     } | {

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) => {
@@ -69,9 +70,11 @@ const objectRoot = (schema) => {
 // 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 modelCompatibility = (schema, model) => {
     const root = objectRoot(schema);
-    switch (model.compatibility?.sanitizer ?? protocolDefault ?? MODEL_NAMES.find(([name]) => name.test(model.id))?.[1]) {
+    switch (model.compatibility?.sanitizer ??
+        model.route.sanitizer ??
+        MODEL_NAMES.find(([name]) => name.test(model.id))?.[1]) {
         case "gemini":
             return gemini(root);
         case "moonshot":
@@ -81,10 +84,14 @@ const modelCompatibility = (schema, model, protocolDefault) => {
             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/route/client.d.ts

@@ -6,7 +6,7 @@ import { Framing } from "./framing.js";
 import { HttpTransport } from "./transport/index.js";
 import type { HttpMiddleware, Transport, TransportRuntime, WebSocketChannelExecutor } from "./transport/index.js";
 import type { Protocol } from "./protocol.js";
-import type { ProtocolID, ProviderOptions } from "../schema/index.js";
+import type { LanguageModelSanitizerCompatibility, ProtocolID, ProviderOptions } from "../schema/index.js";
 import { AIError, CompactionResponse, CompactionCheckpointResponse, GenerationOptions, HttpOptions, LLMRequest, LLMResponse, LanguageModel, LLMEvent, ProviderID } from "../schema/index.js";
 export interface RouteBody<Body> {
     /** Schema for the validated provider-native body sent as the JSON request. */
@@ -31,6 +31,7 @@ export interface Route<Body, Prepared = unknown, Compact extends CompactionOpera
     readonly defaults: RouteDefaults;
     readonly body: RouteBody<Body>;
     readonly supportsEffortUpdates?: (request: LLMRequest) => boolean;
+    readonly sanitizer?: LanguageModelSanitizerCompatibility;
     readonly with: {
         <Next extends CompactionOperations | undefined>(patch: RoutePatch<Body, Prepared> & {
             readonly compact: Next;

package/dist/route/client.js

@@ -9,6 +9,7 @@ import { applyEffortUpdates } from "../effort-updates.js";
 import { normalizeToolHistory } from "../tool-history.js";
 import { sanitizeSurrogates } from "../utils/sanitize.js";
 import * as ProviderShared from "../protocols/shared.js";
+import { ToolSchemaProjection } from "../protocols/utils/tool-schema.js";
 import { AIError, CompactionResponse, CompactionCheckpointResponse, AIErrorReason, GenerationOptions, HttpOptions, LLMRequest, LLMResponse, LanguageModel, LLMEvent, InvalidProviderOutputError, ProviderConfigurationError, ProviderID, mergeGenerationOptions, mergeHttpOptions, mergeProviderOptions, } from "../schema/index.js";
 const makeRouteLanguageModel = (route, mapped) => {
     const provider = route.provider ?? ("provider" in mapped ? mapped.provider : undefined);
@@ -118,6 +119,7 @@ function makeFromTransport(input) {
             defaults: routeInput.defaults ?? {},
             body: protocol.body,
             supportsEffortUpdates: protocol.supportsEffortUpdates,
+            sanitizer: protocol.sanitizer,
             with: (patch) => {
                 const { compact, id, provider, providerMetadataKey, auth, transport, endpoint, ...defaults } = patch;
                 return build({
@@ -210,7 +212,7 @@ const prepareRequest = (request) => {
     const sanitized = LLMRequest.update(original, sanitizeSurrogates({ ...LLMRequest.input(original), model: undefined }));
     // Deduplicate per sibling level; a tool and a namespace may share a name.
     const dedupe = (tools) => [...new Map(tools.map((tool) => [`${tool.type}:${tool.name}`, tool])).values()].map((tool) => tool.type === "tool" ? tool : { ...tool, tools: dedupe(tool.tools) });
-    const resolved = applyCachePolicy(applyEffortUpdates(LLMRequest.update(sanitized, { tools: dedupe(sanitized.tools) })));
+    const resolved = applyCachePolicy(applyEffortUpdates(LLMRequest.update(sanitized, { tools: ToolSchemaProjection.tools(dedupe(sanitized.tools), sanitized.model) })));
     const headers = resolved.model.route.headers?.({ request: resolved });
     return headers === undefined
         ? resolved

package/dist/route/media.d.ts

@@ -3,7 +3,7 @@ import { Auth } from "./auth.js";
 import { Endpoint } from "./endpoint.js";
 import { type Interface } from "./executor-service.js";
 import { MediaProtocol } from "./media-protocol.js";
-import { Generation, type AwaitOptions, type Observation } from "../generation.js";
+import { Generation } from "../generation.js";
 import { AIError, HttpOptions, ProviderID } from "../schema/index.js";
 export type Execute = Interface["execute"];
 /** The minimum a media request must carry for the route to build a transport request. */
@@ -30,7 +30,7 @@ export declare const deployment: (input: {
     readonly http?: HttpOptions.Input;
 }, auth: Auth.Definition) => Omit<ModelInput, "id">;
 /** One request, one response. */
-export interface Route<Request extends MediaRequest, Response> {
+export interface InlineRoute<Request extends MediaRequest, Response> {
     readonly kind: "inline";
     readonly id: string;
     readonly provider: ProviderID;
@@ -56,7 +56,7 @@ export interface StreamRoute<Request extends MediaRequest, Event, Response> {
     readonly stream: (request: Request, execute: Execute) => Stream.Stream<Event, AIError>;
     readonly generate: (request: Request, execute: Execute) => Effect.Effect<Response, AIError>;
 }
-export type AnyRoute<Request extends MediaRequest, Event, Response> = Route<Request, Response> | StreamRoute<Request, Event, Response> | QueuedRoute<Request, Response>;
+export type AnyRoute<Request extends MediaRequest, Event, Response> = InlineRoute<Request, Response> | StreamRoute<Request, Event, Response> | QueuedRoute<Request, Response>;
 export interface Composition<Request extends MediaRequest> {
     readonly endpoint: Endpoint.Definition<MediaProtocol.Body, Request>;
     readonly auth: Auth.Definition;
@@ -79,7 +79,7 @@ export interface StreamInput<Request extends MediaRequest, Event, Response, Fram
  * rejection, URL and query rendering, auth headers, JSON, multipart, or binary encoding, and handing responses back
  * to the protocol.
  */
-export declare const inline: <Request extends MediaRequest, Response>(input: InlineInput<Request, Response>) => Route<Request, Response>;
+export declare const inline: <Request extends MediaRequest, Response>(input: InlineInput<Request, Response>) => InlineRoute<Request, Response>;
 /**
  * Compose a queued media protocol the same way, adding `start`/`resume` handles whose polls reuse the route's auth,
  * deployment headers, and (for `start`) the request's `http` overlay. The token is decoded once at the boundary and
@@ -88,14 +88,4 @@ export declare const inline: <Request extends MediaRequest, Response>(input: Inl
 export declare const queued: <Request extends MediaRequest, Response, Token>(input: QueuedInput<Request, Response, Token>) => QueuedRoute<Request, Response>;
 /** Compose a streaming media protocol; `generate` runs the same stream in `generate` mode and folds it with `collect`. */
 export declare const stream: <Request extends MediaRequest, Event, Response, Frame, State>(input: StreamInput<Request, Event, Response, Frame, State>) => StreamRoute<Request, Event, Response>;
-export declare const dispatch: <Event, Response>(input: {
-    readonly modality: string;
-    readonly execute: Execute;
-    readonly responseEvents: (response: Response) => ReadonlyArray<Event>;
-}) => {
-    start: <Request extends MediaRequest>(route: AnyRoute<Request, Event, Response>, request: Request) => Effect.Effect<Generation<Response>, AIError, never>;
-    resume: <Request extends MediaRequest>(route: AnyRoute<Request, Event, Response>, model: MediaRequest["model"], token: unknown) => Effect.Effect<Generation<Response>, AIError, never>;
-    generate: <Request extends MediaRequest>(route: AnyRoute<Request, Event, Response>, request: Request, options?: AwaitOptions) => Effect.Effect<Response, AIError, never>;
-    stream: <Request extends MediaRequest>(route: AnyRoute<Request, Event, Response>, request: Request, options?: AwaitOptions) => Stream.Stream<Event | Observation, AIError>;
-};
 export * as MediaRoute from "./media.js";