@jsonstudio/rcc 0.90.367 → 0.90.701

package/vendor/llmswitch-core/dist/servertool/pre-command-hooks.js

@@ -1,491 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { isPreCommandScriptPathAllowed } from '../router/virtual-router/pre-command-file-resolver.js';
-import { resolveRccPath } from '../runtime/user-data-paths.js';
-const DEFAULT_PRE_COMMAND_HOOKS_FILE = path.join(resolveRccPath(), 'hooks', 'pre-command-hooks.json');
-const DEFAULT_TIMEOUT_MS = 2000;
-const DEFAULT_TOOLS = ['exec_command', 'shell', 'shell_command'];
-let cachedConfig = null;
-export function runPreCommandHooks(options) {
-    const runtimeRule = resolveRuntimePreCommandRule(options.preCommandState);
-    const config = runtimeRule
-        ? { enabled: true, hooks: [runtimeRule] }
-        : loadPreCommandHooksConfig();
-    if (!config.enabled || config.hooks.length === 0) {
-        return {
-            toolArguments: options.toolArguments,
-            changed: false,
-            traces: []
-        };
-    }
-    const traces = [];
-    let changed = false;
-    let currentArguments = options.toolArguments;
-    let currentParsedArgs = parseToolArgumentsObject(currentArguments);
-    let currentCommandText = extractCommandText(currentParsedArgs, currentArguments);
-    const normalizedTool = normalizeToolName(options.toolName);
-    for (const hook of config.hooks) {
-        const traceBase = {
-            hookId: hook.id,
-            phase: 'pre_command',
-            priority: hook.priority,
-            queue: 'A_optional',
-            queueIndex: 0,
-            queueTotal: config.hooks.length
-        };
-        if (!hook.toolNames.has(normalizedTool)) {
-            traces.push({ ...traceBase, result: 'miss', reason: 'tool_mismatch' });
-            continue;
-        }
-        if (hook.cmdRegex && !hook.cmdRegex.test(currentCommandText)) {
-            traces.push({ ...traceBase, result: 'miss', reason: 'cmd_regex_mismatch' });
-            continue;
-        }
-        try {
-            let matched = false;
-            if (hook.runtimeScriptPath && hook.runtimeScriptPath.trim()) {
-                const runtimeOutput = runRuntimeScriptHook(hook.runtimeScriptPath, {
-                    requestId: options.requestId,
-                    entryEndpoint: options.entryEndpoint,
-                    providerProtocol: options.providerProtocol,
-                    toolName: normalizedTool,
-                    toolCallId: options.toolCallId,
-                    arguments: currentParsedArgs ?? { args_raw: currentArguments },
-                    command: currentCommandText,
-                    hookId: hook.id
-                }, hook.timeoutMs);
-                if (typeof runtimeOutput === 'string' && runtimeOutput !== currentArguments) {
-                    changed = true;
-                    currentArguments = runtimeOutput;
-                    currentParsedArgs = parseToolArgumentsObject(currentArguments);
-                    currentCommandText = extractCommandText(currentParsedArgs, currentArguments);
-                }
-                matched = true;
-            }
-            if (hook.jqExpression && hook.jqExpression.trim()) {
-                const jqInput = currentParsedArgs ?? { args_raw: currentArguments };
-                const transformed = runJqTransform(hook.jqExpression, jqInput, hook.timeoutMs);
-                currentParsedArgs = transformed;
-                const nextArgs = JSON.stringify(transformed);
-                if (nextArgs !== currentArguments) {
-                    changed = true;
-                    currentArguments = nextArgs;
-                    currentCommandText = extractCommandText(currentParsedArgs, currentArguments);
-                }
-                matched = true;
-            }
-            if (hook.shellCommand && hook.shellCommand.trim()) {
-                runShellCommandHook(hook.shellCommand, {
-                    requestId: options.requestId,
-                    entryEndpoint: options.entryEndpoint,
-                    providerProtocol: options.providerProtocol,
-                    toolName: normalizedTool,
-                    toolCallId: options.toolCallId,
-                    arguments: currentParsedArgs ?? { args_raw: currentArguments },
-                    command: currentCommandText,
-                    hookId: hook.id
-                }, hook.timeoutMs);
-                matched = true;
-            }
-            traces.push({
-                ...traceBase,
-                result: 'match',
-                reason: matched ? (changed ? 'applied' : 'matched') : 'no_action'
-            });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error ?? 'unknown_error');
-            traces.push({
-                ...traceBase,
-                result: 'error',
-                reason: message
-            });
-        }
-    }
-    return {
-        toolArguments: currentArguments,
-        changed,
-        traces
-    };
-}
-export function resetPreCommandHooksCacheForTests() {
-    cachedConfig = null;
-}
-function resolveRuntimePreCommandRule(rawState) {
-    if (!rawState || typeof rawState !== 'object' || Array.isArray(rawState)) {
-        return null;
-    }
-    const record = rawState;
-    const scriptPath = readString(record.preCommandScriptPath ?? record.scriptPath);
-    if (!scriptPath) {
-        return null;
-    }
-    if (!isPreCommandScriptPathAllowed(scriptPath)) {
-        return null;
-    }
-    const timeoutMs = normalizeTimeoutMs(record.timeoutMs ?? record.timeout_ms ?? process.env.ROUTECODEX_PRE_COMMAND_TIMEOUT_MS);
-    return {
-        id: `runtime_precommand:${sanitizeHookId(path.basename(scriptPath) || 'script')}`,
-        toolNames: new Set(DEFAULT_TOOLS),
-        runtimeScriptPath: scriptPath,
-        timeoutMs,
-        priority: -1000,
-        order: -1
-    };
-}
-function resolvePreCommandHooksFilePath() {
-    const configured = process.env.ROUTECODEX_PRE_COMMAND_HOOKS_FILE ||
-        process.env.RCC_PRE_COMMAND_HOOKS_FILE ||
-        process.env.LLMSWITCH_PRE_COMMAND_HOOKS_FILE;
-    if (typeof configured === 'string' && configured.trim()) {
-        return path.resolve(configured.trim());
-    }
-    return DEFAULT_PRE_COMMAND_HOOKS_FILE;
-}
-function loadPreCommandHooksConfig() {
-    const filePath = resolvePreCommandHooksFilePath();
-    let stat;
-    try {
-        stat = fs.statSync(filePath);
-    }
-    catch {
-        cachedConfig = {
-            filePath,
-            mtimeMs: 0,
-            size: 0,
-            config: { enabled: false, hooks: [] }
-        };
-        return cachedConfig.config;
-    }
-    if (cachedConfig &&
-        cachedConfig.filePath === filePath &&
-        cachedConfig.mtimeMs === stat.mtimeMs &&
-        cachedConfig.size === stat.size) {
-        return cachedConfig.config;
-    }
-    try {
-        const content = fs.readFileSync(filePath, 'utf8');
-        const parsed = JSON.parse(content);
-        const config = normalizePreCommandHooksConfig(parsed);
-        cachedConfig = {
-            filePath,
-            mtimeMs: stat.mtimeMs,
-            size: stat.size,
-            config
-        };
-        return config;
-    }
-    catch {
-        cachedConfig = {
-            filePath,
-            mtimeMs: stat.mtimeMs,
-            size: stat.size,
-            config: { enabled: false, hooks: [] }
-        };
-        return cachedConfig.config;
-    }
-}
-function normalizePreCommandHooksConfig(raw) {
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-        return { enabled: false, hooks: [] };
-    }
-    const record = raw;
-    const enabled = record.enabled !== false;
-    if (!enabled) {
-        return { enabled: false, hooks: [] };
-    }
-    const hooksRaw = Array.isArray(record.hooks) ? record.hooks : [];
-    const hooks = [];
-    for (let idx = 0; idx < hooksRaw.length; idx += 1) {
-        const normalized = normalizePreCommandHookRule(hooksRaw[idx], idx);
-        if (normalized) {
-            hooks.push(normalized);
-        }
-    }
-    hooks.sort((left, right) => {
-        if (left.priority !== right.priority) {
-            return left.priority - right.priority;
-        }
-        if (left.order !== right.order) {
-            return left.order - right.order;
-        }
-        return left.id.localeCompare(right.id);
-    });
-    return {
-        enabled: true,
-        hooks
-    };
-}
-function normalizePreCommandHookRule(raw, order) {
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-        return null;
-    }
-    const record = raw;
-    if (record.enabled === false) {
-        return null;
-    }
-    const id = normalizeHookId(record.id, order);
-    const toolNames = normalizeToolSet(record.tool ?? record.tools);
-    const cmdRegex = parseRegex(record.cmdRegex ?? record.commandRegex ?? record.matchCommand);
-    const jqExpression = readString(record.jq ?? record.jqTransform ?? record.expression);
-    const shellCommand = readString(record.shell ?? record.command);
-    const hasAction = Boolean(jqExpression || shellCommand);
-    if (!hasAction) {
-        return null;
-    }
-    const timeoutMs = normalizeTimeoutMs(record.timeoutMs ?? record.timeout_ms);
-    const priority = normalizePriority(record.priority);
-    return {
-        id,
-        toolNames,
-        cmdRegex,
-        jqExpression,
-        shellCommand,
-        timeoutMs,
-        priority,
-        order
-    };
-}
-function sanitizeHookId(value) {
-    return value.replace(/[^a-zA-Z0-9_.-]+/g, '_');
-}
-function normalizeHookId(value, order) {
-    const text = readString(value);
-    if (!text) {
-        return `pre_command_hook_${order + 1}`;
-    }
-    return sanitizeHookId(text);
-}
-function normalizeToolName(value) {
-    return (value || '').trim().toLowerCase();
-}
-function normalizeToolSet(raw) {
-    const out = new Set();
-    const push = (value) => {
-        if (typeof value !== 'string') {
-            return;
-        }
-        const normalized = normalizeToolName(value);
-        if (normalized) {
-            out.add(normalized);
-        }
-    };
-    if (Array.isArray(raw)) {
-        for (const item of raw) {
-            push(item);
-        }
-    }
-    else {
-        push(raw);
-    }
-    if (out.size === 0) {
-        for (const tool of DEFAULT_TOOLS) {
-            out.add(tool);
-        }
-    }
-    return out;
-}
-function parseRegex(raw) {
-    if (typeof raw !== 'string' || !raw.trim()) {
-        return undefined;
-    }
-    const value = raw.trim();
-    const slashMatch = value.match(/^\/(.*)\/([a-z]*)$/i);
-    if (slashMatch) {
-        const pattern = slashMatch[1];
-        const flags = slashMatch[2] || 'i';
-        try {
-            return new RegExp(pattern, flags);
-        }
-        catch {
-            return undefined;
-        }
-    }
-    try {
-        return new RegExp(value, 'i');
-    }
-    catch {
-        return undefined;
-    }
-}
-function normalizeTimeoutMs(raw) {
-    const num = typeof raw === 'number' ? raw : typeof raw === 'string' ? Number.parseInt(raw, 10) : NaN;
-    if (!Number.isFinite(num) || num <= 0) {
-        return DEFAULT_TIMEOUT_MS;
-    }
-    return Math.floor(Math.min(num, 30_000));
-}
-function normalizePriority(raw) {
-    const num = typeof raw === 'number' ? raw : typeof raw === 'string' ? Number.parseInt(raw, 10) : NaN;
-    if (!Number.isFinite(num)) {
-        return 100;
-    }
-    return Math.floor(num);
-}
-function readString(raw) {
-    return typeof raw === 'string' ? raw.trim() : '';
-}
-function parseToolArgumentsObject(raw) {
-    if (typeof raw !== 'string' || !raw.trim()) {
-        return {};
-    }
-    try {
-        const parsed = JSON.parse(raw);
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return null;
-        }
-        return parsed;
-    }
-    catch {
-        return null;
-    }
-}
-function extractCommandText(args, rawArgs) {
-    if (args && typeof args.cmd === 'string' && args.cmd.trim()) {
-        return args.cmd.trim();
-    }
-    if (args && typeof args.command === 'string' && args.command.trim()) {
-        return args.command.trim();
-    }
-    if (typeof rawArgs === 'string' && rawArgs.trim()) {
-        return rawArgs.trim();
-    }
-    return '';
-}
-function runJqTransform(expression, input, timeoutMs) {
-    const result = spawnSync('jq', ['-c', expression], {
-        input: JSON.stringify(input),
-        encoding: 'utf8',
-        timeout: timeoutMs,
-        maxBuffer: 1024 * 1024
-    });
-    if (result.error) {
-        const code = result.error.code;
-        if (code === 'ENOENT') {
-            throw new Error('jq_not_found');
-        }
-        throw new Error(`jq_error:${result.error.message}`);
-    }
-    if (typeof result.status === 'number' && result.status !== 0) {
-        const stderr = typeof result.stderr === 'string' ? result.stderr.trim() : '';
-        throw new Error(`jq_failed:${stderr || result.status}`);
-    }
-    const stdout = typeof result.stdout === 'string' ? result.stdout.trim() : '';
-    if (!stdout) {
-        throw new Error('jq_empty_output');
-    }
-    const lines = stdout
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
-    const payload = lines.length > 0 ? lines[lines.length - 1] : stdout;
-    let parsed;
-    try {
-        parsed = JSON.parse(payload);
-    }
-    catch {
-        throw new Error('jq_invalid_json_output');
-    }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error('jq_non_object_output');
-    }
-    return parsed;
-}
-function runShellCommandHook(command, eventPayload, timeoutMs) {
-    const result = spawnSync(command, {
-        shell: true,
-        timeout: timeoutMs,
-        encoding: 'utf8',
-        input: JSON.stringify(eventPayload),
-        env: {
-            ...process.env,
-            ROUTECODEX_PRE_COMMAND_HOOK_EVENT: JSON.stringify(eventPayload)
-        }
-    });
-    if (result.error) {
-        throw new Error(`shell_hook_error:${result.error.message}`);
-    }
-    if (typeof result.status === 'number' && result.status !== 0) {
-        const stderr = typeof result.stderr === 'string' ? result.stderr.trim() : '';
-        throw new Error(`shell_hook_failed:${stderr || result.status}`);
-    }
-}
-function runRuntimeScriptHook(scriptPath, eventPayload, timeoutMs) {
-    const payloadText = JSON.stringify(eventPayload);
-    let result = spawnSync(scriptPath, [], {
-        timeout: timeoutMs,
-        encoding: 'utf8',
-        input: payloadText,
-        env: {
-            ...process.env,
-            ROUTECODEX_PRE_COMMAND_HOOK_EVENT: payloadText
-        }
-    });
-    if (result.error) {
-        const code = result.error.code;
-        if ((code === 'EACCES' || code === 'ENOEXEC') && process.platform !== 'win32') {
-            result = spawnSync('/bin/bash', [scriptPath], {
-                timeout: timeoutMs,
-                encoding: 'utf8',
-                input: payloadText,
-                env: {
-                    ...process.env,
-                    ROUTECODEX_PRE_COMMAND_HOOK_EVENT: payloadText
-                }
-            });
-        }
-    }
-    if (result.error) {
-        throw new Error(`runtime_precommand_error:${result.error.message}`);
-    }
-    if (typeof result.status === 'number' && result.status !== 0) {
-        const stderr = typeof result.stderr === 'string' ? result.stderr.trim() : '';
-        throw new Error(`runtime_precommand_failed:${stderr || result.status}`);
-    }
-    const stdout = typeof result.stdout === 'string' ? result.stdout.trim() : '';
-    if (!stdout) {
-        return undefined;
-    }
-    const lines = stdout
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
-    const payload = lines.length > 0 ? lines[lines.length - 1] : stdout;
-    let parsed;
-    try {
-        parsed = JSON.parse(payload);
-    }
-    catch {
-        const fallback = payload.replace(/\\"/g, '"').trim();
-        const unwrapped = fallback.startsWith('"') && fallback.endsWith('"') && fallback.length > 1
-            ? fallback.slice(1, -1)
-            : fallback;
-        try {
-            parsed = JSON.parse(unwrapped);
-        }
-        catch {
-            throw new Error('runtime_precommand_invalid_json:' + payload.slice(0, 200));
-        }
-    }
-    if (typeof parsed === 'string' && parsed.trim()) {
-        return parsed;
-    }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        return undefined;
-    }
-    const record = parsed;
-    if (typeof record.toolArguments === 'string' && record.toolArguments.trim()) {
-        return record.toolArguments;
-    }
-    if (Object.prototype.hasOwnProperty.call(record, 'arguments')) {
-        const argValue = record.arguments;
-        if (typeof argValue === 'string') {
-            return argValue;
-        }
-        if (argValue && typeof argValue === 'object' && !Array.isArray(argValue)) {
-            return JSON.stringify(argValue);
-        }
-    }
-    return JSON.stringify(record);
-}

