@code-yeongyu/senpi 2026.7.23 → 2026.7.24

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

@@ -2,12 +2,15 @@ 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";
@@ -133,10 +136,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 +149,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 +180,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 +217,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 +276,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 +319,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 +413,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 +423,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 +475,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";
@@ -479,9 +543,10 @@ 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 params = {
@@ -675,7 +740,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 +758,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 +798,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 +925,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 +1064,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 +1095,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 +1236,7 @@ function detectCompat(model) {
         toolSchemaFlavor: isMoonshot ? "moonshot-mfjs" : undefined,
         supportsDisabledThinking: true,
         toolCallFormat: undefined,
+        supportsOpenAIGrammarTools: false,
         cacheControlFormat,
         sendSessionAffinityHeaders: false,
         deferredToolsMode: undefined,
@@ -1167,6 +1275,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,