@psnext/slingcli 2.5.20260723-1 → 2.5.20260725-1

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

@@ -6,7 +6,9 @@ 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 { 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 { buildBaseOptions } from "./simple-options.js";
@@ -120,10 +122,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, 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;
@@ -131,11 +134,13 @@ 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 { data: openaiStream, response } = await client.chat.completions
-                .create(params, requestOptions)
-                .withResponse();
+            const { data: openaiStream, response } = await retryProviderRequest(() => client.chat.completions.create(params, requestOptions).withResponse(), {
+                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;
@@ -146,6 +151,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) {
@@ -168,10 +188,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",
@@ -213,17 +247,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) {
@@ -246,6 +290,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;
             };
@@ -327,8 +383,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) {
@@ -336,6 +393,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),
@@ -384,6 +445,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";
@@ -447,8 +509,8 @@ function createClient(model, context, apiKey, optionsHeaders, sessionId, compat
         defaultHeaders: headers,
     });
 }
-function buildParams(model, context, options, compat = getCompat(model), cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env)) {
-    const messages = convertMessages(model, context, compat);
+function buildParams(model, context, options, compat = getCompat(model), cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env), grammarToolInputProperties = createGrammarToolInputProperties(context.tools, compat.supportsOpenAIGrammarTools)) {
+    const messages = convertMessages(model, context, compat, { grammarToolInputProperties });
     const cacheControl = getCompatCacheControl(compat, cacheRetention);
     const params = {
         model: model.id,
@@ -642,7 +704,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;
             }
@@ -660,7 +722,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;
@@ -693,7 +755,7 @@ function addCacheControlToTextContent(message, cacheControl) {
     }
     return false;
 }
-export function convertMessages(model, context, compat) {
+export function convertMessages(model, context, compat, options) {
     const params = [];
     const normalizeToolCallId = (id) => {
         // Handle pipe-separated IDs from OpenAI Responses API
@@ -823,14 +885,27 @@ export function convertMessages(model, context, compat) {
             }
             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) => {
@@ -948,16 +1023,36 @@ export function convertMessages(model, context, compat) {
     return params;
 }
 function convertTools(tools, compat) {
-    return tools.map((tool) => ({
-        type: "function",
-        function: {
-            name: tool.name,
-            description: tool.description,
-            parameters: tool.parameters, // TypeBox already generates JSON Schema
-            // Only include strict if provider supports it. Some reject unknown fields.
-            ...(compat.supportsStrictMode !== false && { strict: false }),
-        },
-    }));
+    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,
+                        },
+                    },
+                },
+            };
+        }
+        const strict = resolveJsonSchemaStrictSampling(tool, compat.supportsStrictMode !== false);
+        return {
+            type: "function",
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters, // TypeBox already generates JSON Schema
+                // Only include strict if provider supports it. Some reject unknown fields.
+                ...(compat.supportsStrictMode !== false && { strict: strict ?? false }),
+            },
+        };
+    });
 }
 function parseChunkUsage(rawUsage, model) {
     const promptTokens = rawUsage.prompt_tokens || 0;
@@ -1074,6 +1169,7 @@ function detectCompat(model) {
         chatTemplateKwargs: {},
         zaiToolStream: false,
         supportsStrictMode: !isMoonshot && !isTogether && !isCloudflareAiGateway && !isNvidia,
+        supportsOpenAIGrammarTools: false,
         cacheControlFormat,
         sendSessionAffinityHeaders: false,
         deferredToolsMode: undefined,
@@ -1110,6 +1206,7 @@ function getCompat(model) {
         chatTemplateKwargs: model.compat.chatTemplateKwargs ?? detected.chatTemplateKwargs,
         zaiToolStream: model.compat.zaiToolStream ?? detected.zaiToolStream,
         supportsStrictMode: model.compat.supportsStrictMode ?? detected.supportsStrictMode,
+        supportsOpenAIGrammarTools: model.compat.supportsOpenAIGrammarTools ?? detected.supportsOpenAIGrammarTools,
         cacheControlFormat: model.compat.cacheControlFormat ?? detected.cacheControlFormat,
         sendSessionAffinityHeaders: model.compat.sendSessionAffinityHeaders ?? detected.sendSessionAffinityHeaders,
         deferredToolsMode: model.compat.deferredToolsMode ?? detected.deferredToolsMode,

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

@@ -2,6 +2,7 @@ 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 +32,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;
+}
 // =============================================================================
 // Message conversion
 // =============================================================================
@@ -141,20 +165,35 @@ 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);
                     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_")) {
+                    // When replaying custom-tool calls as a function_call, also drop non-fc_* ids such as
+                    // ctc_* custom-tool ids because function_call item ids must be fc_*.
+                    if ((isDifferentModel && itemId?.startsWith("fc_")) ||
+                        (customInputProperty === undefined && !itemId?.startsWith("fc_"))) {
                         itemId = undefined;
                     }
-                    output.push({
-                        type: "function_call",
-                        id: itemId,
-                        call_id: callId,
-                        name: toolCall.name,
-                        arguments: JSON.stringify(toolCall.arguments),
-                    });
+                    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 {
+                        output.push({
+                            type: "function_call",
+                            id: itemId,
+                            call_id: callId,
+                            name: toolCall.name,
+                            arguments: JSON.stringify(toolCall.arguments),
+                        });
+                    }
                 }
             }
             if (output.length === 0)