package/vendor/llmswitch-core/dist/servertool/reenter-backend.d.ts

@@ -1,23 +0,0 @@
-import type { JsonObject } from '../conversion/hub/types/json.js';
-export declare function reenterServerToolBackend(args: {
-    reenterPipeline: (options: {
-        entryEndpoint: string;
-        requestId: string;
-        body: JsonObject;
-        metadata?: JsonObject;
-    }) => Promise<{
-        body?: JsonObject;
-        __sse_responses?: unknown;
-        format?: string;
-    }>;
-    entryEndpoint: string;
-    requestId: string;
-    body: JsonObject;
-    providerProtocol: string;
-    routeHint?: string;
-    metadata?: JsonObject;
-}): Promise<{
-    body?: JsonObject;
-    __sse_responses?: unknown;
-    format?: string;
-}>;

package/vendor/llmswitch-core/dist/servertool/reenter-backend.js

@@ -1,20 +0,0 @@
-import { ensureRuntimeMetadata } from '../conversion/runtime-metadata.js';
-export async function reenterServerToolBackend(args) {
-    const routeHint = typeof args.routeHint === 'string' && args.routeHint.trim().length ? args.routeHint.trim() : undefined;
-    const merged = {
-        providerProtocol: args.providerProtocol,
-        stream: false,
-        ...(routeHint ? { routeHint } : {}),
-        ...(args.metadata ?? {})
-    };
-    const rt = ensureRuntimeMetadata(merged);
-    rt.serverToolFollowup = true;
-    rt.preserveRouteHint = false;
-    rt.disableStickyRoutes = true;
-    return await args.reenterPipeline({
-        entryEndpoint: args.entryEndpoint,
-        requestId: args.requestId,
-        body: args.body,
-        metadata: merged
-    });
-}

