@jsonstudio/rcc 0.90.876 → 0.90.1270

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/provider-runtime-ingress.js

@@ -0,0 +1,139 @@
+const runtimeRouterHooks = new Map();
+const runtimeQuotaHooks = new Map();
+const runtimeProviderQuotaHooks = new Map();
+const runtimeObserverHooks = new Map();
+function logIngressHookFailure(stage, error) {
+    const reason = error instanceof Error ? error.stack || error.message : String(error);
+    try {
+        console.warn(`[provider-runtime-ingress] ${stage} failed (non-blocking): ${reason}`);
+    }
+    catch {
+        // Never throw from logging.
+    }
+}
+function setHookEntry(store, owner, hooks) {
+    if (!owner) {
+        return;
+    }
+    if (!hooks) {
+        store.delete(owner);
+        return;
+    }
+    store.set(owner, hooks);
+}
+function dispatchToRouterHooks(event, kind) {
+    for (const hooks of runtimeRouterHooks.values()) {
+        try {
+            if (kind === 'error') {
+                hooks.handleProviderError?.(event);
+            }
+            else {
+                hooks.handleProviderSuccess?.(event);
+            }
+        }
+        catch (error) {
+            logIngressHookFailure(`runtime_router_hooks.${kind}`, error);
+        }
+    }
+}
+function dispatchToQuotaHooks(event, kind) {
+    for (const hooks of runtimeQuotaHooks.values()) {
+        try {
+            if (kind === 'error') {
+                hooks.onProviderError?.(event);
+            }
+            else {
+                hooks.onProviderSuccess?.(event);
+            }
+        }
+        catch (error) {
+            logIngressHookFailure(`runtime_quota_hooks.${kind}`, error);
+        }
+    }
+}
+function dispatchToProviderQuotaHooks(event) {
+    for (const hooks of runtimeProviderQuotaHooks.values()) {
+        try {
+            hooks.onProviderError?.(event);
+        }
+        catch (error) {
+            logIngressHookFailure('runtime_provider_quota_hooks.error', error);
+        }
+    }
+}
+function dispatchToObserverHooks(event, kind) {
+    for (const hooks of runtimeObserverHooks.values()) {
+        try {
+            if (kind === 'error') {
+                hooks.onProviderErrorReported?.(event);
+            }
+            else {
+                hooks.onProviderSuccessReported?.(event);
+            }
+        }
+        catch (error) {
+            logIngressHookFailure(`runtime_observer_hooks.${kind}`, error);
+        }
+    }
+}
+function normalizeProviderErrorEvent(event) {
+    const timestamp = typeof event.timestamp === 'number' ? event.timestamp : Date.now();
+    const code = event.code?.toString() || 'ERR_UNKNOWN';
+    const message = event.message || code;
+    const stage = event.stage || 'unknown';
+    const runtime = (event.runtime || {});
+    return {
+        code,
+        message,
+        stage,
+        status: event.status,
+        recoverable: event.recoverable,
+        affectsHealth: event.affectsHealth,
+        runtime,
+        timestamp,
+        details: event.details
+    };
+}
+function normalizeProviderSuccessEvent(event) {
+    const timestamp = typeof event.timestamp === 'number' ? event.timestamp : Date.now();
+    const runtime = (event.runtime || {});
+    return {
+        runtime,
+        timestamp,
+        metadata: event.metadata,
+        details: event.details
+    };
+}
+export function setVirtualRouterPolicyRuntimeRouterHooks(owner, hooks) {
+    setHookEntry(runtimeRouterHooks, owner, hooks);
+}
+export function setProviderRuntimeQuotaHooks(owner, hooks) {
+    setHookEntry(runtimeQuotaHooks, owner, hooks);
+}
+export function setProviderRuntimeProviderQuotaHooks(owner, hooks) {
+    setHookEntry(runtimeProviderQuotaHooks, owner, hooks);
+}
+export function setProviderRuntimeObserverHooks(owner, hooks) {
+    setHookEntry(runtimeObserverHooks, owner, hooks);
+}
+export function reportProviderErrorToRouterPolicy(event) {
+    const normalized = normalizeProviderErrorEvent(event);
+    dispatchToRouterHooks(normalized, 'error');
+    dispatchToQuotaHooks(normalized, 'error');
+    dispatchToProviderQuotaHooks(normalized);
+    dispatchToObserverHooks(normalized, 'error');
+    return normalized;
+}
+export function reportProviderSuccessToRouterPolicy(event) {
+    const normalized = normalizeProviderSuccessEvent(event);
+    dispatchToRouterHooks(normalized, 'success');
+    dispatchToQuotaHooks(normalized, 'success');
+    dispatchToObserverHooks(normalized, 'success');
+    return normalized;
+}
+export function resetProviderRuntimeIngressForTests() {
+    runtimeRouterHooks.clear();
+    runtimeQuotaHooks.clear();
+    runtimeProviderQuotaHooks.clear();
+    runtimeObserverHooks.clear();
+}

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/routing-instructions/parse.js

