@jsonstudio/llms 0.6.2172 → 0.6.2979

package/dist/servertool/server-side-tools.js

@@ -11,6 +11,7 @@ import './handlers/clock-auto.js';
 import './handlers/exec-command-guard.js';
 import './handlers/apply-patch-guard.js';
 import './handlers/continue-execution.js';
+import './handlers/review.js';
 import { runPreCommandHooks } from './pre-command-hooks.js';
 import { readRuntimeMetadata } from '../conversion/shared/runtime-metadata.js';
 function traceAutoHook(options, event) {
@@ -21,7 +22,7 @@ function traceAutoHook(options, event) {
         // best-effort trace callback
     }
 }
-const OPTIONAL_PRIMARY_HOOK_ORDER = ['empty_reply_continue', 'stop_message_auto', 'clock_auto'];
+const OPTIONAL_PRIMARY_HOOK_ORDER = ['empty_reply_continue', 'clock_auto', 'stop_message_auto'];
 const MANDATORY_HOOK_ORDER = [];
 let fallbackToolCallIdSeq = 0;
 function ensureToolCallId(record) {
@@ -81,6 +82,33 @@ function buildAutoHookQueues(hooks) {
     }
     return { optionalQueue, mandatoryQueue };
 }
+function normalizeFilterTokenSet(values) {
+    if (!Array.isArray(values) || values.length === 0) {
+        return null;
+    }
+    const normalized = new Set();
+    for (const raw of values) {
+        if (typeof raw !== 'string') {
+            continue;
+        }
+        const value = raw.trim().toLowerCase();
+        if (!value) {
+            continue;
+        }
+        normalized.add(value);
+    }
+    return normalized.size > 0 ? normalized : null;
+}
+function isNameIncluded(name, includeSet, excludeSet) {
+    const normalized = name.trim().toLowerCase();
+    if (includeSet && !includeSet.has(normalized)) {
+        return false;
+    }
+    if (excludeSet && excludeSet.has(normalized)) {
+        return false;
+    }
+    return true;
+}
 function extractToolCallsFromMessage(message) {
     const toolCalls = getArray(message.tool_calls);
     const out = [];
@@ -259,6 +287,10 @@ export async function runServerSideToolEngine(options) {
             providerInvoker: typeof options.providerInvoker === 'function'
         }
     };
+    const includeToolCallNames = normalizeFilterTokenSet(options.includeToolCallHandlerNames);
+    const excludeToolCallNames = normalizeFilterTokenSet(options.excludeToolCallHandlerNames);
+    const includeAutoHookIds = normalizeFilterTokenSet(options.includeAutoHookIds);
+    const excludeAutoHookIds = normalizeFilterTokenSet(options.excludeAutoHookIds);
     // Tool-call servertools: execute all executable servertool calls first, then decide:
     // - if only servertools were present -> followup via reenter (existing behavior)
     // - if mixed (servertool + client tools) -> persist servertool results, return remaining tool_calls to client
@@ -282,59 +314,64 @@ export async function runServerSideToolEngine(options) {
             continue;
         attemptedToolCallsByMessage.push(...extractToolCallsFromMessage(message));
     }
