@code-yeongyu/senpi 2026.7.23 → 2026.7.24

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

@@ -1,7 +1,9 @@
+import { CONTEXT_PROVENANCE_FIELD, contextProvenanceFingerprint, getContextProvenance, } from "../context-provenance.js";
 import { calculateCost } from "../models.js";
 import { shortHash } from "../utils/hash.js";
 import { parseStreamingJson } from "../utils/json-parse.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
+import { appendGrammarToolInputJsonDelta, getGrammarToolInput, resolveGrammarConstrainedSampling, resolveJsonSchemaStrictSampling, } from "./constrained-sampling.js";
 import { transformMessages } from "./transform-messages.js";
 // =============================================================================
 // Utilities
@@ -31,6 +33,29 @@ function parseTextSignature(signature) {
     }
     return { id: signature };
 }
+function convertToolResultOutput(model, content) {
+    const textResult = content
+        .filter((c) => c.type === "text")
+        .map((c) => c.text)
+        .join("\n");
+    const images = content.filter((c) => c.type === "image");
+    const hasText = textResult.length > 0;
+    if (images.length === 0 || !model.input.includes("image")) {
+        return sanitizeSurrogates(hasText ? textResult : images.length > 0 ? "(see attached image)" : "(no tool output)");
+    }
+    const output = [];
+    if (hasText) {
+        output.push({ type: "input_text", text: sanitizeSurrogates(textResult) });
+    }
+    for (const image of images) {
+        output.push({
+            type: "input_image",
+            detail: "auto",
+            image_url: `data:${image.mimeType};base64,${image.data}`,
+        });
+    }
+    return output;
+}
 function isResponseCustomToolCallItem(item) {
     return item.type === "custom_tool_call";
 }