@@ -1,9 +1,29 @@
 import { parseRoutingInstructionsWithNative } from '../engine-selection/native-virtual-router-routing-instructions-semantics.js';
+function readLatestUserMessageText(messages) {
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const message = messages[i];
+        if (!message || message.role !== 'user' || typeof message.content !== 'string') {
+            continue;
+        }
+        const trimmed = message.content.trim();
+        if (trimmed) {
+            return trimmed;
+        }
+    }
+    return '';
+}
 export function parseRoutingInstructions(messages) {
     if (!Array.isArray(messages) || messages.length === 0) {
         return [];
     }
-    return parseRoutingInstructionsWithNative(messages);
+    const instructions = parseRoutingInstructionsWithNative(messages);
+    const latestUserMessage = readLatestUserMessageText(messages);
+    if (!latestUserMessage || !latestUserMessage.includes('\u200BstopMessage')) {
+        return instructions;
+    }
+    return instructions.filter((inst) => !(inst.type === 'stopMessageSet'
+        || inst.type === 'stopMessageMode'
+        || inst.type === 'stopMessageClear'));
 }
 export function parseAndPreprocessRoutingInstructions(messages) {
     const rawInstructions = parseRoutingInstructions(messages);

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/routing-instructions/state.js

@@ -25,6 +25,11 @@ export function applyRoutingInstructions(instructions, currentState) {
                 ? { ...entry }
                 : {})
             : undefined,
+        reasoningStopMode: currentState.reasoningStopMode,
+        reasoningStopArmed: currentState.reasoningStopArmed,
+        reasoningStopSummary: currentState.reasoningStopSummary,
+        reasoningStopUpdatedAt: currentState.reasoningStopUpdatedAt,
+        reasoningStopFailCount: currentState.reasoningStopFailCount,
         preCommandSource: currentState.preCommandSource,
         preCommandScriptPath: currentState.preCommandScriptPath,
         preCommandUpdatedAt: currentState.preCommandUpdatedAt,
@@ -166,6 +171,11 @@ export function applyRoutingInstructions(instructions, currentState) {
                 newState.disabledKeys.clear();
                 newState.disabledModels.clear();
                 applyStopMessageInstructionToState({ type: 'stopMessageClear' }, newState);
+                newState.reasoningStopMode = undefined;
+                newState.reasoningStopArmed = undefined;
+                newState.reasoningStopSummary = undefined;
+                newState.reasoningStopUpdatedAt = undefined;
+                newState.reasoningStopFailCount = undefined;
                 clearPreCommandState(newState);
                 break;
             case 'stopMessageSet':
@@ -197,6 +207,22 @@ export function serializeRoutingInstructionState(state) {
             models: Array.from(models)
         })),
         ...serializeStopMessageState(state),