@@ -162,41 +201,22 @@ export function convertResponsesMessages(model, context, allowedToolCallProvider
             messages.push(...output);
         }
         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;
+            const output = convertToolResultOutput(model, msg.content);
+            if (options?.grammarToolInputProperties?.has(msg.toolName)) {
+                messages.push({
+                    type: "custom_tool_call_output",
+                    call_id: callId,
+                    output,
+                });
             }
             else {
-                output = sanitizeSurrogates(hasText ? textResult : hasImages ? "(see attached image)" : "(no tool output)");
+                messages.push({
+                    type: "function_call_output",
+                    call_id: callId,
+                    output,
+                });
             }
-            messages.push({
-                type: "function_call_output",
-                call_id: callId,
-                output,
-            });
             const deferredTools = [];
             for (const name of msg.addedToolNames ?? []) {
                 const tool = options?.deferredTools?.get(name);
@@ -220,7 +240,10 @@ export function convertResponsesMessages(model, context, allowedToolCallProvider
                     call_id: searchCallId,
                     execution: "client",
                     status: "completed",
-                    tools: convertResponsesTools(deferredTools, { deferLoading: true }),
+                    tools: convertResponsesTools(deferredTools, {
+                        ...options?.toolOptions,
+                        deferLoading: true,
+                    }),
                 });
             }
         }
@@ -232,15 +255,52 @@ export function convertResponsesMessages(model, context, allowedToolCallProvider
 // Tool conversion
 // =============================================================================
 export function convertResponsesTools(tools, options) {
-    const strict = options?.strict === undefined ? false : options.strict;
-    return tools.map((tool) => ({
-        type: "function",
-        name: tool.name,
-        description: tool.description,
-        parameters: tool.parameters, // TypeBox already generates JSON Schema
-        strict,
-        ...(options?.deferLoading ? { defer_loading: true } : {}),
-    }));
+    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 } : {}),
+            };
+        }
+        const constrainedStrict = resolveJsonSchemaStrictSampling(tool, supportsStrictMode);
+        const functionTool = {
+            type: "function",
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters, // TypeBox already generates JSON Schema
+            ...(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;
@@ -250,6 +310,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: "" };
@@ -289,6 +359,29 @@ export async function processResponsesStream(openaiStream, output, stream, model
             stream.push({ type: "toolcall_start", contentIndex: slot.contentIndex, partial: output });
             return slot;
         }
+        if (item.type === "custom_tool_call") {
+            const inputProperty = options?.grammarToolInputProperties?.get(item.name) ?? "input";
+            const input = item.input || "";
+            const block = {
+                type: "toolCall",
+                id: `${item.call_id}|${item.id}`,
+                name: item.name,
+                arguments: { [inputProperty]: input },
+                customInput: {
+                    property: inputProperty,
+                    jsonBuffer: { input: "", started: false, closed: false },
+                },
+            };
+            output.content.push(block);
+            const slot = {
+                type: "toolCall",
+                block,
+                contentIndex: output.content.length - 1,
+            };
+            outputSlots.set(outputIndex, slot);
+            stream.push({ type: "toolcall_start", contentIndex: slot.contentIndex, partial: output });
+            return slot;
+        }
         return undefined;
     };
     const getOrCreateSlot = (outputIndex, item) => {
@@ -417,36 +510,37 @@ 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 || !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 || !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 = getOrCreateSlot(event.output_index, item);
@@ -475,7 +569,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.
@@ -488,6 +584,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 (event.type === "response.completed" || event.type === "response.incomplete") {
             finalizeResponse(event.response);