@@ -43,6 +68,30 @@ function isFreeformToolName(toolName, tools) {
 function getFreeformToolInput(argumentsValue) {
     return typeof argumentsValue.input === "string" ? argumentsValue.input : JSON.stringify(argumentsValue);
 }
+function contextProvenanceForInput(message, seal) {
+    const provenance = getContextProvenance(message);
+    if (!provenance)
+        return undefined;
+    const fingerprint = contextProvenanceFingerprint(message);
+    if (fingerprint === undefined)
+        return undefined;
+    const stored = provenance.integrity;
+    if (stored === undefined && seal) {
+        provenance.integrity = fingerprint;
+        return provenance;
+    }
+    return stored === fingerprint ? provenance : undefined;
+}
+function withContextProvenance(item, message, seal) {
+    const provenance = contextProvenanceForInput(message, seal);
+    if (provenance) {
+        Object.defineProperty(item, CONTEXT_PROVENANCE_FIELD, {
+            value: provenance,
+            enumerable: false,
+        });
+    }
+    return item;
+}
 // =============================================================================
 // Message conversion
 // =============================================================================
@@ -90,10 +139,10 @@ export function convertResponsesMessages(model, context, allowedToolCallProvider
     for (const msg of transformedMessages) {
         if (msg.role === "user") {
             if (typeof msg.content === "string") {
-                messages.push({
+                messages.push(withContextProvenance({
                     role: "user",
                     content: [{ type: "input_text", text: sanitizeSurrogates(msg.content) }],
-                });
+                }, msg, options?.sealContextProvenance));
             }
             else {
                 const content = msg.content.map((item) => {
@@ -111,10 +160,7 @@ export function convertResponsesMessages(model, context, allowedToolCallProvider
                 });
                 if (content.length === 0)
                     continue;
-                messages.push({
-                    role: "user",
-                    content,
-                });
+                messages.push(withContextProvenance({ role: "user", content }, msg, options?.sealContextProvenance));
             }
         }
         else if (msg.role === "assistant") {
@@ -158,14 +204,28 @@ export function convertResponsesMessages(model, context, allowedToolCallProvider
                 else if (block.type === "toolCall") {
                     const toolCall = block;
                     const [callId, itemIdRaw] = toolCall.id.split("|");
+                    const customInputProperty = options?.grammarToolInputProperties?.get(toolCall.name);
+                    const isFreeform = isFreeformToolName(toolCall.name, context.tools);
                     let itemId = itemIdRaw;
                     // For different-model messages, set id to undefined to avoid pairing validation.
                     // OpenAI tracks which fc_xxx IDs were paired with rs_xxx reasoning items.
                     // By omitting the id, we avoid triggering that validation (like cross-provider does).
-                    if (isDifferentModel && itemId?.startsWith("fc_")) {
+                    // Function-call item ids must begin with fc_ while freeform calls can replay
+                    // without the local <call_id>|custom sentinel.
+                    if ((isDifferentModel && itemId?.startsWith("fc_")) ||
+                        (!isFreeform && customInputProperty === undefined && !itemId?.startsWith("fc_"))) {
                         itemId = undefined;
                     }
-                    if (isFreeformToolName(toolCall.name, context.tools)) {
+                    if (customInputProperty !== undefined) {
+                        output.push({
+                            type: "custom_tool_call",
+                            id: itemId,
+                            call_id: callId,
+                            name: toolCall.name,
+                            input: sanitizeSurrogates(getGrammarToolInput(toolCall.name, toolCall.arguments, customInputProperty)),
+                        });
+                    }
+                    else if (isFreeform) {
                         output.push({
                             type: "custom_tool_call",
                             call_id: callId,
@@ -174,14 +234,9 @@ export function convertResponsesMessages(model, context, allowedToolCallProvider
                         });
                     }
                     else {
-                        // The Responses API rejects function_call input items whose id does
-                        // not begin with "fc". Custom tool calls replayed without their
-                        // freeform tool (e.g. compaction summarization requests) carry the
-                        // "<call_id>|custom" sentinel, not a server-issued id; omit it.
-                        const replayableItemId = itemId?.startsWith("fc") ? itemId : undefined;
                         output.push({
                             type: "function_call",
-                            ...(replayableItemId ? { id: replayableItemId } : {}),
+                            ...(itemId?.startsWith("fc_") ? { id: itemId } : {}),
                             call_id: callId,
                             name: toolCall.name,
                             arguments: JSON.stringify(toolCall.arguments),
@@ -191,53 +246,29 @@ export function convertResponsesMessages(model, context, allowedToolCallProvider
             }
             if (output.length === 0)
                 continue;
-            messages.push(...output);
+            messages.push(...output.map((item) => withContextProvenance(item, msg, options?.sealContextProvenance)));
         }
         else if (msg.role === "toolResult") {
-            const textResult = msg.content
-                .filter((c) => c.type === "text")
-                .map((c) => c.text)
-                .join("\n");
-            const hasImages = msg.content.some((c) => c.type === "image");
-            const hasText = textResult.length > 0;
             const [callId] = msg.toolCallId.split("|");
-            let output;
-            if (hasImages && model.input.includes("image")) {
-                const contentParts = [];
-                if (hasText) {
-                    contentParts.push({
-                        type: "input_text",
-                        text: sanitizeSurrogates(textResult),
-                    });
-                }
-                for (const block of msg.content) {
-                    if (block.type === "image") {
-                        contentParts.push({
-                            type: "input_image",
-                            detail: "auto",
-                            image_url: `data:${block.mimeType};base64,${block.data}`,
-                        });
-                    }
-                }
-                output = contentParts;
-            }
-            else {
-                output = sanitizeSurrogates(hasText ? textResult : hasImages ? "(see attached image)" : "(no tool output)");
+            const output = convertToolResultOutput(model, msg.content);
+            const customInputProperty = options?.grammarToolInputProperties?.get(msg.toolName);
+            if (customInputProperty !== undefined) {
+                messages.push(withContextProvenance({
+                    type: "custom_tool_call_output",
+                    call_id: callId,
+                    output,
+                }, msg, options?.sealContextProvenance));
             }
-            if (isFreeformToolName(msg.toolName, context.tools)) {
-                messages.push({
+            else if (isFreeformToolName(msg.toolName, context.tools)) {
+                messages.push(withContextProvenance({
                     type: "custom_tool_call_output",
                     call_id: callId,
                     name: msg.toolName,
                     output,
-                });
+                }, msg, options?.sealContextProvenance));
             }
             else {
-                messages.push({
-                    type: "function_call_output",
-                    call_id: callId,
-                    output,
-                });
+                messages.push(withContextProvenance({ type: "function_call_output", call_id: callId, output }, msg, options?.sealContextProvenance));
             }
             const deferredTools = [];
             for (const name of msg.addedToolNames ?? []) {
@@ -250,20 +281,23 @@ export function convertResponsesMessages(model, context, allowedToolCallProvider
             if (deferredTools.length > 0) {
                 const names = deferredTools.map((tool) => tool.name);
                 const searchCallId = `pi_tool_load_${shortHash(`${msg.toolCallId}:${names.join(",")}`)}`;
-                messages.push({
+                messages.push(withContextProvenance({
                     type: "tool_search_call",
                     call_id: searchCallId,
                     execution: "client",
                     status: "completed",
                     arguments: { query: names.join(" "), limit: names.length },
-                });
-                messages.push({
+                }, msg, options?.sealContextProvenance));
+                messages.push(withContextProvenance({
                     type: "tool_search_output",
                     call_id: searchCallId,
                     execution: "client",
                     status: "completed",
-                    tools: convertResponsesTools(deferredTools, { deferLoading: true }),
-                });
+                    tools: convertResponsesTools(deferredTools, {
+                        ...options?.toolOptions,
+                        deferLoading: true,
+                    }),
+                }, msg, options?.sealContextProvenance));
             }
         }
         msgIndex++;
@@ -274,8 +308,24 @@ export function convertResponsesMessages(model, context, allowedToolCallProvider
 // Tool conversion
 // =============================================================================
 export function convertResponsesTools(tools, options) {
-    const strict = options?.strict === undefined ? false : options.strict;
+    const defaultStrict = options?.strict === undefined ? false : options.strict;
+    const supportsStrictMode = options?.supportsStrictMode ?? true;
+    const supportsOpenAIGrammarTools = options?.supportsOpenAIGrammarTools ?? false;
     return tools.map((tool) => {
+        const grammar = resolveGrammarConstrainedSampling(tool, supportsOpenAIGrammarTools);
+        if (grammar) {
+            return {
+                type: "custom",
+                name: tool.name,
+                description: tool.description,
+                format: {
+                    type: "grammar",
+                    syntax: grammar.format,
+                    definition: grammar.definition,
+                },
+                ...(options?.deferLoading ? { defer_loading: true } : {}),
+            };
+        }
         if (tool.freeform) {
             return {
                 type: "custom",
@@ -285,16 +335,35 @@ export function convertResponsesTools(tools, options) {
                 ...(options?.deferLoading ? { defer_loading: true } : {}),
             };
         }
-        return {
+        const constrainedStrict = resolveJsonSchemaStrictSampling(tool, supportsStrictMode);
+        const functionTool = {
             type: "function",
             name: tool.name,
             description: tool.description,
             parameters: tool.parameters, // TypeBox already generates JSON Schema
-            strict,
             ...(options?.deferLoading ? { defer_loading: true } : {}),
         };
+        if (supportsStrictMode) {
+            functionTool.strict = constrainedStrict ?? defaultStrict;
+        }
+        return functionTool;
     });
 }
+function getCustomToolCallInput(block) {
+    const property = block.customInput?.property;
+    if (property === undefined)
+        return "";
+    const value = block.arguments[property];
+    return typeof value === "string" ? value : "";
+}
+function 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;
+}
 export async function processResponsesStream(openaiStream, output, stream, model, options) {
     let sawTerminalResponseEvent = false;
     const outputSlots = new Map();
@@ -303,6 +372,16 @@ export async function processResponsesStream(openaiStream, output, stream, model
         const slot = outputSlots.get(outputIndex);
         return slot?.type === type ? slot : undefined;
     };
+    const pushToolCallDelta = (slot, delta) => {
+        if (delta === undefined)
+            return;
+        stream.push({
+            type: "toolcall_delta",
+            contentIndex: slot.contentIndex,
+            delta,
+            partial: output,
+        });
+    };
     const createSlot = (outputIndex, item) => {
         if (item.type === "reasoning") {
             const block = { type: "thinking", thinking: "" };
@@ -343,13 +422,17 @@ export async function processResponsesStream(openaiStream, output, stream, model
             return slot;
         }
         if (isResponseCustomToolCallItem(item)) {
+            const inputProperty = options?.grammarToolInputProperties?.get(item.name) ?? "input";
             const input = item.input || "";
             const block = {
                 type: "toolCall",
-                id: `${item.call_id}|custom`,
+                id: `${item.call_id}|${item.id ?? "custom"}`,
                 name: item.name,
-                arguments: { input },
-                partialJson: JSON.stringify({ input }),
+                arguments: { [inputProperty]: input },
+                customInput: {
+                    property: inputProperty,
+                    jsonBuffer: { input: "", started: false, closed: false },
+                },
             };
             output.content.push(block);
             const slot = {
@@ -371,6 +454,9 @@ export async function processResponsesStream(openaiStream, output, stream, model
         outputSlots.set(outputIndex, slot);
         return slot;
     };
+    const getOrCreateSlot = (outputIndex, item) => {
+        return outputSlots.get(outputIndex) ?? createSlot(outputIndex, item);
+    };
     // Azure OpenAI can omit reasoning.encrypted_content from response.output_item.done
     // and provide it only in response.completed.response.output. Backfill the
     // persisted reasoning signature from the terminal response to keep store:false
@@ -494,39 +580,40 @@ export async function processResponsesStream(openaiStream, output, stream, model
         }
         else if (event.type === "response.function_call_arguments.delta") {
             const slot = getSlot(event.output_index, "toolCall");
-            if (!slot)
+            if (!slot || slot.block.partialJson === undefined)
                 continue;
             slot.block.partialJson += event.delta;
             slot.block.arguments = parseStreamingJson(slot.block.partialJson);
-            stream.push({
-                type: "toolcall_delta",
-                contentIndex: slot.contentIndex,
-                delta: event.delta,
-                partial: output,
-            });
+            pushToolCallDelta(slot, event.delta);
         }
         else if (event.type === "response.function_call_arguments.done") {
             const slot = getSlot(event.output_index, "toolCall");
-            if (!slot)
+            if (!slot || slot.block.partialJson === undefined)
                 continue;
             const previousPartialJson = slot.block.partialJson;
             slot.block.partialJson = event.arguments;
             slot.block.arguments = parseStreamingJson(slot.block.partialJson);
             if (event.arguments.startsWith(previousPartialJson)) {
                 const delta = event.arguments.slice(previousPartialJson.length);
-                if (delta.length > 0) {
-                    stream.push({
-                        type: "toolcall_delta",
-                        contentIndex: slot.contentIndex,
-                        delta,
-                        partial: output,
-                    });
-                }
+                if (delta.length > 0)
+                    pushToolCallDelta(slot, delta);
             }
         }
+        else if (event.type === "response.custom_tool_call_input.delta") {
+            const slot = getSlot(event.output_index, "toolCall");
+            if (!slot?.block.customInput)
+                continue;
+            pushToolCallDelta(slot, appendCustomToolCallInput(slot.block, getCustomToolCallInput(slot.block) + event.delta, false));
+        }
+        else if (event.type === "response.custom_tool_call_input.done") {
+            const slot = getSlot(event.output_index, "toolCall");
+            if (!slot?.block.customInput)
+                continue;
+            pushToolCallDelta(slot, appendCustomToolCallInput(slot.block, event.input, true));
+        }
         else if (event.type === "response.output_item.done") {
             const item = event.item;
-            const slot = outputSlots.get(event.output_index) ?? createSlot(event.output_index, item);
+            const slot = getOrCreateSlot(event.output_index, item);
             if (item.type === "reasoning" && slot?.type === "thinking") {
                 const summaryText = item.summary?.map((s) => s.text).join("\n\n") || "";
                 const contentText = item.content?.map((c) => c.text).join("\n\n") || "";
@@ -552,7 +639,9 @@ export async function processResponsesStream(openaiStream, output, stream, model
                 });
                 outputSlots.delete(event.output_index);
             }
-            else if (item.type === "function_call" && slot?.type === "toolCall") {
+            else if (item.type === "function_call" &&
+                slot?.type === "toolCall" &&
+                slot.block.partialJson !== undefined) {
                 slot.block.arguments = parseStreamingJson(item.arguments || slot.block.partialJson || "{}");
                 // Finalize in-place and strip the scratch buffer so replay only
                 // carries parsed arguments.
@@ -565,6 +654,17 @@ export async function processResponsesStream(openaiStream, output, stream, model
                 });
                 outputSlots.delete(event.output_index);
             }
+            else if (item.type === "custom_tool_call" && slot?.type === "toolCall" && slot.block.customInput) {
+                pushToolCallDelta(slot, appendCustomToolCallInput(slot.block, item.input ?? getCustomToolCallInput(slot.block), true));
+                delete slot.block.customInput;
+                stream.push({
+                    type: "toolcall_end",
+                    contentIndex: slot.contentIndex,
+                    toolCall: slot.block,
+                    partial: output,
+                });
+                outputSlots.delete(event.output_index);
+            }
             else if (isResponseCustomToolCallItem(item) && slot?.type === "toolCall") {
                 const input = typeof item.input === "string" ? item.input : "";
                 slot.block.arguments = { input };