+        ...(typeof state.reasoningStopMode === 'string'
+            && (state.reasoningStopMode === 'on' || state.reasoningStopMode === 'off' || state.reasoningStopMode === 'endless')
+            ? { reasoningStopMode: state.reasoningStopMode }
+            : {}),
+        ...(typeof state.reasoningStopArmed === 'boolean'
+            ? { reasoningStopArmed: state.reasoningStopArmed }
+            : {}),
+        ...(typeof state.reasoningStopSummary === 'string' && state.reasoningStopSummary.trim()
+            ? { reasoningStopSummary: state.reasoningStopSummary.trim() }
+            : {}),
+        ...(typeof state.reasoningStopUpdatedAt === 'number' && Number.isFinite(state.reasoningStopUpdatedAt)
+            ? { reasoningStopUpdatedAt: state.reasoningStopUpdatedAt }
+            : {}),
+        ...(typeof state.reasoningStopFailCount === 'number' && Number.isFinite(state.reasoningStopFailCount)
+            ? { reasoningStopFailCount: state.reasoningStopFailCount }
+            : {}),
         ...serializePreCommandState(state),
         ...(typeof state.chatProcessLastTotalTokens === 'number'
             ? { chatProcessLastTotalTokens: state.chatProcessLastTotalTokens }
@@ -229,6 +255,11 @@ export function deserializeRoutingInstructionState(data) {
         stopMessageAiMode: undefined,
         stopMessageAiSeedPrompt: undefined,
         stopMessageAiHistory: undefined,
+        reasoningStopMode: undefined,
+        reasoningStopArmed: undefined,
+        reasoningStopSummary: undefined,
+        reasoningStopUpdatedAt: undefined,
+        reasoningStopFailCount: undefined,
         preCommandSource: undefined,
         preCommandScriptPath: undefined,
         preCommandUpdatedAt: undefined,
@@ -267,6 +298,21 @@ export function deserializeRoutingInstructionState(data) {
         }
     }
     deserializeStopMessageState(data, state);
+    if (typeof data.reasoningStopMode === 'string') {
+        const normalizedMode = data.reasoningStopMode.trim().toLowerCase();
+        if (normalizedMode === 'on' || normalizedMode === 'off' || normalizedMode === 'endless') {
+            state.reasoningStopMode = normalizedMode;
+        }
+    }
+    if (typeof data.reasoningStopArmed === 'boolean') {
+        state.reasoningStopArmed = data.reasoningStopArmed;
+    }
+    if (typeof data.reasoningStopSummary === 'string' && data.reasoningStopSummary.trim()) {
+        state.reasoningStopSummary = data.reasoningStopSummary.trim();
+    }
+    if (typeof data.reasoningStopUpdatedAt === 'number' && Number.isFinite(data.reasoningStopUpdatedAt)) {
+        state.reasoningStopUpdatedAt = Math.max(0, Math.round(data.reasoningStopUpdatedAt));
+    }
     deserializePreCommandState(data, state);
     if (typeof data.chatProcessLastTotalTokens === 'number' && Number.isFinite(data.chatProcessLastTotalTokens)) {
         state.chatProcessLastTotalTokens = Math.max(0, Math.round(data.chatProcessLastTotalTokens));

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/routing-instructions/types.d.ts

@@ -64,6 +64,13 @@ export interface RoutingInstructionState {
     stopMessageAiMode?: 'on' | 'off';
     stopMessageAiSeedPrompt?: string;
     stopMessageAiHistory?: Array<Record<string, unknown>>;
+    reasoningStopMode?: 'on' | 'off' | 'endless';
+    reasoningStopArmed?: boolean;
+    reasoningStopSummary?: string;
+    reasoningStopUpdatedAt?: number;
+    reasoningStopFailCount?: number;
+    reasoningStopGuardTriggerCount?: number;
+    reasoningStopGuardTriggerAt?: number;
     preCommandSource?: string;
     preCommandScriptPath?: string;
     preCommandUpdatedAt?: number;

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/routing-stop-message-state-codec.js

@@ -1,7 +1,21 @@
 import { deserializeStopMessageStateWithNative, serializeStopMessageStateWithNative } from './engine-selection/native-virtual-router-stop-message-state-semantics.js';
 export const DEFAULT_STOP_MESSAGE_MAX_REPEATS = 10;
 export function serializeStopMessageState(state) {
-    return serializeStopMessageStateWithNative(state);
+    const out = serializeStopMessageStateWithNative(state);
+    if (typeof state.reasoningStopMode === 'string' &&
+        (state.reasoningStopMode === 'on' || state.reasoningStopMode === 'off' || state.reasoningStopMode === 'endless')) {
+        out.reasoningStopMode = state.reasoningStopMode;
+    }
+    if (typeof state.reasoningStopArmed === 'boolean') {
+        out.reasoningStopArmed = state.reasoningStopArmed;
+    }
+    if (typeof state.reasoningStopSummary === 'string' && state.reasoningStopSummary.trim()) {
+        out.reasoningStopSummary = state.reasoningStopSummary.trim();
+    }
+    if (typeof state.reasoningStopUpdatedAt === 'number' && Number.isFinite(state.reasoningStopUpdatedAt)) {
+        out.reasoningStopUpdatedAt = Math.max(0, Math.round(state.reasoningStopUpdatedAt));
+    }
+    return out;
 }
 export function deserializeStopMessageState(data, state) {
     const patch = deserializeStopMessageStateWithNative(data, state);
@@ -46,6 +60,21 @@ function deserializeStopMessageStateFallback(data, state) {
     if (history.length > 0) {
         state.stopMessageAiHistory = history;
     }
+    if (typeof data.reasoningStopMode === 'string') {
+        const normalizedMode = data.reasoningStopMode.trim().toLowerCase();
+        if (normalizedMode === 'on' || normalizedMode === 'off' || normalizedMode === 'endless') {
+            state.reasoningStopMode = normalizedMode;
+        }
+    }
+    if (typeof data.reasoningStopArmed === 'boolean') {
+        state.reasoningStopArmed = data.reasoningStopArmed;
+    }
+    if (typeof data.reasoningStopSummary === 'string' && data.reasoningStopSummary.trim()) {
+        state.reasoningStopSummary = data.reasoningStopSummary.trim();
+    }
+    if (typeof data.reasoningStopUpdatedAt === 'number' && Number.isFinite(data.reasoningStopUpdatedAt)) {
+        state.reasoningStopUpdatedAt = Math.max(0, Math.round(data.reasoningStopUpdatedAt));
+    }
     // Keep stopMessage mode state armed consistently across old/new snapshots.
     if (!hasPersistedMaxRepeats) {
         ensureStopMessageModeMaxRepeats(state);

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/sticky-session-store.js

@@ -1,7 +1,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { serializeRoutingInstructionState, deserializeRoutingInstructionState } from './routing-instructions.js';
-import { providerErrorCenter } from './error-center.js';
+import { reportProviderErrorToRouterPolicy } from './provider-runtime-ingress.js';
 import { resolveRccPath } from '../../runtime/user-data-paths.js';
 const pendingWrites = new Map();
 const STICKY_RUNTIME_REQUEST_ID = 'sticky-session-store';
@@ -17,8 +17,17 @@ function formatError(error) {
     }
     return String(error);
 }
+function logStickyStoreNonBlockingError(stage, error, details) {
+    try {
+        const suffix = details && Object.keys(details).length > 0 ? ` details=${JSON.stringify(details)}` : '';
+        process.stderr.write(`[sticky-session-store] ${stage} failed (non-blocking): ${formatError(error)}${suffix}\n`);
+    }
+    catch {
+        // Never throw from non-blocking logging.
+    }
+}
 function emitStickyStoreError(code, stage, message, details) {
-    providerErrorCenter.emit({
+    reportProviderErrorToRouterPolicy({
         code,
         message,
         stage,
@@ -35,8 +44,11 @@ function emitStickyStoreError(code, stage, message, details) {
         const errMsg = typeof details.error === 'string' ? details.error : '';
         console.warn(`[sticky-session-store] ${code} stage=${stage} op=${op}${errMsg ? ` error=${errMsg}` : ''}`);
     }
-    catch {
-        // no-op
+    catch (warnError) {
+        logStickyStoreNonBlockingError('emitStickyStoreError.consoleWarn', warnError, {
+            code,
+            stage
+        });
     }
 }
 export class StickySessionKeyMissingError extends Error {
@@ -312,13 +324,16 @@ async function atomicWriteFile(filepath, content) {
         try {
             await fs.promises.rename(tmp, filepath);
         }
-        catch {
+        catch (renameError) {
             try {
                 await fs.promises.unlink(filepath);
             }
-            catch {
-                // ignore unlink failures
+            catch (unlinkError) {
+                if (!shouldIgnoreUnlinkError(unlinkError)) {
+                    logStickyStoreNonBlockingError('atomicWriteFile.unlinkBeforeRename', unlinkError, { filepath, tmp });
+                }
             }
+            logStickyStoreNonBlockingError('atomicWriteFile.renamePrimary', renameError, { filepath, tmp });
             await fs.promises.rename(tmp, filepath);
         }
     }
@@ -326,8 +341,10 @@ async function atomicWriteFile(filepath, content) {
         try {
             await fs.promises.unlink(tmp);
         }
-        catch {
-            // ignore tmp cleanup failures
+        catch (tmpCleanupError) {
+            if (!shouldIgnoreUnlinkError(tmpCleanupError)) {
+                logStickyStoreNonBlockingError('atomicWriteFile.tmpCleanup', tmpCleanupError, { filepath, tmp });
+            }
         }
     }
 }
@@ -338,13 +355,16 @@ function atomicWriteFileSync(filepath, content) {
         try {
             fs.renameSync(tmp, filepath);
         }
-        catch {
+        catch (renameError) {
             try {
                 fs.unlinkSync(filepath);
             }
-            catch {
-                // ignore unlink failures
+            catch (unlinkError) {
+                if (!shouldIgnoreUnlinkError(unlinkError)) {
+                    logStickyStoreNonBlockingError('atomicWriteFileSync.unlinkBeforeRename', unlinkError, { filepath, tmp });
+                }
             }
+            logStickyStoreNonBlockingError('atomicWriteFileSync.renamePrimary', renameError, { filepath, tmp });
             fs.renameSync(tmp, filepath);
         }
     }
@@ -352,8 +372,10 @@ function atomicWriteFileSync(filepath, content) {
         try {
             fs.unlinkSync(tmp);
         }
-        catch {
-            // ignore tmp cleanup failures
+        catch (tmpCleanupError) {
+            if (!shouldIgnoreUnlinkError(tmpCleanupError)) {
+                logStickyStoreNonBlockingError('atomicWriteFileSync.tmpCleanup', tmpCleanupError, { filepath, tmp });
+            }
         }
     }
 }
@@ -366,6 +388,7 @@ function recoverPersistedJson(raw) {
         return null;
     }
     const maxScan = Math.min(text.length, 256 * 1024);
+    let parseFailures = 0;
     for (let i = maxScan - 1; i >= 1; i -= 1) {
         if (text[i] !== '}') {
             continue;
@@ -378,8 +401,14 @@ function recoverPersistedJson(raw) {
             }
         }
         catch {
-            // keep scanning
+            parseFailures += 1;
         }
     }
+    if (parseFailures > 0) {
+        logStickyStoreNonBlockingError('recoverPersistedJson.scan', `unable to recover JSON from truncated payload`, {
+            parseFailures,
+            maxScan
+        });
+    }
     return null;
 }

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/stop-message-state-sync.d.ts

@@ -1,5 +1,5 @@
 import type { RoutingInstructionState } from './routing-instructions.js';
-type StopMessageSubset = Pick<RoutingInstructionState, 'stopMessageSource' | 'stopMessageText' | 'stopMessageMaxRepeats' | 'stopMessageUsed' | 'stopMessageStageMode' | 'stopMessageAiMode' | 'stopMessageAiSeedPrompt' | 'stopMessageAiHistory' | 'stopMessageUpdatedAt' | 'stopMessageLastUsedAt'>;
+type StopMessageSubset = Pick<RoutingInstructionState, 'stopMessageSource' | 'stopMessageText' | 'stopMessageMaxRepeats' | 'stopMessageUsed' | 'stopMessageStageMode' | 'stopMessageAiMode' | 'stopMessageAiSeedPrompt' | 'stopMessageAiHistory' | 'stopMessageUpdatedAt' | 'stopMessageLastUsedAt' | 'reasoningStopMode' | 'reasoningStopArmed' | 'reasoningStopSummary' | 'reasoningStopUpdatedAt'>;
 /**
  * Decide whether we should overwrite in-memory stopMessage fields with persisted ones.
  *

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/stop-message-state-sync.js

@@ -31,7 +31,11 @@ function overlayPersistedUsage(existing, persisted) {
         stopMessageUsed: persisted.stopMessageUsed,
         stopMessageLastUsedAt: persisted.stopMessageLastUsedAt,
         stopMessageAiSeedPrompt: persisted.stopMessageAiSeedPrompt,
-        stopMessageAiHistory: persisted.stopMessageAiHistory
+        stopMessageAiHistory: persisted.stopMessageAiHistory,
+        reasoningStopMode: persisted.reasoningStopMode,
+        reasoningStopArmed: persisted.reasoningStopArmed,
+        reasoningStopSummary: persisted.reasoningStopSummary,
+        reasoningStopUpdatedAt: persisted.reasoningStopUpdatedAt
     };
 }
 /**
@@ -77,6 +81,10 @@ export function mergeStopMessageFromPersisted(existing, persisted) {
         stopMessageAiSeedPrompt: persisted.stopMessageAiSeedPrompt,
         stopMessageAiHistory: persisted.stopMessageAiHistory,
         stopMessageUpdatedAt: persisted.stopMessageUpdatedAt,
-        stopMessageLastUsedAt: persisted.stopMessageLastUsedAt
+        stopMessageLastUsedAt: persisted.stopMessageLastUsedAt,
+        reasoningStopMode: persisted.reasoningStopMode,
+        reasoningStopArmed: persisted.reasoningStopArmed,
+        reasoningStopSummary: persisted.reasoningStopSummary,
+        reasoningStopUpdatedAt: persisted.reasoningStopUpdatedAt
     };
 }

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/success-center.js

@@ -1,3 +1,37 @@
+const NON_BLOCKING_WARN_THROTTLE_MS = 60_000;
+const nonBlockingWarnByStage = new Map();
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.stack || `${error.name}: ${error.message}`;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function shouldLogNonBlockingStage(stage) {
+    const now = Date.now();
+    const lastAt = nonBlockingWarnByStage.get(stage) ?? 0;
+    if (now - lastAt < NON_BLOCKING_WARN_THROTTLE_MS) {
+        return false;
+    }
+    nonBlockingWarnByStage.set(stage, now);
+    return true;
+}
+function logSuccessCenterNonBlockingError(stage, operation, error, details) {
+    if (!shouldLogNonBlockingStage(stage)) {
+        return;
+    }
+    try {
+        const suffix = details && Object.keys(details).length > 0 ? ` details=${JSON.stringify(details)}` : '';
+        console.warn(`[success-center] stage=${stage} operation=${operation} failed (non-blocking): ${formatUnknownError(error)}${suffix}`);
+    }
+    catch {
+        void 0;
+    }
+}
 export class ProviderSuccessCenter {
     listeners = new Set();
     subscribe(listener) {
@@ -12,8 +46,11 @@ export class ProviderSuccessCenter {
             try {
                 listener(enriched);
             }
-            catch {
-                // Listener failures should not break propagation
+            catch (error) {
+                logSuccessCenterNonBlockingError('listener_dispatch', 'provider_success_listener', error, {
+                    providerKey: enriched.runtime?.providerKey,
+                    requestId: enriched.runtime?.requestId
+                });
             }
         }
         return enriched;

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/tool-signals.d.ts

@@ -14,6 +14,7 @@ export declare function detectWebTool(request: StandardizedRequest): boolean;
  */
 export declare function detectWebSearchToolDeclared(request: StandardizedRequest): boolean;
 export declare function extractMeaningfulDeclaredToolNames(tools: StandardizedRequest['tools'] | undefined): string[];
+export declare function chooseHigherPriorityToolCategory(current: ToolClassification | undefined, candidate: ToolClassification | undefined): ToolClassification | undefined;
 export declare function detectLastAssistantToolCategory(messages: StandardizedMessage[]): ToolClassification | undefined;
 export declare function classifyToolCallForReport(call: StandardizedMessage['tool_calls'][number]): ToolClassification | undefined;
 export declare function canonicalizeToolName(rawName: string): string;

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/tool-signals.js

@@ -42,7 +42,6 @@ const READ_TOOL_KEYWORDS = ['read', 'view', 'download', 'open', 'show', 'fetch',
 const WRITE_TOOL_KEYWORDS = ['write', 'patch', 'modify', 'edit', 'create', 'update', 'append', 'replace', 'save'];
 const SEARCH_TOOL_KEYWORDS = ['find', 'grep', 'glob', 'lookup', 'locate'];
 const SHELL_TOOL_NAMES = new Set(['shell_command', 'shell', 'bash']);
-const DECLARED_TOOL_IGNORE = new Set(['exec_command']);
 const SHELL_HEREDOC_PATTERN = /<<\s*['"]?[a-z0-9_-]+/i;
 const SHELL_WRITE_COMMANDS = new Set(['apply_patch', 'tee', 'touch', 'truncate', 'patch']);
 const SHELL_READ_COMMANDS = new Set(['cat', 'head', 'tail', 'awk', 'strings', 'less', 'more', 'nl']);
@@ -57,12 +56,7 @@ const SHELL_SEARCH_COMMANDS = new Set([
     'find',
     'fd',
     'locate',
-    'codesearch',
-    'ls',
-    'dir',
-    'tree',
-    'eza',
-    'exa'
+    'codesearch'
 ]);
 const SHELL_REDIRECT_WRITE_BINARIES = new Set(['cat', 'printf', 'python', 'node', 'perl', 'ruby', 'php', 'bash', 'sh', 'zsh', 'echo']);
 const SHELL_WRAPPER_COMMANDS = new Set(['sudo', 'env', 'time', 'nice', 'nohup', 'command', 'stdbuf']);
@@ -153,7 +147,7 @@ export function extractMeaningfulDeclaredToolNames(tools) {
             continue;
         }
         const canonical = canonicalizeToolName(rawName).toLowerCase();
-        if (!canonical || DECLARED_TOOL_IGNORE.has(canonical)) {
+        if (!canonical) {
             continue;
         }
         names.push(rawName);
@@ -162,11 +156,22 @@ export function extractMeaningfulDeclaredToolNames(tools) {
 }
 const TOOL_CATEGORY_PRIORITY = {
     websearch: 4,
-    read: 3,
-    write: 2,
-    search: 1,
+    write: 3,
+    search: 2,
+    read: 1,
     other: 0
 };
+export function chooseHigherPriorityToolCategory(current, candidate) {
+    if (!candidate) {
+        return current;
+    }
+    if (!current) {
+        return candidate;
+    }
+    const currentScore = TOOL_CATEGORY_PRIORITY[current.category] ?? 0;
+    const candidateScore = TOOL_CATEGORY_PRIORITY[candidate.category] ?? 0;
+    return candidateScore > currentScore ? candidate : current;
+}
 export function detectLastAssistantToolCategory(messages) {
     for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
         const msg = messages[idx];
@@ -183,17 +188,13 @@ export function detectLastAssistantToolCategory(messages) {
         if (!candidates.length) {
             continue;
         }
-        let best = candidates[0];
-        let bestScore = TOOL_CATEGORY_PRIORITY[best.category] ?? 0;
-        for (let i = 1; i < candidates.length; i += 1) {
-            const candidate = candidates[i];
-            const score = TOOL_CATEGORY_PRIORITY[candidate.category] ?? 0;
-            if (score > bestScore) {
-                best = candidate;
-                bestScore = score;
-            }
+        let best;
+        for (const candidate of candidates) {
+            best = chooseHigherPriorityToolCategory(best, candidate);
+        }
+        if (best) {
+            return best;
         }
-        return best;
     }
     return undefined;
 }
@@ -419,12 +420,12 @@ function classifyShellCommand(command) {
             }
         }
     }
-    if (sawRead) {
-        return 'read';
-    }
     if (sawSearch) {
         return 'search';
     }
+    if (sawRead) {
+        return 'read';
+    }
     return 'other';
 }
 function normalizeShellSegment(segment) {

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/types.d.ts

@@ -1,6 +1,7 @@
 /**
  * Virtual Router 类型定义
  */
+import type { ChatContinuationSemantics } from '../../conversion/hub/types/chat-envelope.js';
 import type { StandardizedRequest } from '../../conversion/hub/types/standardized.js';
 export declare const DEFAULT_MODEL_CONTEXT_TOKENS = 200000;
 export declare const DEFAULT_ROUTE = "default";
@@ -460,6 +461,7 @@ export interface RouterMetadataInput {
     tmux_session_id?: string;
     stopMessageClientInjectSessionScope?: string;
     stopMessageClientInjectScope?: string;
+    continuation?: ChatContinuationSemantics;
     responsesResume?: {
         previousRequestId?: string;
         restoredFromResponseId?: string;
@@ -569,6 +571,7 @@ export interface StopMessageStateSnapshot {
     stopMessageAiMode?: 'on' | 'off';
     stopMessageAiSeedPrompt?: string;
     stopMessageAiHistory?: Array<Record<string, unknown>>;
+    reasoningStopMode?: 'on' | 'off' | 'endless';
 }
 export interface PreCommandStateSnapshot {
     preCommandScriptPath: string;