@jsonstudio/llms 0.6.3275 → 0.6.3405

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/bootstrap/web-search-config.js

@@ -37,6 +37,27 @@ export function normalizeWebSearch(input, routingSource) {
         const resolvedProviderKey = resolveWebSearchEngineProviderKey(providerKey, webSearchRouteTargets) ?? providerKey;
         const description = typeof node.description === 'string' && node.description.trim() ? node.description.trim() : undefined;
         const isDefault = node.default === true || (typeof node.default === 'string' && node.default.trim().toLowerCase() === 'true');
+        const rawExecutionMode = typeof node.executionMode === 'string'
+            ? node.executionMode.trim().toLowerCase()
+            : typeof node.mode === 'string'
+                ? node.mode.trim().toLowerCase()
+                : '';
+        const executionMode = rawExecutionMode === 'direct' ? 'direct' : 'servertool';
+        const rawDirectActivation = typeof node.directActivation === 'string'
+            ? node.directActivation.trim().toLowerCase()
+            : typeof node.activation === 'string'
+                ? node.activation.trim().toLowerCase()
+                : '';
+        const directActivation = rawDirectActivation === 'builtin'
+            ? 'builtin'
+            : rawDirectActivation === 'route'
+                ? 'route'
+                : executionMode === 'direct'
+                    ? 'route'
+                    : undefined;
+        const modelId = typeof node.modelId === 'string' && node.modelId.trim() ? node.modelId.trim() : undefined;
+        const maxUsesRaw = typeof node.maxUses === 'number' ? node.maxUses : Number(node.maxUses);
+        const maxUses = Number.isFinite(maxUsesRaw) && maxUsesRaw > 0 ? Math.floor(maxUsesRaw) : undefined;
         const serverToolsDisabled = node.serverToolsDisabled === true ||
             (typeof node.serverToolsDisabled === 'string' &&
                 node.serverToolsDisabled.trim().toLowerCase() === 'true') ||
@@ -51,6 +72,10 @@ export function normalizeWebSearch(input, routingSource) {
             providerKey: resolvedProviderKey,
             description,
             default: isDefault,
+            executionMode,
+            ...(directActivation ? { directActivation } : {}),
+            ...(modelId ? { modelId } : {}),
+            ...(maxUses ? { maxUses } : {}),
             ...(serverToolsDisabled ? { serverToolsDisabled: true } : {})
         });
     }

package/dist/router/virtual-router/bootstrap.js

@@ -140,26 +140,31 @@ function buildProviderRuntimeEntries(providers) {
     }
     return { runtimeEntries, aliasIndex, modelIndex };
 }
