@jsonstudio/llms 0.6.3271 → 0.6.3379

package/dist/conversion/shared/tooling.js

@@ -2,7 +2,16 @@
  * Shared helpers for standard tool normalization (shell packing rules).
  * The goal is deterministic, minimal shaping so executors succeed consistently.
  */
-import { parseLenientJsonishWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { chunkStringWithNative, flattenByCommaWithNative, packShellArgsWithNative, repairFindMetaWithNative, splitCommandStringWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+function assertToolingNativeAvailable() {
+    if (typeof repairFindMetaWithNative !== 'function' ||
+        typeof splitCommandStringWithNative !== 'function' ||
+        typeof packShellArgsWithNative !== 'function' ||
+        typeof flattenByCommaWithNative !== 'function' ||
+        typeof chunkStringWithNative !== 'function') {
+        throw new Error('[tooling] native bindings unavailable');
+    }
+}
 // We intentionally do NOT evaluate shell control operators (&&, |, etc.).
 // Codex CLI executor runs argv directly (execvp-like), not through a shell.
 // So we avoid wrapping with "bash -lc" and leave such tokens as-is.
@@ -13,103 +22,12 @@ import { parseLenientJsonishWithNative } from '../../router/virtual-router/engin
  * - escape bare parentheses used in predicates: `(` / `)` → `\(` / `\)`
  */
 export function repairFindMeta(script) {
-    try {
-        const s = String(script ?? '');
-        if (!s)
-            return s;
-        const hasFind = /(^|\s)find\s/.test(s);
-        if (!hasFind)
-            return s;
-        let out = s;
-        // Only escape semicolon not already escaped (negative lookbehind)
-        out = out.replace(/-exec([^;]*?)(?<!\\);/g, (_m, g1) => `-exec${g1} \\;`);
-        // Collapse multiple backslashes immediately before ; into a single backslash
-        out = out.replace(/-exec([^;]*?)\\+;/g, (_m, g1) => `-exec${g1} \\;`);
-        // Escape parentheses only when not already escaped
-        out = out.replace(/(?<!\\)\(/g, '\\(').replace(/(?<!\\)\)/g, '\\)');
-        return out;
-    }
-    catch {
-        return script;
-    }
-}
-function toStringArray(v) {
-    if (Array.isArray(v))
-        return v.map((x) => String(x));
-    if (typeof v === 'string')
-        return [v];
-    if (v == null)
-        return [];
-    return [String(v)];
+    assertToolingNativeAvailable();
+    return repairFindMetaWithNative(script ?? '');
 }
 export function splitCommandString(input) {
-    const s = input.trim();
-    if (!s)
-        return [];
-    try {
-        if (s.startsWith('{') || s.startsWith('[')) {
-            const parsed = parseLenientJsonishWithNative(s);
-            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-                const command = parsed.command;
-                if (Array.isArray(command)) {
-                    const tokens = command.map((entry) => String(entry ?? '')).map((entry) => entry.trim()).filter(Boolean);
-                    if (tokens.length) {
-                        return tokens;
-                    }
-                }
-            }
-        }
-    }
-    catch {
-        // Keep legacy parser path when native parse returns non-command payload.
-    }
-    const out = [];
-    let cur = '';
-    let inSingle = false;
-    let inDouble = false;
-    for (let i = 0; i < s.length; i++) {
-        const ch = s[i];
-        if (inSingle) {
-            if (ch === "'") {
-                inSingle = false;
-                continue;
-            }
-            cur += ch;
-            continue;
-        }
-        if (inDouble) {
-            if (ch === '"') {
-                inDouble = false;
-                continue;
-            }
-            if (ch === '\\' && i + 1 < s.length) { // simple escape in double quotes
-                i++;
-                cur += s[i];
-                continue;
-            }
-            cur += ch;
-            continue;
-        }
-        if (ch === "'") {
-            inSingle = true;
-            continue;
-        }
-        if (ch === '"') {
-            inDouble = true;
-            continue;
-        }
-        if (/\s/.test(ch)) {
-            if (cur) {
-                out.push(cur);
-                cur = '';
-            }
-            continue;
-        }
-        cur += ch;
-    }
-    if (cur)
-        out.push(cur);
-    return out;
+    assertToolingNativeAvailable();
+    return splitCommandStringWithNative(input ?? '');
 }
 /**
  * Pack shell arguments per unified rules:
@@ -125,64 +43,15 @@ export function splitCommandString(input) {
  * - join(rest) uses single-space join without extra quoting
  */
 export function packShellArgs(input) {
-    const out = { ...input };
-    const cmdRaw = out.command;
-    const workdir = out.workdir;
-    // string => split into argv tokens (no shell wrapping)
-    if (typeof cmdRaw === 'string') {
-        const tokens = splitCommandString(cmdRaw);
-        // handle leading cd as cwd switch
-        if (tokens[0] === 'cd' && typeof tokens[1] === 'string' && tokens[1]) {
-            const dir = tokens[1];
-            let rest = tokens.slice(2);
-            // tolerate common chain operator right after cd
-            if (rest[0] === '&&' || rest[0] === ';') {
-                rest = rest.slice(1);
-            }
-            if (!workdir)
-                out.workdir = dir;
-            out.command = rest.length ? rest : ['pwd'];
-            return out;
-        }
-        out.command = tokens.length ? tokens : ['pwd'];
-        if (typeof workdir === 'string' && workdir)
-            out.workdir = workdir;
-        return out;
-    }
-    // array tokens
-    const tokens = toStringArray(cmdRaw);
-    if (tokens.length === 0) {
-        out.command = ['pwd'];
-        if (typeof workdir === 'string' && workdir)
-            out.workdir = workdir;
-        return out;
-    }
-    // cd chain for argv input
-    if (tokens[0] === 'cd' && typeof tokens[1] === 'string' && tokens[1]) {
-        const dir = tokens[1];
-        const rest = tokens.slice(2);
-        if (!workdir)
-            out.workdir = dir;
-        out.command = rest.length ? rest : ['pwd'];
-        return out;
-    }
-    // argv straight
-    out.command = tokens;
-    if (typeof workdir === 'string' && workdir)
-        out.workdir = workdir;
-    return out;
+    assertToolingNativeAvailable();
+    return packShellArgsWithNative(input);
 }
 export function flattenByComma(arr) {
-    return arr.flatMap((t) => String(t).split(',').map(s => s.trim()).filter(Boolean));
+    assertToolingNativeAvailable();
+    return flattenByCommaWithNative(arr);
 }
 // Helper to chunk a long string into N parts (bounded)
 export function chunkString(s, minParts = 3, maxParts = 12, targetChunk = 12) {
-    if (typeof s !== 'string' || !s.length)
-        return [];
-    const parts = Math.max(minParts, Math.min(maxParts, Math.ceil(s.length / targetChunk)));
-    const step = Math.max(1, Math.ceil(s.length / parts));
-    const out = [];
-    for (let i = 0; i < s.length; i += step)
-        out.push(s.slice(i, i + step));
-    return out;
+    assertToolingNativeAvailable();
+    return chunkStringWithNative(s, minParts, maxParts, targetChunk);
 }

package/dist/filters/special/response-tool-arguments-stringify.js

@@ -82,7 +82,7 @@ export class ResponseToolArgumentsStringifyFilter {
                                     fn.arguments = '{}';
                                 }
                             }
