@psnext/slingcli 2.5.20260724-1 → 2.5.20260725-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 }),
             };
@@ -728,16 +729,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;
-    const bedrockTools = tools.map((tool) => ({
-        toolSpec: {
-            name: tool.name,
-            description: tool.description,
-            inputSchema: { json: tool.parameters },
-        },
-    }));
+    if (toolChoice === "none")
+        return undefined;
+    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)) {

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

@@ -16,6 +16,7 @@ import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { resolveHttpProxyUrlForTarget } from "../utils/node-http-proxy.js";
 import { uuidv7 } from "../utils/uuid.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";
@@ -34,6 +35,7 @@ const REQUEST_COMPRESSION_ZSTD_LEVEL = 3;
 const CODEX_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
 const WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE = 1009;
 const WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE = "websocket_connection_limit_reached";
+const PREVIOUS_RESPONSE_NOT_FOUND_CODE = "previous_response_not_found";
 const CODEX_RESPONSE_STATUSES = new Set([
     "completed",
     "incomplete",
@@ -79,9 +81,14 @@ function getRetryAfterDelayMs(headers) {
     }
     return undefined;
 }
-function capRetryDelayMs(delayMs, options) {
+class RetryDelayExceededError extends Error {
+}
+function validateRetryDelayMs(delayMs, options) {
     const maxRetryDelayMs = options?.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
-    return maxRetryDelayMs > 0 ? Math.min(delayMs, maxRetryDelayMs) : delayMs;
+    if (maxRetryDelayMs > 0 && delayMs > maxRetryDelayMs) {
+        throw new RetryDelayExceededError(`Server requested ${Math.ceil(delayMs / 1000)}s retry delay (max: ${Math.ceil(maxRetryDelayMs / 1000)}s)`);
+    }
+    return delayMs;
 }
 function sleep(ms, signal) {
     return new Promise((resolve, reject) => {
@@ -157,12 +164,14 @@ export const stream = (model, context, options) => {
                 throw new Error(`No API key for provider: ${model.provider}`);
             }
             const accountId = extractAccountId(apiKey);
-            let body = buildRequestBody(model, context, options);
+            const grammarToolInputProperties = createGrammarToolInputProperties(context.tools, model.compat?.supportsOpenAIGrammarTools ?? false);
+            const cacheSessionId = options?.cacheRetention === "none" ? undefined : options?.sessionId;
+            const codexSessionId = clampOpenAIPromptCacheKey(cacheSessionId);
+            let body = buildRequestBody(model, context, options, codexSessionId, grammarToolInputProperties);
             const nextBody = await options?.onPayload?.(body, model);
             if (nextBody !== undefined) {
                 body = nextBody;
             }
-            const codexSessionId = clampOpenAIPromptCacheKey(options?.sessionId);
             const websocketRequestId = codexSessionId || uuidv7();
             const sseHeaders = buildSSEHeaders(model.headers, options?.headers, accountId, apiKey, codexSessionId);
             const websocketHeaders = buildWebSocketHeaders(model.headers, options?.headers, accountId, apiKey, websocketRequestId);
@@ -170,19 +179,25 @@ export const stream = (model, context, options) => {
             const httpTimeoutMs = normalizeTimeoutMs(options?.timeoutMs);
             const websocketConnectTimeoutMs = normalizeTimeoutMs(options?.websocketConnectTimeoutMs);
             const transport = options?.transport || "auto";
-            const websocketDisabledForSession = transport !== "sse" && isWebSocketSseFallbackActive(options?.sessionId);
+            let startEmitted = false;
+            const websocketDisabledForSession = transport !== "sse" && isWebSocketSseFallbackActive(cacheSessionId);
             if (websocketDisabledForSession) {
-                recordWebSocketSseFallback(options?.sessionId);
+                recordWebSocketSseFallback(cacheSessionId);
             }
             if (transport !== "sse" && !websocketDisabledForSession) {
                 let websocketStarted = false;
                 let retriedWebSocketConnectionLimit = false;
+                let retriedMissingWebSocketContinuation = false;
                 while (true) {
                     websocketStarted = false;
                     try {
                         await processWebSocketStream(resolveCodexWebSocketUrl(model.baseUrl), body, websocketHeaders, output, stream, model, () => {
                             websocketStarted = true;
-                        }, httpTimeoutMs, websocketConnectTimeoutMs, options);
+                            if (!startEmitted) {
+                                startEmitted = true;
+                                stream.push({ type: "start", partial: output });
+                            }
+                        }, httpTimeoutMs, websocketConnectTimeoutMs, cacheSessionId, grammarToolInputProperties, options);
                         if (options?.signal?.aborted) {
                             throw new Error("Request was aborted");
                         }
@@ -197,6 +212,11 @@ export const stream = (model, context, options) => {
                     catch (error) {
                         const aborted = options?.signal?.aborted;
                         const connectionLimitBeforeStart = !websocketStarted && isWebSocketConnectionLimitReachedError(error);
+                        const previousResponseNotFound = isPreviousResponseNotFoundError(error);
+                        if (!aborted && previousResponseNotFound && !retriedMissingWebSocketContinuation) {
+                            retriedMissingWebSocketContinuation = true;
+                            continue;
+                        }
                         if (!aborted && connectionLimitBeforeStart && !retriedWebSocketConnectionLimit) {
                             retriedWebSocketConnectionLimit = true;
                             continue;
@@ -211,11 +231,11 @@ export const stream = (model, context, options) => {
                             phase: websocketStarted ? "after_message_stream_start" : "before_message_stream_start",
                             requestBytes: new TextEncoder().encode(bodyJson).byteLength,
                         }));
-                        recordWebSocketFailure(options?.sessionId, error);
+                        recordWebSocketFailure(cacheSessionId, error);
                         if (websocketStarted) {
                             throw error;
                         }
-                        recordWebSocketSseFallback(options?.sessionId);
+                        recordWebSocketSseFallback(cacheSessionId);
                         break;
                     }
                 }
@@ -265,9 +285,7 @@ export const stream = (model, context, options) => {
                         const retryAfterDelayMs = getRetryAfterDelayMs(response.headers);
                         const delayMs = retryAfterDelayMs === undefined
                             ? BASE_DELAY_MS * 2 ** attempt
-                            : response.status === 429
-                                ? capRetryDelayMs(retryAfterDelayMs, options)
-                                : retryAfterDelayMs;
+                            : validateRetryDelayMs(retryAfterDelayMs, options);
                         await sleep(delayMs, options?.signal);
                         continue;
                     }
@@ -287,7 +305,9 @@ export const stream = (model, context, options) => {
                     }
                     lastError = error instanceof Error ? error : new Error(String(error));
                     // Network errors are retryable
-                    if (attempt < maxRetries && !lastError.message.includes("usage limit")) {
+                    if (attempt < maxRetries &&
+                        !(lastError instanceof RetryDelayExceededError) &&
+                        !lastError.message.includes("usage limit")) {
                         const delayMs = BASE_DELAY_MS * 2 ** attempt;
                         await sleep(delayMs, options?.signal);
                         continue;
@@ -301,8 +321,11 @@ export const stream = (model, context, options) => {
             if (!response.body) {
                 throw new Error("No response body");
             }
-            stream.push({ type: "start", partial: output });
-            await processStream(response, output, stream, model, options);
+            if (!startEmitted) {
+                startEmitted = true;
+                stream.push({ type: "start", partial: output });
+            }
+            await processStream(response, output, stream, model, grammarToolInputProperties, options);
             if (options?.signal?.aborted) {
                 throw new Error("Request was aborted");
             }
@@ -311,8 +334,9 @@ export const stream = (model, context, options) => {
         }
         catch (error) {
             for (const block of output.content) {
-                // 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 = formatProviderError(normalizeProviderError(error));
@@ -338,11 +362,19 @@ export const streamSimple = (model, context, options) => {
 // ============================================================================
 // Request Building
 // ============================================================================
-function buildRequestBody(model, context, options) {
+function buildRequestBody(model, context, options, cacheSessionId, grammarToolInputProperties = createGrammarToolInputProperties(context.tools, model.compat?.supportsOpenAIGrammarTools ?? false)) {
+    const supportsStrictMode = model.compat?.supportsStrictMode ?? true;
+    const supportsOpenAIGrammarTools = model.compat?.supportsOpenAIGrammarTools ?? false;
     const toolPlacement = splitDeferredTools(context, model.compat?.supportsToolSearch ?? false);
     const messages = convertResponsesMessages(model, context, CODEX_TOOL_CALL_PROVIDERS, {
         includeSystemPrompt: false,
+        grammarToolInputProperties,
         deferredTools: toolPlacement.deferred,
+        toolOptions: {
+            strict: null,
+            supportsStrictMode,
+            supportsOpenAIGrammarTools,
+        },
     });
     const body = {
         model: model.id,
@@ -352,7 +384,7 @@ function buildRequestBody(model, context, options) {
         input: messages,
         text: { verbosity: options?.textVerbosity || "low" },
         include: ["reasoning.encrypted_content"],
-        prompt_cache_key: clampOpenAIPromptCacheKey(options?.sessionId),
+        prompt_cache_key: cacheSessionId,
         tool_choice: options?.toolChoice ?? "auto",
         parallel_tool_calls: true,
     };
@@ -363,7 +395,11 @@ function buildRequestBody(model, context, options) {
         body.service_tier = options.serviceTier;
     }
     if (toolPlacement.immediate.length > 0) {
-        body.tools = convertResponsesTools(toolPlacement.immediate, { strict: null });
+        body.tools = convertResponsesTools(toolPlacement.immediate, {
+            strict: null,
+            supportsStrictMode,
+            supportsOpenAIGrammarTools,
+        });
     }
     if (options?.reasoningEffort !== undefined) {
         const effort = options.reasoningEffort === "none"
@@ -424,9 +460,10 @@ function resolveCodexWebSocketUrl(baseUrl) {
 // ============================================================================
 // Response Processing
 // ============================================================================
-async function processStream(response, output, stream, model, options) {
+async function processStream(response, output, stream, model, grammarToolInputProperties, options) {
     await processResponsesStream(mapCodexEvents(parseSSE(response, options?.signal)), output, stream, model, {
         serviceTier: options?.serviceTier,
+        grammarToolInputProperties,
         resolveServiceTier: resolveCodexServiceTier,
         applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model),
     });
@@ -457,6 +494,9 @@ function isCodexNonTransportError(error) {
 function isWebSocketConnectionLimitReachedError(error) {
     return error instanceof CodexApiError && error.code === WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE;
 }
+function isPreviousResponseNotFoundError(error) {
+    return error instanceof CodexApiError && error.code === PREVIOUS_RESPONSE_NOT_FOUND_CODE;
+}
 function extractCodexEventError(event) {
     const nested = event.error && typeof event.error === "object" ? event.error : undefined;
     return {
@@ -1062,26 +1102,25 @@ function buildCachedWebSocketRequestBody(entry, body) {
         input: delta,
     };
 }
-async function* startWebSocketOutputOnFirstEvent(events, output, stream, onStart) {
+async function* startWebSocketOutputOnFirstEvent(events, onStart) {
     let started = false;
     for await (const event of events) {
         if (!started) {
             started = true;
             onStart();
-            stream.push({ type: "start", partial: output });
         }
         yield event;
     }
 }
-async function processWebSocketStream(url, body, headers, output, stream, model, onStart, idleTimeoutMs, websocketConnectTimeoutMs, options) {
-    const { socket, entry, reused, release } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal, websocketConnectTimeoutMs, options?.env);
+async function processWebSocketStream(url, body, headers, output, stream, model, onStart, idleTimeoutMs, websocketConnectTimeoutMs, cacheSessionId, grammarToolInputProperties, options) {
+    const { socket, entry, reused, release } = await acquireWebSocket(url, headers, cacheSessionId, options?.signal, websocketConnectTimeoutMs, options?.env);
     let keepConnection = true;
     const useCachedContext = options?.transport === "websocket-cached" || options?.transport === "auto";
     // ChatGPT Codex Responses rejects `store: true` ("Store must be set to false").
     // WebSocket continuation still works via connection-scoped previous_response_id state.
     const fullBody = body;
     const requestBody = useCachedContext && entry ? buildCachedWebSocketRequestBody(entry, fullBody) : fullBody;
-    const stats = options?.sessionId ? getOrCreateWebSocketDebugStats(options.sessionId) : undefined;
+    const stats = cacheSessionId ? getOrCreateWebSocketDebugStats(cacheSessionId) : undefined;
     if (stats) {
         stats.requests++;
         if (reused)
@@ -1106,8 +1145,9 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
     }
     try {
         socket.send(JSON.stringify({ type: "response.create", ...requestBody }));
-        await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal, idleTimeoutMs)), output, stream, onStart), output, stream, model, {
+        await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal, idleTimeoutMs)), onStart), output, stream, model, {
             serviceTier: options?.serviceTier,
+            grammarToolInputProperties,
             resolveServiceTier: resolveCodexServiceTier,
             applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model),
         });
@@ -1117,7 +1157,8 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
         else if (useCachedContext && entry && output.responseId) {
             const responseItems = convertResponsesMessages(model, { messages: [output] }, CODEX_TOOL_CALL_PROVIDERS, {
                 includeSystemPrompt: false,
-            }).filter((item) => item.type !== "function_call_output");
+                grammarToolInputProperties,
+            }).filter((item) => item.type !== "function_call_output" && item.type !== "custom_tool_call_output");
             entry.continuation = {
                 lastRequestBody: fullBody,
                 lastResponseId: output.responseId,