@code-yeongyu/senpi 2026.7.23 → 2026.7.25-2

package/node_modules/@earendil-works/pi-ai/dist/api/openai-completions.js

@@ -2,16 +2,100 @@ import OpenAI from "openai";
 import { calculateCost, clampThinkingLevel, supportsXhigh } from "../models.js";
 import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
+import { shortHash } from "../utils/hash.js";
 import { headersToRecord } from "../utils/headers.js";
 import { parseStreamingJson } from "../utils/json-parse.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
+import { retryProviderRequest } from "../utils/provider-retry.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { isForcedToolChoiceUnsupportedError, omitToolChoiceParam } from "../utils/tool-choice-fallback.js";
 import { normalizeToolParametersForMoonshot, normalizeToolParametersForOpenAICompat, } from "../utils/tool-schema-compat.js";
+import { appendGrammarToolInputJsonDelta, createGrammarToolInputProperties, getGrammarToolInput, resolveGrammarConstrainedSampling, resolveJsonSchemaStrictSampling, } from "./constrained-sampling.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { applyExtraBody, buildBaseOptions, clampMaxForOpenAI, OPENAI_COMPLETIONS_RESERVED_BODY_KEYS, } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
+const KIMI_K3_THINKING_LEVEL_MAP = {
+    off: null,
+    minimal: null,
+    low: "low",
+    medium: null,
+    high: "high",
+    xhigh: null,
+    max: "max",
+};
+const DEEPSEEK_THINKING_LEVEL_MAP = {
+    minimal: "high",
+    low: "high",
+    medium: "high",
+    high: "high",
+    xhigh: "max",
+    max: "max",
+};
+const OPENROUTER_DEEPSEEK_THINKING_LEVEL_MAP = {
+    minimal: "high",
+    low: "high",
+    medium: "high",
+    high: "high",
+    xhigh: "high",
+    max: "high",
+};
+const MIMO_THINKING_LEVEL_MAP = {
+    minimal: "low",
+    low: "low",
+    medium: "medium",
+    high: "high",
+    xhigh: "high",
+    max: null,
+};
+const OLLAMA_THINKING_LEVEL_MAP = {
+    off: "none",
+    minimal: null,
+    low: "low",
+    medium: "medium",
+    high: "high",
+    xhigh: null,
+    max: "max",
+};
+function getThinkingLevelMap(model, compat) {
+    if (model.thinkingLevelMap !== undefined) {
+        return model.thinkingLevelMap;
+    }
+    const id = model.id.toLowerCase();
+    const isKimiK3 = id === "k3" || id.startsWith("k3-") || /(?:^|[/:-])kimi-k3(?:$|[/.:_-])/.test(id);
+    const isDeepSeek = id.includes("deepseek");
+    const isMiMo = /\bmimo\b/.test(id);
+    const isGlm52 = /(?:^|[/:-])glm-5\.2(?:$|[/.:_-])/.test(id);
+    if (model.provider === "ollama") {
+        return OLLAMA_THINKING_LEVEL_MAP;
+    }
+    if (isKimiK3) {
+        return KIMI_K3_THINKING_LEVEL_MAP;
+    }
+    if (compat.thinkingFormat === "openrouter" && isDeepSeek) {
+        return OPENROUTER_DEEPSEEK_THINKING_LEVEL_MAP;
+    }
+    if ((compat.thinkingFormat === "openai" || compat.thinkingFormat === "openrouter") && isMiMo) {
+        return MIMO_THINKING_LEVEL_MAP;
+    }
+    if (isDeepSeek) {
+        return DEEPSEEK_THINKING_LEVEL_MAP;
+    }
+    if (isGlm52) {
+        if (compat.thinkingFormat === "zai") {
+            return DEEPSEEK_THINKING_LEVEL_MAP;
+        }
+        if (compat.thinkingFormat === "openrouter") {
+            return { xhigh: "xhigh" };
+        }
+        return { max: "max" };
+    }
+    return undefined;
+}
+function resolveReasoningEffort(thinkingLevelMap, effort) {
+    const mapped = thinkingLevelMap?.[effort];
+    return mapped === undefined ? effort : typeof mapped === "string" ? mapped : undefined;
+}
 /**
  * Check if conversation messages contain tool calls or tool results.
  * This is needed because Anthropic (via proxy) requires the tools param
@@ -133,10 +217,11 @@ export const stream = (model, context, options) => {
         try {
             const apiKey = getClientApiKey(model.provider, options?.apiKey, options?.headers);
             const compat = getCompat(model);
+            const grammarToolInputProperties = createGrammarToolInputProperties(context.tools, compat.supportsOpenAIGrammarTools);
             const cacheRetention = resolveCacheRetention(options?.cacheRetention ?? model.cacheRetention, options?.env);
             const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
             const client = createClient(model, context, apiKey, options?.headers, cacheSessionId, compat);
-            let params = buildParams(model, context, options, compat, cacheRetention);
+            let params = buildParams(model, context, options, compat, cacheRetention, grammarToolInputProperties);
             const nextParams = await options?.onPayload?.(params, model);
             if (nextParams !== undefined) {
                 params = nextParams;
@@ -145,24 +230,27 @@ export const stream = (model, context, options) => {
             const requestOptions = {
                 ...(options?.signal ? { signal: options.signal } : {}),
                 ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
-                maxRetries: options?.maxRetries ?? 0,
+                maxRetries: 0,
             };
             const createChatCompletion = client.chat.completions.create.bind(client.chat.completions);
             const createStream = (body) => createChatCompletion(body, requestOptions).withResponse();
-            let completionResponse;
-            try {
-                completionResponse = await createStream(params);
-            }
-            catch (error) {
-                if (isForcedToolChoiceUnsupportedError(error, isForcedOpenAICompletionsToolChoice(params.tool_choice))) {
-                    params = omitToolChoiceParam(params);
-                    completionResponse = await createStream(params);
+            const createRequest = async () => {
+                try {
+                    return await createStream(params);
                 }
-                else {
+                catch (error) {
+                    if (isForcedToolChoiceUnsupportedError(error, isForcedOpenAICompletionsToolChoice(params.tool_choice))) {
+                        params = omitToolChoiceParam(params);
+                        return createStream(params);
+                    }
                     throw error;
                 }
-            }
-            const { data: openaiStream, response } = completionResponse;
+            };
+            const { data: openaiStream, response } = await retryProviderRequest(createRequest, {
+                maxRetries: options?.maxRetries,
+                maxRetryDelayMs: options?.maxRetryDelayMs,
+                signal: options?.signal,
+            });
             await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
             stream.push({ type: "start", partial: output });
             let textBlock = null;
@@ -173,6 +261,21 @@ export const stream = (model, context, options) => {
             const pendingReasoningDetailsByToolCallId = new Map();
             const blocks = output.content;
             const getContentIndex = (block) => blocks.indexOf(block);
+            const getCustomToolCallInput = (block) => {
+                const property = block.customInput?.property;
+                if (property === undefined)
+                    return "";
+                const value = block.arguments[property];
+                return typeof value === "string" ? value : "";
+            };
+            const appendCustomToolCallInput = (block, nextInput, close) => {
+                const customInput = block.customInput;
+                if (!customInput)
+                    return undefined;
+                const delta = appendGrammarToolInputJsonDelta(customInput.jsonBuffer, customInput.property, nextInput, close);
+                block.arguments = { [customInput.property]: nextInput };
+                return delta;
+            };
             const finishBlock = (block) => {
                 const contentIndex = getContentIndex(block);
                 if (contentIndex === -1) {
@@ -195,10 +298,24 @@ export const stream = (model, context, options) => {
                     });
                 }
                 else if (block.type === "toolCall") {
-                    block.arguments = parseStreamingJson(block.partialArgs);
+                    if (block.customInput) {
+                        const delta = appendCustomToolCallInput(block, getCustomToolCallInput(block), true);
+                        if (delta !== undefined) {
+                            stream.push({
+                                type: "toolcall_delta",
+                                contentIndex,
+                                delta,
+                                partial: output,
+                            });
+                        }
+                    }
+                    else {
+                        block.arguments = parseStreamingJson(block.partialArgs);
+                    }
                     // Finalize in-place and strip the scratch buffers so replay only
                     // carries parsed arguments.
                     delete block.partialArgs;
+                    delete block.customInput;
                     delete block.streamIndex;
                     stream.push({
                         type: "toolcall_end",
@@ -240,17 +357,27 @@ export const stream = (model, context, options) => {
             };
             const ensureToolCallBlock = (toolCall) => {
                 const streamIndex = typeof toolCall.index === "number" ? toolCall.index : undefined;
+                const name = toolCall.function?.name ?? toolCall.custom?.name ?? "";
                 let block = streamIndex !== undefined ? toolCallBlocksByIndex.get(streamIndex) : undefined;
                 if (!block && toolCall.id) {
                     block = toolCallBlocksById.get(toolCall.id);
                 }
                 if (!block) {
+                    // Note: the "input" fallback here should/must not be taken.  in case the LLM makes up
+                    // a tool we don't knwo about, we at least have a place to stash our stuff.
+                    const customInputProperty = toolCall.custom
+                        ? (grammarToolInputProperties.get(name) ?? "input")
+                        : undefined;
+                    const hasCustomInput = customInputProperty !== undefined;
                     block = {
                         type: "toolCall",
                         id: toolCall.id || "",
-                        name: toolCall.function?.name || "",
-                        arguments: {},
-                        partialArgs: "",
+                        name,
+                        arguments: hasCustomInput ? { [customInputProperty]: "" } : {},
+                        partialArgs: hasCustomInput ? undefined : "",
+                        customInput: hasCustomInput
+                            ? { property: customInputProperty, jsonBuffer: { input: "", started: false, closed: false } }
+                            : undefined,
                         streamIndex,
                     };
                     if (streamIndex !== undefined) {
@@ -273,6 +400,18 @@ export const stream = (model, context, options) => {
                 if (toolCall.id) {
                     toolCallBlocksById.set(toolCall.id, block);
                 }
+                if (!block.name && name) {
+                    block.name = name;
+                }
+                if (toolCall.custom && !block.customInput) {
+                    const customInputProperty = grammarToolInputProperties.get(block.name) ?? "input";
+                    block.arguments = { [customInputProperty]: "" };
+                    block.customInput = {
+                        property: customInputProperty,
+                        jsonBuffer: { input: "", started: false, closed: false },
+                    };
+                    delete block.partialArgs;
+                }
                 applyPendingReasoningDetail(block);
                 return block;
             };
@@ -355,8 +494,9 @@ export const stream = (model, context, options) => {
                                 block.id = toolCall.id;
                                 toolCallBlocksById.set(toolCall.id, block);
                             }
-                            if (!block.name && toolCall.function?.name) {
-                                block.name = toolCall.function.name;
+                            const name = toolCall.function?.name ?? toolCall.custom?.name;
+                            if (!block.name && name) {
+                                block.name = name;
                             }
                             let delta = "";
                             if (toolCall.function?.arguments) {
@@ -364,6 +504,10 @@ export const stream = (model, context, options) => {
                                 block.partialArgs = (block.partialArgs ?? "") + toolCall.function.arguments;
                                 block.arguments = parseStreamingJson(block.partialArgs);
                             }
+                            else if (toolCall.custom?.input) {
+                                const nextInput = getCustomToolCallInput(block) + toolCall.custom.input;
+                                delta = appendCustomToolCallInput(block, nextInput, false) ?? "";
+                            }
                             stream.push({
                                 type: "toolcall_delta",
                                 contentIndex: getContentIndex(block),
@@ -412,6 +556,7 @@ export const stream = (model, context, options) => {
                 delete block.index;
                 // Streaming scratch buffers are only used during parsing; never persist them.
                 delete block.partialArgs;
+                delete block.customInput;
                 delete block.streamIndex;
             }
             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
@@ -433,12 +578,15 @@ export const stream = (model, context, options) => {
 export const streamSimple = (model, context, options) => {
     getClientApiKey(model.provider, options?.apiKey, options?.headers);
     const base = buildBaseOptions(model, context, options, options?.apiKey);
-    const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
+    const compat = getCompat(model);
+    const thinkingLevelMap = getThinkingLevelMap(model, compat);
+    const thinkingModel = thinkingLevelMap === model.thinkingLevelMap ? model : { ...model, thinkingLevelMap };
+    const clampedReasoning = options?.reasoning ? clampThinkingLevel(thinkingModel, options.reasoning) : undefined;
     const reasoningEffort = clampedReasoning === "off"
         ? undefined
-        : clampedReasoning === "max" && model.thinkingLevelMap?.max !== undefined
+        : clampedReasoning === "max" && thinkingLevelMap?.max !== undefined
             ? "max"
-            : clampMaxForOpenAI(clampedReasoning, supportsXhigh(model));
+            : clampMaxForOpenAI(clampedReasoning, supportsXhigh(thinkingModel));
     const toolChoice = options?.toolChoice;
     return stream(model, context, {
         ...base,
@@ -479,11 +627,13 @@ function createClient(model, context, apiKey, optionsHeaders, sessionId, compat
         defaultHeaders: headers,
     });
 }
-function buildParams(model, context, options, compat = getCompat(model), cacheRetention = resolveCacheRetention(options?.cacheRetention ?? model.cacheRetention, options?.env)) {
+function buildParams(model, context, options, compat = getCompat(model), cacheRetention = resolveCacheRetention(options?.cacheRetention ?? model.cacheRetention, options?.env), grammarToolInputProperties = createGrammarToolInputProperties(context.tools, compat.supportsOpenAIGrammarTools)) {
     const messages = convertMessages(model, context, compat, {
         preserveThinking: options?.reasoningEffort !== undefined,
+        grammarToolInputProperties,
     });
     const cacheControl = getCompatCacheControl(compat, cacheRetention);
+    const thinkingLevelMap = getThinkingLevelMap(model, compat);
     const params = {
         model: model.id,
         messages,
@@ -533,9 +683,8 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
         const zaiParams = params;
         zaiParams.thinking = options?.reasoningEffort ? { type: "enabled", clear_thinking: false } : { type: "disabled" };
         if (options?.reasoningEffort && compat.supportsReasoningEffort) {
-            const mappedEffort = model.thinkingLevelMap?.[options.reasoningEffort];
-            const effort = mappedEffort === undefined ? options.reasoningEffort : mappedEffort;
-            if (typeof effort === "string") {
+            const effort = resolveReasoningEffort(thinkingLevelMap, options.reasoningEffort);
+            if (effort !== undefined) {
                 zaiParams.reasoning_effort = effort;
             }
         }
@@ -559,10 +708,13 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
         if (options?.reasoningEffort) {
             params.thinking = { type: "enabled" };
             if (compat.supportsReasoningEffort) {
-                params.reasoning_effort = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+                const effort = resolveReasoningEffort(thinkingLevelMap, options.reasoningEffort);
+                if (effort !== undefined) {
+                    params.reasoning_effort = effort;
+                }
             }
         }
-        else if (compat.supportsDisabledThinking !== false && model.thinkingLevelMap?.off !== null) {
+        else if (compat.supportsDisabledThinking !== false && thinkingLevelMap?.off !== null) {
             params.thinking = { type: "disabled" };
         }
     }
@@ -570,16 +722,17 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
         // OpenRouter normalizes reasoning across providers via a nested reasoning object.
         const openRouterParams = params;
         if (options?.reasoningEffort) {
-            openRouterParams.reasoning = {
-                effort: model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort,
-            };
+            const effort = resolveReasoningEffort(thinkingLevelMap, options.reasoningEffort);
+            if (effort !== undefined) {
+                openRouterParams.reasoning = { effort };
+            }
         }
-        else if (model.thinkingLevelMap?.off !== null) {
-            openRouterParams.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
+        else if (thinkingLevelMap?.off !== null) {
+            openRouterParams.reasoning = { effort: thinkingLevelMap?.off ?? "none" };
         }
     }
     else if (compat.thinkingFormat === "ant-ling" && model.reasoning && options?.reasoningEffort) {
-        const effort = model.thinkingLevelMap?.[options.reasoningEffort];
+        const effort = thinkingLevelMap?.[options.reasoningEffort];
         if (typeof effort === "string") {
             params.reasoning = { effort };
         }
@@ -588,23 +741,32 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
         const togetherParams = params;
         togetherParams.reasoning = { enabled: !!options?.reasoningEffort };
         if (options?.reasoningEffort && compat.supportsReasoningEffort) {
-            togetherParams.reasoning_effort = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+            const effort = resolveReasoningEffort(thinkingLevelMap, options.reasoningEffort);
+            if (effort !== undefined) {
+                togetherParams.reasoning_effort = effort;
+            }
         }
     }
     else if (compat.thinkingFormat === "string-thinking" && model.reasoning) {
         if (options?.reasoningEffort) {
-            params.thinking = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+            const effort = resolveReasoningEffort(thinkingLevelMap, options.reasoningEffort);
+            if (effort !== undefined) {
+                params.thinking = effort;
+            }
         }
-        else if (model.thinkingLevelMap?.off !== null) {
-            params.thinking = model.thinkingLevelMap?.off ?? "none";
+        else if (thinkingLevelMap?.off !== null) {
+            params.thinking = thinkingLevelMap?.off ?? "none";
         }
     }
     else if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
         // OpenAI-style reasoning_effort
-        params.reasoning_effort = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+        const effort = resolveReasoningEffort(thinkingLevelMap, options.reasoningEffort);
+        if (effort !== undefined) {
+            params.reasoning_effort = effort;
+        }
     }
     else if (!options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
-        const offValue = model.thinkingLevelMap?.off;
+        const offValue = thinkingLevelMap?.off;
         if (typeof offValue === "string") {
             params.reasoning_effort = offValue;
         }
@@ -631,14 +793,14 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
 function buildChatTemplateKwargs(model, options, compat) {
     const kwargs = {};
     for (const [key, value] of Object.entries(compat.chatTemplateKwargs)) {
-        const resolved = resolveChatTemplateKwargValue(model, options, value);
+        const resolved = resolveChatTemplateKwargValue(model, options, compat, value);
         if (resolved !== undefined) {
             kwargs[key] = resolved;
         }
     }
     return Object.keys(kwargs).length > 0 ? kwargs : undefined;
 }
-function resolveChatTemplateKwargValue(model, options, value) {
+function resolveChatTemplateKwargValue(model, options, compat, value) {
     if (typeof value !== "object" || value === null) {
         return value;
     }
@@ -649,7 +811,8 @@ function resolveChatTemplateKwargValue(model, options, value) {
     if (value.$var === "thinking.enabled") {
         return !!reasoningEffort;
     }
-    const mappedValue = reasoningEffort ? model.thinkingLevelMap?.[reasoningEffort] : model.thinkingLevelMap?.off;
+    const thinkingLevelMap = getThinkingLevelMap(model, compat);
+    const mappedValue = reasoningEffort ? thinkingLevelMap?.[reasoningEffort] : thinkingLevelMap?.off;
     return mappedValue === undefined ? reasoningEffort : typeof mappedValue === "string" ? mappedValue : undefined;
 }
 function getCompatCacheControl(compat, cacheRetention) {
@@ -675,7 +838,7 @@ function addCacheControlToSystemPrompt(messages, cacheControl) {
 function addCacheControlToLastConversationMessage(messages, cacheControl) {
     for (let i = messages.length - 1; i >= 0; i--) {
         const message = messages[i];
-        if (message.role === "user" || message.role === "assistant") {
+        if (message.role === "user" || message.role === "assistant" || message.role === "tool") {
             if (addCacheControlToMessage(message, cacheControl)) {
                 return;
             }
@@ -693,7 +856,7 @@ function addCacheControlToInstructionMessage(message, cacheControl) {
     return addCacheControlToTextContent(message, cacheControl);
 }
 function addCacheControlToMessage(message, cacheControl) {
-    if (message.role === "user" || message.role === "assistant") {
+    if (message.role === "user" || message.role === "assistant" || message.role === "tool") {
         return addCacheControlToTextContent(message, cacheControl);
     }
     return false;
@@ -733,10 +896,21 @@ export function convertMessages(model, context, compat, options = {}) {
         // Format: {call_id}|{id} where {id} can be 400+ chars with special chars (+, /, =)
         // These come from providers like github-copilot, openai-codex, opencode
         // Extract just the call_id part and normalize it
+        // Multiple tool calls in the same turn can share call_id but differ by item_id.
+        // Preserve item-level uniqueness when replaying into Chat Completions, which
+        // requires distinct tool call ids.
         if (id.includes("|")) {
-            const [callId] = id.split("|");
             // Sanitize to allowed chars and truncate to 40 chars (OpenAI limit)
-            return callId.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 40);
+            const separatorIndex = id.indexOf("|");
+            const callId = id.slice(0, separatorIndex).replace(/[^a-zA-Z0-9_-]/g, "_");
+            const itemId = id.slice(separatorIndex + 1).replace(/[^a-zA-Z0-9_-]/g, "_");
+            const combinedId = itemId.length > 0 ? `${callId}_${itemId}` : callId;
+            if (combinedId.length <= 40) {
+                return combinedId;
+            }
+            const hash = shortHash(id).slice(0, 8);
+            const prefix = callId.slice(0, Math.max(1, 40 - hash.length - 1));
+            return `${prefix}_${hash}`;
         }
         if (model.provider === "openai")
             return id.length > 40 ? id.slice(0, 40) : id;
@@ -849,14 +1023,27 @@ export function convertMessages(model, context, compat, options = {}) {
             }
             const toolCalls = msg.content.filter(isToolCallBlock);
             if (toolCalls.length > 0) {
-                assistantMsg.tool_calls = toolCalls.map((tc) => ({
-                    id: tc.id,
-                    type: "function",
-                    function: {
-                        name: tc.name,
-                        arguments: JSON.stringify(tc.arguments),
-                    },
-                }));
+                assistantMsg.tool_calls = toolCalls.map((tc) => {
+                    const customInputProperty = options?.grammarToolInputProperties?.get(tc.name);
+                    if (customInputProperty !== undefined) {
+                        return {
+                            id: tc.id,
+                            type: "custom",
+                            custom: {
+                                name: tc.name,
+                                input: sanitizeSurrogates(getGrammarToolInput(tc.name, tc.arguments, customInputProperty)),
+                            },
+                        };
+                    }
+                    return {
+                        id: tc.id,
+                        type: "function",
+                        function: {
+                            name: tc.name,
+                            arguments: JSON.stringify(tc.arguments),
+                        },
+                    };
+                });
                 const reasoningDetails = toolCalls
                     .filter((tc) => tc.thoughtSignature)
                     .map((tc) => {
@@ -975,12 +1162,30 @@ export function convertMessages(model, context, compat, options = {}) {
 }
 function convertTools(tools, compat) {
     return tools.map((tool) => {
+        const grammar = resolveGrammarConstrainedSampling(tool, compat.supportsOpenAIGrammarTools);
+        if (grammar) {
+            return {
+                type: "custom",
+                custom: {
+                    name: tool.name,
+                    description: tool.description,
+                    format: {
+                        type: "grammar",
+                        grammar: {
+                            syntax: grammar.format,
+                            definition: grammar.definition,
+                        },
+                    },
+                },
+            };
+        }
         if (tool.freeform) {
             throw new Error("Freeform tools cannot be sent to OpenAI Chat Completions; use Responses API");
         }
         const normalizedParameters = compat.toolSchemaFlavor === "moonshot-mfjs"
             ? normalizeToolParametersForMoonshot(tool.parameters)
             : normalizeToolParametersForOpenAICompat(tool.parameters);
+        const strict = resolveJsonSchemaStrictSampling(tool, compat.supportsStrictMode !== false);
         return {
             type: "function",
             function: {
@@ -988,7 +1193,7 @@ function convertTools(tools, compat) {
                 description: tool.description,
                 parameters: normalizedParameters,
                 // Only include strict if provider supports it. Some reject unknown fields.
-                ...(compat.supportsStrictMode !== false && { strict: false }),
+                ...(compat.supportsStrictMode !== false && { strict: strict ?? false }),
             },
         };
     });
@@ -1129,6 +1334,7 @@ function detectCompat(model) {
         toolSchemaFlavor: isMoonshot ? "moonshot-mfjs" : undefined,
         supportsDisabledThinking: true,
         toolCallFormat: undefined,
+        supportsOpenAIGrammarTools: false,
         cacheControlFormat,
         sendSessionAffinityHeaders: false,
         deferredToolsMode: undefined,
@@ -1167,6 +1373,7 @@ function getCompat(model) {
         zaiToolStream: model.compat.zaiToolStream ?? detected.zaiToolStream,
         supportsStrictMode: model.compat.supportsStrictMode ?? detected.supportsStrictMode,
         toolCallFormat: model.compat.toolCallFormat ?? detected.toolCallFormat,
+        supportsOpenAIGrammarTools: model.compat.supportsOpenAIGrammarTools ?? detected.supportsOpenAIGrammarTools,
         cacheControlFormat: model.compat.cacheControlFormat ?? detected.cacheControlFormat,
         sendSessionAffinityHeaders: model.compat.sendSessionAffinityHeaders ?? detected.sendSessionAffinityHeaders,
         deferredToolsMode: model.compat.deferredToolsMode ?? detected.deferredToolsMode,