-    for (const { parsed: toolCall } of attemptedToolCallsByMessage) {
-        const preHookResult = runPreCommandHooks({
-            requestId: options.requestId,
-            entryEndpoint: options.entryEndpoint,
-            providerProtocol: options.providerProtocol,
-            toolName: toolCall.name,
-            toolCallId: toolCall.id,
-            toolArguments: toolCall.arguments,
-            preCommandState: runtimePreCommandState
-        });
-        for (const trace of preHookResult.traces) {
-            traceAutoHook(options, trace);
-        }
-        if (preHookResult.changed && preHookResult.toolArguments !== toolCall.arguments) {
-            toolCall.arguments = preHookResult.toolArguments;
-            patchToolCallArgumentsById(base, toolCall.id, preHookResult.toolArguments);
-            patchToolCallArgumentsById(baseForExecution, toolCall.id, preHookResult.toolArguments);
-        }
-        const entry = getServerToolHandler(toolCall.name);
-        if (!entry || entry.trigger !== 'tool_call') {
-            continue;
-        }
-        const ctx = { ...contextBase, base: baseForExecution, toolCall };
-        let planned = null;
-        let lastErr;
-        for (let attempt = 1; attempt <= 2; attempt += 1) {
-            try {
-                planned = await runHandler(entry.handler, ctx);
-                lastErr = undefined;
-                break;
+    if (options.disableToolCallHandlers !== true) {
+        for (const { parsed: toolCall } of attemptedToolCallsByMessage) {
+            if (!isNameIncluded(toolCall.name, includeToolCallNames, excludeToolCallNames)) {
+                continue;
             }
-            catch (err) {
-                lastErr = err;
+            const preHookResult = runPreCommandHooks({
+                requestId: options.requestId,
+                entryEndpoint: options.entryEndpoint,
+                providerProtocol: options.providerProtocol,
+                toolName: toolCall.name,
+                toolCallId: toolCall.id,
+                toolArguments: toolCall.arguments,
+                preCommandState: runtimePreCommandState
+            });
+            for (const trace of preHookResult.traces) {
+                traceAutoHook(options, trace);
             }
-        }
-        const result = planned ? await materializePlannedResult(planned, options) : null;
-        if (result) {
-            replaceJsonObjectInPlace(baseForExecution, cloneJson(result.chatResponse));
-            executedToolCalls.push(toolCall);
-            executedIds.add(toolCall.id);
-            if (result.execution?.flowId && typeof result.execution.flowId === 'string' && result.execution.flowId.trim()) {
-                executedFlowIds.push(result.execution.flowId.trim());
+            if (preHookResult.changed && preHookResult.toolArguments !== toolCall.arguments) {
+                toolCall.arguments = preHookResult.toolArguments;
+                patchToolCallArgumentsById(base, toolCall.id, preHookResult.toolArguments);
+                patchToolCallArgumentsById(baseForExecution, toolCall.id, preHookResult.toolArguments);
+            }
+            const entry = getServerToolHandler(toolCall.name);
+            if (!entry || entry.trigger !== 'tool_call') {
+                continue;
+            }
+            const ctx = { ...contextBase, base: baseForExecution, toolCall };
+            let planned = null;
+            let lastErr;
+            for (let attempt = 1; attempt <= 2; attempt += 1) {
+                try {
+                    planned = await runHandler(entry.handler, ctx);
+                    lastErr = undefined;
+                    break;
+                }
+                catch (err) {
+                    lastErr = err;
+                }
+            }
+            const result = planned ? await materializePlannedResult(planned, options) : null;
+            if (result) {
+                replaceJsonObjectInPlace(baseForExecution, cloneJson(result.chatResponse));
+                executedToolCalls.push(toolCall);
+                executedIds.add(toolCall.id);
+                if (result.execution?.flowId && typeof result.execution.flowId === 'string' && result.execution.flowId.trim()) {
+                    executedFlowIds.push(result.execution.flowId.trim());
+                }
+                lastExecution = result.execution;
+                continue;
+            }
+            if (lastErr) {
+                // Handler failed: report tool error as a tool_output, but do not crash the whole pipeline.
+                const message = lastErr instanceof Error ? lastErr.message : String(lastErr ?? 'unknown');
+                appendToolOutput(baseForExecution, toolCall.id, toolCall.name, JSON.stringify({ ok: false, tool: toolCall.name, message, retryable: true }));
+                executedToolCalls.push(toolCall);
+                executedIds.add(toolCall.id);
+                executedFlowIds.push(`${toolCall.name}_error`);
             }
-            lastExecution = result.execution;
-            continue;
-        }
-        if (lastErr) {
-            // Handler failed: report tool error as a tool_output, but do not crash the whole pipeline.
-            const message = lastErr instanceof Error ? lastErr.message : String(lastErr ?? 'unknown');
-            appendToolOutput(baseForExecution, toolCall.id, toolCall.name, JSON.stringify({ ok: false, tool: toolCall.name, message, retryable: true }));
-            executedToolCalls.push(toolCall);
-            executedIds.add(toolCall.id);
-            executedFlowIds.push(`${toolCall.name}_error`);
         }
     }
     if (executedToolCalls.length > 0) {
@@ -409,7 +446,8 @@ export async function runServerSideToolEngine(options) {
         };
     }
     const autoHookExecutionList = listAutoServerToolHooks();
-    const { optionalQueue, mandatoryQueue } = buildAutoHookQueues(autoHookExecutionList);
+    const filteredAutoHooks = autoHookExecutionList.filter((hook) => isNameIncluded(hook.id, includeAutoHookIds, excludeAutoHookIds));
+    const { optionalQueue, mandatoryQueue } = buildAutoHookQueues(filteredAutoHooks);
     const optionalResult = await runAutoHookQueue({
         queueName: 'A_optional',
         hooks: optionalQueue,

package/dist/servertool/types.d.ts

@@ -48,6 +48,11 @@ export interface ServerSideToolEngineOptions {
     entryEndpoint: string;
     requestId: string;
     providerProtocol: string;
+    disableToolCallHandlers?: boolean;
+    includeAutoHookIds?: string[];
+    excludeAutoHookIds?: string[];
+    includeToolCallHandlerNames?: string[];
+    excludeToolCallHandlerNames?: string[];
     providerInvoker?: ProviderInvoker;
     reenterPipeline?: (options: {
         entryEndpoint: string;
@@ -59,6 +64,15 @@ export interface ServerSideToolEngineOptions {
         __sse_responses?: unknown;
         format?: string;
     }>;
+    clientInjectDispatch?: (options: {
+        entryEndpoint: string;
+        requestId: string;
+        body?: JsonObject;
+        metadata?: JsonObject;
+    }) => Promise<{
+        ok: boolean;
+        reason?: string;
+    }>;
     onAutoHookTrace?: (event: ServerToolAutoHookTraceEvent) => void;
 }
 export type ServerToolFollowupInjectionOp = {
@@ -103,6 +117,9 @@ export type ServerToolFollowupPlan = {
     injection: ServerToolFollowupInjectionPlan;
     metadata?: JsonObject;
     entryEndpoint?: string;
+} | {
+    requestIdSuffix: string;
+    metadata?: JsonObject;
 };
 export type ServerToolBackendPlan = {
     kind: 'vision_analysis';

package/dist/tools/apply-patch/patch-text/normalize.js

@@ -179,6 +179,16 @@ const stripConflictMarkers = (text) => {
         return text;
     }
 };
+const splitInlineBeginPatchFileHeader = (text) => {
+    if (!text)
+        return text;
+    return text.replace(/\*\*\*\s*Begin Patch(?:\s*\*\*\*)?\s*(Create|Add|Update|Delete)\s+File:\s*([^\n]+?)(?:\s+\*\*\*)?(?=\n|$)/gi, (_m, actionRaw, pathRaw) => {
+        const action = String(actionRaw || '').trim().toLowerCase();
+        const mappedAction = action === 'create' ? 'Add' : `${action.charAt(0).toUpperCase()}${action.slice(1)}`;
+        const path = String(pathRaw || '').trim();
+        return `*** Begin Patch\n*** ${mappedAction} File: ${path}`;
+    });
+};
 export const normalizeApplyPatchText = (raw) => {
     if (!raw)
         return raw;
@@ -189,6 +199,7 @@ export const normalizeApplyPatchText = (raw) => {
     if (!text)
         return raw;
     text = stripConflictMarkers(text);
+    text = splitInlineBeginPatchFileHeader(text);
     text = normalizeBeginEndMarkers(text);
     // Some models emit a GNU unified diff wrapped in apply_patch markers, e.g.:
     //   *** Begin Patch ***

package/dist/tools/exec-command/validator.d.ts

@@ -4,4 +4,7 @@ export type ExecCommandValidationResult = {
     message?: string;
     normalizedArgs?: string;
 };
-export declare function validateExecCommandArgs(argsString: string, rawArgs: unknown): ExecCommandValidationResult;
+export type ExecCommandValidationOptions = {
+    policyFile?: string;
+};
+export declare function validateExecCommandArgs(argsString: string, rawArgs: unknown, options?: ExecCommandValidationOptions): ExecCommandValidationResult;

package/dist/tools/exec-command/validator.js

@@ -1,5 +1,8 @@
 import { parseToolArgsJson } from '../args-json.js';
 import { normalizeExecCommandArgs } from './normalize.js';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const toJson = (value) => {
     try {
@@ -9,6 +12,7 @@ const toJson = (value) => {
         return '{}';
     }
 };
+const POLICY_CACHE = new Map();
 const GIT_RESET_HARD_PATTERN = /\bgit\s+reset\s+--hard(?:\s|$)/i;
 const GIT_CHECKOUT_PATTERN = /\bgit\s+checkout\b/i;
 const SHELL_SEPARATORS = new Set([';', '&&', '||', '|', '&']);
@@ -124,10 +128,90 @@ function evaluateGitCheckoutScope(command) {
     }
     return null;
 }
-function detectPolicyViolation(command) {
+function resolvePolicyPath(rawPath) {
+    const trimmed = rawPath.trim();
+    if (!trimmed) {
+        return '';
+    }
+    if (trimmed.startsWith('~/')) {
+        return path.join(os.homedir(), trimmed.slice(2));
+    }
+    return path.resolve(trimmed);
+}
+function loadPolicyRules(policyFile) {
+    const resolved = typeof policyFile === 'string' ? resolvePolicyPath(policyFile) : '';
+    if (!resolved) {
+        return [];
+    }
+    try {
+        const stat = fs.statSync(resolved);
+        if (!stat.isFile()) {
+            return [];
+        }
+        const cached = POLICY_CACHE.get(resolved);
+        if (cached && cached.mtimeMs === stat.mtimeMs) {
+            return cached.rules;
+        }
+        const raw = fs.readFileSync(resolved, 'utf8');
+        const parsed = raw.trim() ? JSON.parse(raw) : {};
+        const rulesNode = isRecord(parsed) && Array.isArray(parsed.rules) ? parsed.rules : [];
+        const rules = [];
+        for (const item of rulesNode) {
+            if (!isRecord(item)) {
+                continue;
+            }
+            const type = typeof item.type === 'string' ? item.type.trim().toLowerCase() : '';
+            if (type !== 'regex') {
+                continue;
+            }
+            const pattern = typeof item.pattern === 'string' ? item.pattern : '';
+            if (!pattern.trim()) {
+                continue;
+            }
+            const id = typeof item.id === 'string' && item.id.trim() ? item.id.trim() : `rule_${rules.length + 1}`;
+            const reason = typeof item.reason === 'string' && item.reason.trim()
+                ? item.reason.trim()
+                : `policy rule "${id}" blocked this command`;
+            const flagsRaw = typeof item.flags === 'string' ? item.flags.trim() : '';
+            let regex;
+            try {
+                regex = new RegExp(pattern, flagsRaw || 'i');
+            }
+            catch {
+                continue;
+            }
+            rules.push({ id, regex, reason });
+        }
+        POLICY_CACHE.set(resolved, { mtimeMs: stat.mtimeMs, rules });
+        return rules;
+    }
+    catch {
+        return [];
+    }
+}
+function detectPolicyRuleViolation(command, options) {
+    const rules = loadPolicyRules(options?.policyFile);
+    if (!rules.length) {
+        return null;
+    }
+    for (const rule of rules) {
+        if (rule.regex.test(command)) {
+            return {
+                reason: 'forbidden_exec_command_policy',
+                message: rule.reason
+            };
+        }
+    }
+    return null;
+}
+function detectPolicyViolation(command, options) {
     if (!command || !command.trim()) {
         return null;
     }
+    const policyViolation = detectPolicyRuleViolation(command, options);
+    if (policyViolation) {
+        return policyViolation;
+    }
     if (GIT_RESET_HARD_PATTERN.test(command)) {
         return {
             reason: 'forbidden_git_reset_hard',
@@ -136,7 +220,7 @@ function detectPolicyViolation(command) {
     }
     return evaluateGitCheckoutScope(command);
 }
-export function validateExecCommandArgs(argsString, rawArgs) {
+export function validateExecCommandArgs(argsString, rawArgs, options) {
     const raw = typeof argsString === 'string' ? argsString : String(argsString ?? '');
     const parsed = isRecord(rawArgs) && Object.keys(rawArgs).length > 0
         ? rawArgs
@@ -146,7 +230,7 @@ export function validateExecCommandArgs(argsString, rawArgs) {
         return { ok: false, reason: normalized.reason };
     }
     const command = typeof normalized.normalized.cmd === 'string' ? normalized.normalized.cmd : '';
-    const violation = detectPolicyViolation(command);
+    const violation = detectPolicyViolation(command, options);
     if (violation) {
         return { ok: false, reason: violation.reason, message: violation.message };
     }

package/dist/tools/tool-registry.d.ts

@@ -5,5 +5,11 @@ export interface ToolValidationResult {
     warnings?: Array<Record<string, unknown>>;
     normalizedArgs?: string;
 }
+export interface ToolValidationOptions {
+    execCommandGuard?: {
+        enabled?: boolean;
+        policyFile?: string;
+    };
+}
 export declare function getAllowedToolNames(): string[];
-export declare function validateToolCall(name: string, argsString: string): ToolValidationResult;
+export declare function validateToolCall(name: string, argsString: string, options?: ToolValidationOptions): ToolValidationResult;

package/dist/tools/tool-registry.js

@@ -81,7 +81,7 @@ export function getAllowedToolNames() {
         'list_mcp_resource_templates'
     ];
 }
-export function validateToolCall(name, argsString) {
+export function validateToolCall(name, argsString, options) {
     const normalizedName = String(name || '').trim();
     if (!normalizedName) {
         return { ok: false, reason: 'empty_tool_name' };
@@ -93,7 +93,8 @@ export function validateToolCall(name, argsString) {
     const rawArgsAny = parseToolArgsJson(typeof argsString === 'string' ? argsString : '{}');
     switch (normalizedName) {
         case 'exec_command': {
-            const validation = validateExecCommandArgs(argsString, rawArgsAny);
+            const guard = options?.execCommandGuard;
+            const validation = validateExecCommandArgs(argsString, rawArgsAny, guard && guard.enabled ? { policyFile: guard.policyFile } : undefined);
             if (!validation.ok) {
                 const reason = validation.reason || 'unknown';
                 captureExecCommandRegression({