package/vendor/llmswitch-core/dist/servertool/registry.d.ts

@@ -1,35 +0,0 @@
-import type { ServerToolHandler } from './types.js';
-type TriggerMode = 'tool_call' | 'auto';
-type AutoHookPhase = 'pre' | 'default' | 'post';
-interface ServerToolAutoHookSpec {
-    id: string;
-    phase: AutoHookPhase;
-    priority: number;
-    order: number;
-}
-export interface ServerToolHandlerEntry {
-    name: string;
-    trigger: TriggerMode;
-    handler: ServerToolHandler;
-    autoHook?: ServerToolAutoHookSpec;
-}
-export interface ServerToolAutoHookDescriptor {
-    id: string;
-    phase: AutoHookPhase;
-    priority: number;
-    order: number;
-    handler: ServerToolHandler;
-}
-export declare function registerServerToolHandler(name: string, handler: ServerToolHandler, options?: {
-    trigger?: TriggerMode;
-    priority?: number;
-    phase?: AutoHookPhase | string;
-    hook?: {
-        priority?: number;
-        phase?: AutoHookPhase | string;
-    };
-}): void;
-export declare function getServerToolHandler(name: string): ServerToolHandlerEntry | undefined;
-export declare function listAutoServerToolHandlers(): ServerToolHandlerEntry[];
-export declare function listAutoServerToolHooks(): ServerToolAutoHookDescriptor[];
-export {};

