@psnext/slingcli 2.5.20260724-1 → 2.5.20260727-1

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);

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

@@ -5,6 +5,8 @@ import { formatProviderError, normalizeProviderError } from "../utils/error-body
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
+import { retryProviderRequest } from "../utils/provider-retry.js";
+import { createGrammarToolInputProperties } from "./constrained-sampling.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
@@ -50,7 +52,10 @@ function getCompat(model) {
         supportsDeveloperRole: model.compat?.supportsDeveloperRole ?? true,
         sessionAffinityFormat: model.compat?.sessionAffinityFormat ?? detectSessionAffinityFormat(model),
         supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? true,
+        supportsStrictMode: model.compat?.supportsStrictMode ?? false,
+        supportsOpenAIGrammarTools: model.compat?.supportsOpenAIGrammarTools ?? false,
         supportsToolSearch: model.compat?.supportsToolSearch ?? false,
+        supportsExplicitPromptCacheMode: model.compat?.supportsExplicitPromptCacheMode ?? false,
     };
 }
 function getPromptCacheRetention(compat, cacheRetention) {
@@ -88,8 +93,10 @@ export const stream = (model, context, options) => {
             const apiKey = getClientApiKey(model.provider, options?.apiKey, options?.headers);
             const cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env);
             const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
+            const compat = getCompat(model);
+            const grammarToolInputProperties = createGrammarToolInputProperties(context.tools, compat.supportsOpenAIGrammarTools);
             const client = createClient(model, context, apiKey, options?.headers, cacheSessionId);
-            let params = buildParams(model, context, options);
+            let params = buildParams(model, context, options, compat, grammarToolInputProperties);
             const nextParams = await options?.onPayload?.(params, model);
             if (nextParams !== undefined) {
                 params = nextParams;
@@ -97,13 +104,18 @@ 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.responses.create(params, requestOptions).withResponse();
+            const { data: openaiStream, response } = await retryProviderRequest(() => client.responses.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 });
             await processResponsesStream(openaiStream, output, stream, model, {
                 serviceTier: options?.serviceTier,
+                grammarToolInputProperties,
                 applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model),
             });
             if (options?.signal?.aborted) {
@@ -118,8 +130,9 @@ export const stream = (model, context, options) => {
         catch (error) {
             for (const block of output.content) {
                 delete block.index;
-                // partialJson is only a streaming scratch buffer; never persist it.
+                // Streaming scratch buffers are only used during parsing; never persist them.
                 delete block.partialJson;
+                delete block.customInput;
             }
             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
             output.errorMessage = formatOpenAIResponsesError(error);
@@ -172,19 +185,25 @@ function createClient(model, context, apiKey, optionsHeaders, sessionId) {
         defaultHeaders: headers,
     });
 }
-function buildParams(model, context, options) {
-    const compat = getCompat(model);
+function buildParams(model, context, options, compat = getCompat(model), grammarToolInputProperties = createGrammarToolInputProperties(context.tools, compat.supportsOpenAIGrammarTools)) {
     const toolPlacement = splitDeferredTools(context, compat.supportsToolSearch);
     const messages = convertResponsesMessages(model, context, OPENAI_TOOL_CALL_PROVIDERS, {
+        grammarToolInputProperties,
         deferredTools: toolPlacement.deferred,
+        toolOptions: {
+            supportsStrictMode: compat.supportsStrictMode,
+            supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools,
+        },
     });
     const cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env);
+    const disableImplicitPromptCache = cacheRetention === "none" && compat.supportsExplicitPromptCacheMode;
     const params = {
         model: model.id,
         input: messages,
         stream: true,
         prompt_cache_key: cacheRetention === "none" ? undefined : clampOpenAIPromptCacheKey(options?.sessionId),
         prompt_cache_retention: getPromptCacheRetention(compat, cacheRetention),
+        prompt_cache_options: disableImplicitPromptCache ? { mode: "explicit" } : undefined,
         store: false,
     };
     if (options?.maxTokens) {
@@ -197,7 +216,10 @@ function buildParams(model, context, options) {
         params.service_tier = options.serviceTier;
     }
     if (toolPlacement.immediate.length > 0) {
-        params.tools = convertResponsesTools(toolPlacement.immediate);
+        params.tools = convertResponsesTools(toolPlacement.immediate, {
+            supportsStrictMode: compat.supportsStrictMode,
+            supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools,
+        });
     }
     if (options?.toolChoice !== undefined) {
         params.tool_choice = options.toolChoice;

package/node_modules/@earendil-works/pi-ai/dist/api/openrouter-images.js

@@ -1,6 +1,7 @@
 import OpenAI from "openai";
 import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
 import { headersToRecord, providerHeadersToRecord } from "../utils/headers.js";
+import { retryProviderRequest } from "../utils/provider-retry.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 export const generateImages = async (model, context, options) => {
     const output = {
@@ -25,11 +26,15 @@ export const generateImages = async (model, context, options) => {
         const requestOptions = {
             ...(options?.signal ? { signal: options.signal } : {}),
             ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
-            maxRetries: options?.maxRetries ?? 0,
+            maxRetries: 0,
         };
-        const { data: response, response: rawResponse } = await client.chat.completions
+        const { data: response, response: rawResponse } = await retryProviderRequest(() => client.chat.completions
             .create(params, requestOptions)
-            .withResponse();
+            .withResponse(), {
+            maxRetries: options?.maxRetries,
+            maxRetryDelayMs: options?.maxRetryDelayMs,
+            signal: options?.signal,
+        });
         await options?.onResponse?.({ status: rawResponse.status, headers: headersToRecord(rawResponse.headers) }, model);
         const imageResponse = response;
         output.responseId = imageResponse.id;

package/node_modules/@earendil-works/pi-ai/dist/auth/oauth/load.js

@@ -36,6 +36,11 @@ export const loadGitHubCopilotOAuth = async () => {
         return bundledLoaders.githubCopilot();
     return (await importOAuthModule("./github-copilot.ts")).githubCopilotOAuth;
 };
+export const loadOpenRouterOAuth = async () => {
+    if (bundledLoaders)
+        return bundledLoaders.openrouter();
+    return (await importOAuthModule("./openrouter.ts")).openRouterOAuth;
+};
 export const loadKimiCodingOAuth = async () => {
     if (bundledLoaders)
         return bundledLoaders.kimiCoding();