-                            else if ((name === 'exec_command' || name === 'shell_command' || name === 'bash') && isObject(parsed)) {
+                            else if (name === 'exec_command' && isObject(parsed)) {
                                 const normalized = normalizeExecCommandArgs(parsed);
                                 const next = normalized.ok ? normalized.normalized : parsed;
                                 try {
@@ -92,6 +92,14 @@ export class ResponseToolArgumentsStringifyFilter {
                                     fn.arguments = '{}';
                                 }
                             }
+                            else if ((name === 'shell_command' || name === 'bash') && isObject(parsed)) {
+                                try {
+                                    fn.arguments = JSON.stringify(parsed ?? {});
+                                }
+                                catch {
+                                    fn.arguments = '{}';
+                                }
+                            }
                             else {
                                 if (typeof argIn !== 'string') {
                                     try {

package/dist/guidance/index.js

@@ -67,7 +67,7 @@ function buildApplyPatchGuidanceText() {
         '*** End Patch',
         '```',
         '',
-        'Paths must stay relative to the workspace root (no leading "/" or drive letters).'
+        'Paths must be workspace-relative ONLY (no leading "/" or drive letters). Absolute paths will be rejected by the sandbox.'
     ].join('\n');
     return { marker, text };
 }
@@ -127,7 +127,7 @@ function augmentApplyPatch(fn) {
     const props = params.properties;
     props.patch = {
         type: 'string',
-        description: 'Patch text. Supports "*** Begin Patch" format or GNU unified diff. Paths must be workspace-relative.'
+        description: 'Patch text. Supports "*** Begin Patch" format or GNU unified diff. Paths must be workspace-relative (absolute paths are rejected).'
     };
     props.input = {
         type: 'string',

package/dist/router/virtual-router/engine-legacy/helpers.js

@@ -91,7 +91,7 @@ export function hasLatestUserRoutingInstructionMarker(messages) {
             continue;
         }
         if (message.role !== 'user') {
-            return false;
+            continue;
         }
         const content = extractMessageText(message);
         if (!content) {

package/dist/router/virtual-router/engine-selection/native-hub-bridge-action-semantics.d.ts

@@ -58,6 +58,30 @@ export interface NativeApplyBridgeEnsureToolPlaceholdersOutput {
     messages: unknown[];
     toolOutputs?: Array<Record<string, unknown>>;
 }
+export interface NativeBridgeInputToChatInput {
+    input: unknown[];
+    tools?: Array<Record<string, unknown>>;
+    toolResultFallbackText?: string;
+    normalizeFunctionName?: string;
+}
+export interface NativeBridgeInputToChatOutput {
+    messages: Array<Record<string, unknown>>;
+}
+export interface NativeCoerceBridgeRoleInput {
+    role: unknown;
+}
+export interface NativeSerializeToolArgumentsInput {
+    args?: unknown;
+}
+export interface NativeSerializeToolOutputInput {
+    output?: unknown;
+}
+export interface NativeEnsureMessagesArrayInput {
+    state?: unknown;
+}
+export interface NativeEnsureMessagesArrayOutput {
+    messages: Array<Record<string, unknown>>;
+}
 export interface NativeEnsureBridgeOutputFieldsInput {
     messages: unknown[];
     toolFallback?: string;
@@ -137,12 +161,27 @@ export interface NativeNormalizeMessageReasoningToolsOutput {
     toolCallsAdded: number;
     cleanedReasoning?: string;
 }
+export interface NativeHarvestToolsInput {
+    signal: Record<string, unknown>;
+    context?: Record<string, unknown>;
+}
+export interface NativeHarvestToolsOutput {
+    deltaEvents: Array<Record<string, unknown>>;
+    normalized?: Record<string, unknown>;
+    stats?: Record<string, unknown>;
+}
 export declare function normalizeBridgeToolCallIdsWithNative(input: NativeBridgeToolCallIdsInput): NativeBridgeToolCallIdsOutput;
 export declare function applyBridgeNormalizeToolIdentifiersWithNative(input: NativeApplyBridgeNormalizeToolIdentifiersInput): NativeBridgeToolCallIdsOutput;
 export declare function buildBridgeHistoryWithNative(input: NativeBridgeHistoryInput): NativeBridgeHistoryOutput;
 export declare function applyBridgeNormalizeHistoryWithNative(input: NativeApplyBridgeNormalizeHistoryInput): NativeApplyBridgeNormalizeHistoryOutput;
 export declare function applyBridgeCaptureToolResultsWithNative(input: NativeApplyBridgeCaptureToolResultsInput): NativeApplyBridgeCaptureToolResultsOutput;
 export declare function applyBridgeEnsureToolPlaceholdersWithNative(input: NativeApplyBridgeEnsureToolPlaceholdersInput): NativeApplyBridgeEnsureToolPlaceholdersOutput;
+export declare function convertBridgeInputToChatMessagesWithNative(input: NativeBridgeInputToChatInput): NativeBridgeInputToChatOutput;
+export declare function coerceBridgeRoleWithNative(role: unknown): string;
+export declare function serializeToolOutputWithNative(input: NativeSerializeToolOutputInput): string | null;
+export declare function serializeToolArgumentsWithNative(input: NativeSerializeToolArgumentsInput): string;
+export declare function ensureMessagesArrayWithNative(input: NativeEnsureMessagesArrayInput): NativeEnsureMessagesArrayOutput;
+export declare function harvestToolsWithNative(input: NativeHarvestToolsInput): NativeHarvestToolsOutput;
 export declare function ensureBridgeOutputFieldsWithNative(input: NativeEnsureBridgeOutputFieldsInput): NativeEnsureBridgeOutputFieldsOutput;
 export declare function applyBridgeMetadataActionWithNative(input: NativeApplyBridgeMetadataActionInput): NativeApplyBridgeMetadataActionOutput;
 export declare function applyBridgeReasoningExtractWithNative(input: NativeApplyBridgeReasoningExtractInput): NativeApplyBridgeReasoningExtractOutput;

package/dist/router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js

@@ -38,6 +38,20 @@ function parseOutput(raw) {
         return null;
     }
 }
+function parseEnsureMessagesArrayOutput(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        const row = parsed;
+        const messages = Array.isArray(row.messages) ? row.messages : [];
+        return { messages };
+    }
+    catch {
+        return null;
+    }
+}
 function parseBridgeHistoryOutput(raw) {
     try {
         const parsed = JSON.parse(raw);
@@ -68,6 +82,14 @@ function parseBridgeHistoryOutput(raw) {
         return null;
     }
 }
+function parseBridgeInputToChatOutput(raw) {
+    const parsed = parseRecord(raw);
+    if (!parsed || !Array.isArray(parsed.messages)) {
+        return null;
+    }
+    const messages = parsed.messages.filter((entry) => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry));
+    return { messages };
+}
 function parseBridgeActionState(raw) {
     try {
         const parsed = JSON.parse(raw);
@@ -517,6 +539,180 @@ export function applyBridgeEnsureToolPlaceholdersWithNative(input) {
         return fail(reason);
     }
 }
+export function convertBridgeInputToChatMessagesWithNative(input) {
+    const capability = 'convertBridgeInputToChatMessagesJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({
+        input: input.input,
+        tools: input.tools,
+        toolResultFallbackText: input.toolResultFallbackText,
+        normalizeFunctionName: input.normalizeFunctionName
+    });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseBridgeInputToChatOutput(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function coerceBridgeRoleWithNative(role) {
+    const capability = 'coerceBridgeRoleJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({ role });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'string' ? parsed : fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function serializeToolOutputWithNative(input) {
+    const capability = 'serializeToolOutputJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({ output: input.output });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string') {
+            return fail('empty result');
+        }
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'string' || parsed === null ? parsed : fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function serializeToolArgumentsWithNative(input) {
+    const capability = 'serializeToolArgumentsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({ args: input.args });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'string' ? parsed : fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function ensureMessagesArrayWithNative(input) {
+    const capability = 'ensureMessagesArrayJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({ state: input.state });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseEnsureMessagesArrayOutput(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function harvestToolsWithNative(input) {
+    const capability = 'harvestToolsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({ signal: input.signal, context: input.context });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return fail('invalid payload');
+        }
+        const row = parsed;
+        if (!Array.isArray(row.deltaEvents)) {
+            return fail('invalid payload');
+        }
+        return row;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function ensureBridgeOutputFieldsWithNative(input) {
     const capability = 'ensureBridgeOutputFieldsJson';
     const fail = (reason) => failNativeRequired(capability, reason);

package/dist/router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.d.ts

@@ -13,6 +13,7 @@ export interface NativeReqInboundChatToStandardizedInput {
     endpoint: string;
     requestId?: string;
 }
+export declare function pruneChatRequestPayloadWithNative(payload: Record<string, unknown>, preserveStreamField?: boolean): Record<string, unknown>;
 export declare function sanitizeReqInboundFormatEnvelopeWithNative<T>(candidate: unknown): T;
 export declare function mapReqInboundResumeToolOutputsDetailedWithNative(responsesResume: unknown): Array<{
     tool_call_id: string;

package/dist/router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js

@@ -87,6 +87,33 @@ function replaceRecord(target, source) {
     }
     Object.assign(target, source);
 }
+export function pruneChatRequestPayloadWithNative(payload, preserveStreamField = false) {
+    const capability = 'pruneChatRequestPayloadJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({ payload, preserveStreamField });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseRecord(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function sanitizeReqInboundFormatEnvelopeWithNative(candidate) {
     return sanitizeFormatEnvelopeWithNative(candidate);
 }

package/dist/router/virtual-router/engine-selection/native-router-hotpath-loader.js

@@ -51,6 +51,33 @@ const REQUIRED_NATIVE_EXPORTS = [
     'applyBridgeCaptureToolResultsJson',
     'applyBridgeNormalizeToolIdentifiersJson',
     'applyBridgeEnsureToolPlaceholdersJson',
+    'convertBridgeInputToChatMessagesJson',
+    'coerceBridgeRoleJson',
+    'harvestToolsJson',
+    'serializeToolArgumentsJson',
+    'pruneChatRequestPayloadJson',
+    'enforceToolCallIdStyleJson',
+    'transformToolCallIdJson',
+    'createToolCallIdTransformerJson',
+    'extractToolCallIdJson',
+    'normalizeIdValueJson',
+    'extractStreamingToolCallsJson',
+    'chunkStringJson',
+    'flattenByCommaJson',
+    'packShellArgsJson',
+    'splitCommandStringJson',
+    'repairFindMetaJson',
+    'removeTrailingUnsignedThinkingBlocksJson',
+    'filterInvalidThinkingBlocksJson',
+    'sanitizeThinkingBlockJson',
+    'hasValidThoughtSignatureJson',
+    'serializeToolOutputJson',
+    'ensureMessagesArrayJson',
+    'normalizeReasoningInChatPayloadJson',
+    'normalizeReasoningInResponsesPayloadJson',
+    'normalizeReasoningInGeminiPayloadJson',
+    'normalizeReasoningInAnthropicPayloadJson',
+    'normalizeReasoningInOpenAIPayloadJson',
     'buildContinueExecutionOperationsJson',
     'buildDueReminderUserMessageJson',
     'buildGovernedFilterPayloadJson',
@@ -67,8 +94,13 @@ const REQUIRED_NATIVE_EXPORTS = [
     'mapOpenaiChatToChatJson',
     'mapOpenaiChatFromChatJson',
     'mapChatToolsToBridgeJson',
+    'bridgeToolToChatDefinitionJson',
+    'chatToolToBridgeDefinitionJson',
+    'mapBridgeToolsToChatWithOptionsJson',
+    'mapChatToolsToBridgeWithOptionsJson',
     'captureReqInboundResponsesContextSnapshotJson',
     'computeQuotaBucketsJson',
+    'extractReasoningSegmentsJson',
     'deserializeStopMessageStateJson',
     'detectProviderResponseShapeJson',
     'extractClockReminderDirectivesJson',
@@ -206,6 +238,8 @@ const REQUIRED_NATIVE_EXPORTS = [
     'deriveToolCallKeyJson',
     'extractToolCallsFromReasoningTextJson',
     'mapReasoningContentToResponsesOutputJson',
+    'validateToolArgumentsJson',
+    'repairToolCallsJson',
     'isImagePathJson',
     'resolveServerToolFollowupSnapshotJson',
     'resolveSseStreamModeJson',