-function collectProviderModels(providerRaw, normalizedProvider) {
+function collectProviderModels(providerRaw, _normalizedProvider) {
     const rawModelsNode = providerRaw.models;
     const modelsDeclared = rawModelsNode !== undefined;
     const modelsNode = asRecord(rawModelsNode);
-    const baseModels = Object.keys(modelsNode).filter(Boolean);
-    if (normalizedProvider.compatibilityProfile !== 'chat:deepseek-web') {
-        return { declared: modelsDeclared, models: baseModels };
-    }
-    const withAliases = new Set(baseModels);
-    const hasChatBase = withAliases.has('deepseek-chat') || withAliases.has('deepseek-v3');
-    const hasReasonerBase = withAliases.has('deepseek-reasoner') || withAliases.has('deepseek-r1');
-    if (hasChatBase) {
-        withAliases.add('deepseek-chat-search');
-        withAliases.add('deepseek-v3-search');
-    }
-    if (hasReasonerBase) {
-        withAliases.add('deepseek-reasoner-search');
-        withAliases.add('deepseek-r1-search');
+    const collected = new Set();
+    for (const [modelName, modelConfigRaw] of Object.entries(modelsNode)) {
+        const normalizedModelName = typeof modelName === 'string' ? modelName.trim() : '';
+        if (normalizedModelName) {
+            collected.add(normalizedModelName);
+        }
+        const modelConfig = asRecord(modelConfigRaw);
+        const aliasesNode = Array.isArray(modelConfig.aliases)
+            ? modelConfig.aliases
+            : [];
+        for (const alias of aliasesNode) {
+            if (typeof alias !== 'string') {
+                continue;
+            }
+            const normalizedAlias = alias.trim();
+            if (normalizedAlias) {
+                collected.add(normalizedAlias);
+            }
+        }
     }
-    return { declared: modelsDeclared, models: Array.from(withAliases) };
+    return { declared: modelsDeclared, models: Array.from(collected) };
 }
 function normalizeClassifier(input) {
     const normalized = asRecord(input);

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-compat-action-semantics.d.ts

@@ -0,0 +1,6 @@
+export declare function normalizeResponsePayloadWithNative(payload: Record<string, unknown>, config?: Record<string, unknown>): Record<string, unknown>;
+export declare function validateResponsePayloadWithNative(payload: Record<string, unknown>): void;
+export declare function applyRequestRulesWithNative(payload: Record<string, unknown>, config?: Record<string, unknown>): Record<string, unknown>;
+export declare function applyResponseBlacklistWithNative(payload: Record<string, unknown>, config?: Record<string, unknown>): Record<string, unknown>;
+export declare function normalizeToolCallIdsWithNative(payload: Record<string, unknown>): Record<string, unknown>;
+export declare function enforceLmstudioResponsesFcToolCallIdsWithNative(payload: Record<string, unknown>): Record<string, unknown>;

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

@@ -0,0 +1,171 @@
+import { failNativeRequired, isNativeDisabledByEnv } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBindingForInternalUse } from './native-router-hotpath.js';
+function readNativeFunction(name) {
+    const binding = loadNativeRouterHotpathBindingForInternalUse();
+    const fn = binding?.[name];
+    return typeof fn === 'function' ? fn : null;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseRecord(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function normalizeResponsePayloadWithNative(payload, config) {
+    const capability = 'normalizeResponsePayloadJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(payload);
+    const configJson = config ? safeStringify(config) : '{}';
+    if (!payloadJson || !configJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson, configJson);
+        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 validateResponsePayloadWithNative(payload) {
+    const capability = 'validateResponsePayloadJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(payload);
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        fn(payloadJson);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        throw new Error(reason);
+    }
+}
+export function applyRequestRulesWithNative(payload, config) {
+    const capability = 'applyRequestRulesJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv())
+        return fail('native disabled');
+    const fn = readNativeFunction(capability);
+    if (!fn)
+        return fail();
+    const payloadJson = safeStringify(payload);
+    const configJson = config ? safeStringify(config) : '{}';
+    if (!payloadJson || !configJson)
+        return fail('json stringify failed');
+    try {
+        const raw = fn(payloadJson, configJson);
+        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 applyResponseBlacklistWithNative(payload, config) {
+    const capability = 'applyResponseBlacklistJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv())
+        return fail('native disabled');
+    const fn = readNativeFunction(capability);
+    if (!fn)
+        return fail();
+    const payloadJson = safeStringify(payload);
+    const configJson = config ? safeStringify(config) : '{}';
+    if (!payloadJson || !configJson)
+        return fail('json stringify failed');
+    try {
+        const raw = fn(payloadJson, configJson);
+        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 normalizeToolCallIdsWithNative(payload) {
+    const capability = 'normalizeToolCallIdsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv())
+        return fail('native disabled');
+    const fn = readNativeFunction(capability);
+    if (!fn)
+        return fail();
+    const payloadJson = safeStringify(payload);
+    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 enforceLmstudioResponsesFcToolCallIdsWithNative(payload) {
+    const capability = 'enforceLmstudioResponsesFcToolCallIdsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv())
+        return fail('native disabled');
+    const fn = readNativeFunction(capability);
+    if (!fn)
+        return fail();
+    const payloadJson = safeStringify(payload);
+    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);
+    }
+}

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;