package/vendor/llmswitch-core/dist/servertool/registry.js

@@ -1,92 +0,0 @@
-const SERVER_TOOL_HANDLERS = Object.create(null);
-const AUTO_SERVER_TOOL_HANDLERS = [];
-const DEFAULT_AUTO_HOOK_PRIORITY = 100;
-let autoHookRegistrationOrder = 0;
-function normalizeAutoHookPhase(value) {
-    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
-    if (normalized === 'pre' || normalized === 'before') {
-        return 'pre';
-    }
-    if (normalized === 'post' || normalized === 'after') {
-        return 'post';
-    }
-    return 'default';
-}
-function normalizeAutoHookPriority(value) {
-    if (typeof value === 'number' && Number.isFinite(value)) {
-        return Math.floor(value);
-    }
-    if (typeof value === 'string' && value.trim()) {
-        const parsed = Number.parseInt(value.trim(), 10);
-        if (Number.isFinite(parsed)) {
-            return Math.floor(parsed);
-        }
-    }
-    return DEFAULT_AUTO_HOOK_PRIORITY;
-}
-function resolveAutoHookPhaseRank(phase) {
-    if (phase === 'pre')
-        return 0;
-    if (phase === 'post')
-        return 2;
-    return 1;
-}
-export function registerServerToolHandler(name, handler, options) {
-    if (!name || typeof name !== 'string' || typeof handler !== 'function')
-        return;
-    const key = name.trim().toLowerCase();
-    if (!key)
-        return;
-    const trigger = options?.trigger ?? 'tool_call';
-    const entry = { name: key, trigger, handler };
-    if (trigger === 'auto') {
-        const priority = normalizeAutoHookPriority(options?.hook?.priority ?? options?.priority);
-        const phase = normalizeAutoHookPhase(options?.hook?.phase ?? options?.phase);
-        entry.autoHook = {
-            id: key,
-            phase,
-            priority,
-            order: autoHookRegistrationOrder++
-        };
-        AUTO_SERVER_TOOL_HANDLERS.push(entry);
-        return;
-    }
-    SERVER_TOOL_HANDLERS[key] = entry;
-}
-export function getServerToolHandler(name) {
-    if (!name || typeof name !== 'string')
-        return undefined;
-    const key = name.trim().toLowerCase();
-    if (!key)
-        return undefined;
-    return SERVER_TOOL_HANDLERS[key];
-}
-export function listAutoServerToolHandlers() {
-    return [...AUTO_SERVER_TOOL_HANDLERS].sort((left, right) => {
-        const leftHook = left.autoHook;
-        const rightHook = right.autoHook;
-        const phaseRankDiff = resolveAutoHookPhaseRank(leftHook?.phase ?? 'default') -
-            resolveAutoHookPhaseRank(rightHook?.phase ?? 'default');
-        if (phaseRankDiff !== 0) {
-            return phaseRankDiff;
-        }
-        const priorityDiff = (leftHook?.priority ?? DEFAULT_AUTO_HOOK_PRIORITY) - (rightHook?.priority ?? DEFAULT_AUTO_HOOK_PRIORITY);
-        if (priorityDiff !== 0) {
-            return priorityDiff;
-        }
-        const orderDiff = (leftHook?.order ?? 0) - (rightHook?.order ?? 0);
-        if (orderDiff !== 0) {
-            return orderDiff;
-        }
-        return left.name.localeCompare(right.name);
-    });
-}
-export function listAutoServerToolHooks() {
-    return listAutoServerToolHandlers().map((entry) => ({
-        id: entry.name,
-        phase: entry.autoHook?.phase ?? 'default',
-        priority: entry.autoHook?.priority ?? DEFAULT_AUTO_HOOK_PRIORITY,
-        order: entry.autoHook?.order ?? 0,
-        handler: entry.handler
-    }));
-}

package/vendor/llmswitch-core/dist/servertool/server-side-tools.d.ts

@@ -1,15 +0,0 @@
-import type { JsonObject } from '../conversion/hub/types/json.js';
-import type { ServerSideToolEngineOptions, ServerSideToolEngineResult, ToolCall } from './types.js';
-import './handlers/iflow-model-error-retry.js';
-import './handlers/antigravity-thought-signature-bootstrap.js';
-import './handlers/stop-message-auto.js';
-import './handlers/clock.js';
-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';
-export declare function runServerSideToolEngine(options: ServerSideToolEngineOptions): Promise<ServerSideToolEngineResult>;
-export declare function extractToolCalls(chatResponse: JsonObject): ToolCall[];
-export declare function cloneJson<T>(value: T): T;
-export declare function extractTextFromChatLike(payload: JsonObject): string;