@psnext/slingcli 2.5.20260724-1 → 2.5.20260727-1

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

@@ -4,6 +4,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 { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
 import { buildBaseOptions } from "./simple-options.js";
@@ -68,7 +70,8 @@ export const stream = (model, context, options) => {
                 throw new Error(`No API key for provider: ${model.provider}`);
             }
             const client = createClient(model, apiKey, options);
-            let params = buildParams(model, context, options, deploymentName);
+            const grammarToolInputProperties = createGrammarToolInputProperties(context.tools, model.compat?.supportsOpenAIGrammarTools ?? false);
+            let params = buildParams(model, context, options, deploymentName, grammarToolInputProperties);
             const nextParams = await options?.onPayload?.(params, model);
             if (nextParams !== undefined) {
                 params = nextParams;
@@ -76,12 +79,16 @@ 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);
+            await processResponsesStream(openaiStream, output, stream, model, { grammarToolInputProperties });
             if (options?.signal?.aborted) {
                 throw new Error("Request was aborted");
             }
@@ -94,8 +101,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 = formatAzureOpenAIError(error);
@@ -181,8 +189,10 @@ function createClient(model, apiKey, options) {
         baseURL: baseUrl,
     });
 }
-function buildParams(model, context, options, deploymentName) {
-    const messages = convertResponsesMessages(model, context, AZURE_TOOL_CALL_PROVIDERS);
+function buildParams(model, context, options, deploymentName, grammarToolInputProperties = createGrammarToolInputProperties(context.tools, model.compat?.supportsOpenAIGrammarTools ?? false)) {
+    const messages = convertResponsesMessages(model, context, AZURE_TOOL_CALL_PROVIDERS, {
+        grammarToolInputProperties,
+    });
     const params = {
         model: deploymentName,
         input: messages,
@@ -197,7 +207,10 @@ function buildParams(model, context, options, deploymentName) {
         params.temperature = options?.temperature;
     }
     if (context.tools && context.tools.length > 0) {
-        params.tools = convertResponsesTools(context.tools);
+        params.tools = convertResponsesTools(context.tools, {
+            supportsStrictMode: model.compat?.supportsStrictMode ?? true,
+            supportsOpenAIGrammarTools: model.compat?.supportsOpenAIGrammarTools ?? false,
+        });
     }
     if (model.reasoning) {
         if (options?.reasoningEffort || options?.reasoningSummary) {

package/node_modules/@earendil-works/pi-ai/dist/api/bedrock-converse-stream.js

@@ -10,6 +10,7 @@ import { parseStreamingJson } from "../utils/json-parse.js";
 import { resolveHttpProxyUrlForTarget } from "../utils/node-http-proxy.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
+import { resolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
 import { adjustMaxTokensForThinking, buildBaseOptions, clampMaxTokensToContext, clampReasoning, } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
 const EMPTY_TEXT_PLACEHOLDER = "<empty>";
@@ -124,7 +125,7 @@ export const stream = (model, context, options = {}) => {
                     ...(inferenceMaxTokens !== undefined && { maxTokens: inferenceMaxTokens }),
                     ...(options.temperature !== undefined && { temperature: options.temperature }),
                 },
-                toolConfig: convertToolConfig(context.tools, options.toolChoice),
+                toolConfig: convertToolConfig(context.tools, options.toolChoice, model.compat?.supportsStrictMode ?? false),
                 additionalModelRequestFields: buildAdditionalModelRequestFields(model, options),
                 ...(options.requestMetadata !== undefined && { requestMetadata: options.requestMetadata }),
             };
@@ -431,13 +432,18 @@ function supportsAdaptiveThinking(modelId, modelName) {
     return candidates.some((s) => s.includes("opus-4-6") ||
         s.includes("opus-4-7") ||
         s.includes("opus-4-8") ||
+        s.includes("opus-5") ||
         s.includes("sonnet-4-6") ||
         s.includes("sonnet-5") ||
         s.includes("fable-5"));
 }
 function supportsNativeXhighEffort(model) {
     const candidates = getModelMatchCandidates(model.id, model.name);
-    return candidates.some((s) => s.includes("opus-4-7") || s.includes("opus-4-8") || s.includes("sonnet-5") || s.includes("fable-5"));
+    return candidates.some((s) => s.includes("opus-4-7") ||
+        s.includes("opus-4-8") ||
+        s.includes("opus-5") ||
+        s.includes("sonnet-5") ||
+        s.includes("fable-5"));
 }
 function mapThinkingLevelToEffort(model, level) {
     if (level === "xhigh" && supportsNativeXhighEffort(model))
@@ -506,8 +512,8 @@ function supportsPromptCaching(model, env) {
             return true;
         return false;
     }
-    // Claude 5 models (fable-5, sonnet-5)
-    if (candidates.some((s) => s.includes("fable-5") || s.includes("sonnet-5")))
+    // Claude 5 models (fable-5, opus-5, sonnet-5)
+    if (candidates.some((s) => s.includes("fable-5") || s.includes("opus-5") || s.includes("sonnet-5")))
         return true;
     // Claude 4.x models (opus-4, sonnet-4, haiku-4)
     if (candidates.some((s) => s.includes("-4-")))
@@ -728,16 +734,22 @@ function convertMessages(context, model, cacheRetention, env) {
     }
     return result;
 }
-function convertToolConfig(tools, toolChoice) {
-    if (!tools?.length || toolChoice === "none")
+function convertToolConfig(tools, toolChoice, supportsStrictMode) {
+    if (!tools?.length)
+        return undefined;
+    if (toolChoice === "none")
         return undefined;
-    const bedrockTools = tools.map((tool) => ({
-        toolSpec: {
-            name: tool.name,
-            description: tool.description,
-            inputSchema: { json: tool.parameters },
-        },
-    }));
+    const bedrockTools = tools.map((tool) => {
+        const strict = resolveJsonSchemaStrictSampling(tool, supportsStrictMode);
+        return {
+            toolSpec: {
+                name: tool.name,
+                description: tool.description,
+                inputSchema: { json: tool.parameters },
+                ...(strict === true ? { strict: true } : {}),
+            },
+        };
+    });
     let bedrockToolChoice;
     switch (toolChoice) {
         case "auto":

package/node_modules/@earendil-works/pi-ai/dist/api/constrained-sampling.js

@@ -0,0 +1,100 @@
+export function getGrammarToolInput(toolName, arguments_, inputProperty) {
+    const input = arguments_[inputProperty];
+    if (typeof input !== "string") {
+        throw new Error(`Grammar tool call "${toolName}" requires argument "${inputProperty}" to be a string.`);
+    }
+    return input;
+}
+export function appendGrammarToolInputJsonDelta(buffer, inputProperty, nextInput, close) {
+    if (buffer.closed) {
+        if (close && nextInput === buffer.input)
+            return undefined;
+        throw new Error(`grammar tool input for property "${inputProperty}" changed after it was closed`);
+    }
+    if (!nextInput.startsWith(buffer.input)) {
+        throw new Error(`grammar tool input for property "${inputProperty}" changed non-monotonically`);
+    }
+    const inputDelta = nextInput.slice(buffer.input.length);
+    if (!close && inputDelta.length === 0)
+        return undefined;
+    let delta = "";
+    if (!buffer.started) {
+        delta += `{${JSON.stringify(inputProperty)}:"`;
+        buffer.started = true;
+    }
+    delta += JSON.stringify(inputDelta).slice(1, -1);
+    buffer.input = nextInput;
+    if (close) {
+        delta += '"}';
+        buffer.closed = true;
+    }
+    return delta;
+}
+function inferGrammarInputProperty(tool) {
+    const schema = tool.parameters;
+    if (schema.type !== "object") {
+        throw new Error("grammar constrained sampling requires an object parameter schema");
+    }
+    if (!Array.isArray(schema.required) || schema.required.length !== 1 || typeof schema.required[0] !== "string") {
+        throw new Error("grammar constrained sampling requires exactly one required string property");
+    }
+    const inputProperty = schema.required[0];
+    if (!schema.properties?.[inputProperty]) {
+        throw new Error(`grammar constrained sampling requires a properties entry for ${inputProperty}`);
+    }
+    if (schema.properties[inputProperty]?.type !== "string") {
+        throw new Error(`grammar constrained sampling property ${inputProperty} must have type string`);
+    }
+    return inputProperty;
+}
+export function resolveJsonSchemaStrictSampling(tool, supportsStrictMode) {
+    const config = tool.constrainedSampling;
+    if (!config || config.type !== "json_schema") {
+        return undefined;
+    }
+    if (supportsStrictMode) {
+        return true;
+    }
+    if (config.strict === "require") {
+        throw new Error(`Tool "${tool.name}" requires JSON-schema constrained sampling, but strict tools are unsupported.`);
+    }
+    return undefined;
+}
+export function resolveGrammarConstrainedSampling(tool, supportsOpenAIGrammarTools) {
+    const config = tool.constrainedSampling;
+    if (!config || config.type !== "grammar") {
+        return undefined;
+    }
+    if (!supportsOpenAIGrammarTools) {
+        return undefined;
+    }
+    const larkDefinition = config.variants.openai_lark;
+    const regexDefinition = config.variants.openai_regex;
+    const hasLarkDefinition = typeof larkDefinition === "string" && larkDefinition.trim().length > 0;
+    const hasRegexDefinition = typeof regexDefinition === "string" && regexDefinition.trim().length > 0;
+    if (!hasLarkDefinition && !hasRegexDefinition) {
+        throw new Error(`Tool "${tool.name}" cannot use grammar constrained sampling: no supported grammar variant was provided.`);
+    }
+    try {
+        return {
+            format: hasLarkDefinition ? "lark" : "regex",
+            definition: hasLarkDefinition ? larkDefinition : regexDefinition,
+            inputProperty: inferGrammarInputProperty(tool),
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Tool "${tool.name}" cannot use grammar constrained sampling: ${message}.`);
+    }
+}
+export function createGrammarToolInputProperties(tools, supportsOpenAIGrammarTools) {
+    const properties = new Map();
+    for (const tool of tools ?? []) {
+        const grammar = resolveGrammarConstrainedSampling(tool, supportsOpenAIGrammarTools);
+        if (grammar) {
+            properties.set(tool.name, grammar.inputProperty);
+        }
+    }
+    return properties;
+}
+//# sourceMappingURL=constrained-sampling.js.map

package/node_modules/@earendil-works/pi-ai/dist/api/google-generative-ai.js

@@ -4,7 +4,7 @@ import { formatProviderError, normalizeProviderError } from "../utils/error-body
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { providerHeadersToRecord } from "../utils/headers.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
-import { convertMessages, convertTools, isThinkingPart, mapStopReason, mapToolChoice, retainThoughtSignature, } from "./google-shared.js";
+import { convertMessages, convertTools, isThinkingPart, mapStopReason, resolveGoogleFunctionCallingMode, retainThoughtSignature, supportsGoogleStrictToolSampling, } from "./google-shared.js";
 import { buildBaseOptions } from "./simple-options.js";
 // Counter for generating unique tool call IDs
 let toolCallCounter = 0;
@@ -271,21 +271,17 @@ function buildParams(model, context, options = {}) {
     if (options.maxTokens !== undefined) {
         generationConfig.maxOutputTokens = options.maxTokens;
     }
+    const functionCallingMode = context.tools?.length
+        ? resolveGoogleFunctionCallingMode(context.tools, options.toolChoice, supportsGoogleStrictToolSampling(model.id))
+        : undefined;
     const config = {
         ...(Object.keys(generationConfig).length > 0 && generationConfig),
         ...(context.systemPrompt && { systemInstruction: sanitizeSurrogates(context.systemPrompt) }),
         ...(context.tools && context.tools.length > 0 && { tools: convertTools(context.tools) }),
+        ...(functionCallingMode !== undefined && {
+            toolConfig: { functionCallingConfig: { mode: functionCallingMode } },
+        }),
     };
-    if (context.tools && context.tools.length > 0 && options.toolChoice) {
-        config.toolConfig = {
-            functionCallingConfig: {
-                mode: mapToolChoice(options.toolChoice),
-            },
-        };
-    }
-    else {
-        config.toolConfig = undefined;
-    }
     if (options.thinking?.enabled && model.reasoning) {
         const thinkingConfig = { includeThoughts: true };
         if (options.thinking.level !== undefined) {

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

@@ -3,6 +3,7 @@
  */
 import { FinishReason, FunctionCallingConfigMode } from "@google/genai";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
+import { resolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
 import { transformMessages } from "./transform-messages.js";
 /**
  * Determines whether a streamed Gemini `Part` should be treated as "thinking".
@@ -267,9 +268,12 @@ export function convertTools(tools, useParameters = false) {
         },
     ];
 }
-/**
- * Map tool choice string to Gemini FunctionCallingConfigMode.
- */
+/** Gemini 3+ enforces required function parameters in validated tool-calling modes. */
+export function supportsGoogleStrictToolSampling(modelId) {
+    const majorVersion = getGeminiMajorVersion(modelId);
+    return majorVersion !== undefined && majorVersion >= 3;
+}
+/** Map tool choice string to Gemini FunctionCallingConfigMode. */
 export function mapToolChoice(choice) {
     switch (choice) {
         case "auto":
@@ -282,6 +286,16 @@ export function mapToolChoice(choice) {
             return FunctionCallingConfigMode.AUTO;
     }
 }
+export function resolveGoogleFunctionCallingMode(tools, toolChoice, supportsStrictMode) {
+    const useStrictMode = tools.some((tool) => resolveJsonSchemaStrictSampling(tool, supportsStrictMode) === true);
+    if (toolChoice === "none" || toolChoice === "any") {
+        return mapToolChoice(toolChoice);
+    }
+    if (useStrictMode) {
+        return FunctionCallingConfigMode.VALIDATED;
+    }
+    return toolChoice ? mapToolChoice(toolChoice) : undefined;
+}
 /**
  * Map Gemini FinishReason to our StopReason.
  */

package/node_modules/@earendil-works/pi-ai/dist/api/google-vertex.js

@@ -5,7 +5,7 @@ import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { providerHeadersToRecord } from "../utils/headers.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
-import { convertMessages, convertTools, isThinkingPart, mapStopReason, mapToolChoice, retainThoughtSignature, } from "./google-shared.js";
+import { convertMessages, convertTools, isThinkingPart, mapStopReason, resolveGoogleFunctionCallingMode, retainThoughtSignature, supportsGoogleStrictToolSampling, } from "./google-shared.js";
 import { buildBaseOptions } from "./simple-options.js";
 const API_VERSION = "v1";
 const GCP_VERTEX_CREDENTIALS_MARKER = "gcp-vertex-credentials";
@@ -345,21 +345,17 @@ function buildParams(model, context, options = {}) {
     if (options.maxTokens !== undefined) {
         generationConfig.maxOutputTokens = options.maxTokens;
     }
+    const functionCallingMode = context.tools?.length
+        ? resolveGoogleFunctionCallingMode(context.tools, options.toolChoice, supportsGoogleStrictToolSampling(model.id))
+        : undefined;
     const config = {
         ...(Object.keys(generationConfig).length > 0 && generationConfig),
         ...(context.systemPrompt && { systemInstruction: sanitizeSurrogates(context.systemPrompt) }),
         ...(context.tools && context.tools.length > 0 && { tools: convertTools(context.tools) }),
+        ...(functionCallingMode !== undefined && {
+            toolConfig: { functionCallingConfig: { mode: functionCallingMode } },
+        }),
     };
-    if (context.tools && context.tools.length > 0 && options.toolChoice) {
-        config.toolConfig = {
-            functionCallingConfig: {
-                mode: mapToolChoice(options.toolChoice),
-            },
-        };
-    }
-    else {
-        config.toolConfig = undefined;
-    }
     if (options.thinking?.enabled && model.reasoning) {
         const thinkingConfig = { includeThoughts: true };
         if (options.thinking.level !== undefined) {

package/node_modules/@earendil-works/pi-ai/dist/api/mistral-conversations.js

@@ -4,6 +4,7 @@ import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { shortHash } from "../utils/hash.js";
 import { parseStreamingJson } from "../utils/json-parse.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
+import { resolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
 import { buildBaseOptions } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
 const MISTRAL_TOOL_CALL_ID_LENGTH = 9;
@@ -389,15 +390,18 @@ async function consumeChatStream(model, output, stream, mistralStream) {
     }
 }
 function toFunctionTools(tools) {
-    return tools.map((tool) => ({
-        type: "function",
-        function: {
-            name: tool.name,
-            description: tool.description,
-            parameters: stripSymbolKeys(tool.parameters),
-            strict: false,
-        },
-    }));
+    return tools.map((tool) => {
+        const strict = resolveJsonSchemaStrictSampling(tool, true);
+        return {
+            type: "function",
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: stripSymbolKeys(tool.parameters),
+                strict: strict ?? false,
+            },
+        };
+    });
 }
 function stripSymbolKeys(value) {
     if (Array.isArray(value)) {