@jsonstudio/rcc 0.89.3 → 0.89.164

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

@@ -1,5 +1,125 @@
+import { countRequestTokens } from './token-counter.js';
 const THINKING_KEYWORDS = ['let me think', 'chain of thought', 'cot', 'reason step', 'deliberate'];
 const WEB_TOOL_KEYWORDS = ['websearch', 'web_search', 'web-search', 'webfetch', 'web_fetch', 'web_request', 'search_web', 'internet_search'];
+const READ_TOOL_EXACT = new Set([
+    'read_file',
+    'read_text',
+    'view_file',
+    'view_code',
+    'view_document',
+    'open_file',
+    'get_file',
+    'download_file',
+    'describe_current_request',
+    'list_dir',
+    'list_directory',
+    'list_files',
+    'list_documents',
+    'list_resources',
+    'search_files',
+    'find_files'
+]);
+const WRITE_TOOL_EXACT = new Set([
+    'apply_patch',
+    'write_file',
+    'create_file',
+    'modify_file',
+    'edit_file',
+    'update_file',
+    'save_file',
+    'append_file',
+    'replace_file',
+    'delete_file',
+    'remove_file',
+    'rename_file',
+    'move_file',
+    'copy_file',
+    'mkdir',
+    'rmdir'
+]);
+const SEARCH_TOOL_EXACT = new Set(['websearch', 'web_search', 'search_web', 'internet_search', 'webfetch', 'web_fetch']);
+const READ_TOOL_KEYWORDS = ['read', 'list', 'view', 'download', 'open', 'show', 'fetch', 'inspect'];
+const WRITE_TOOL_KEYWORDS = ['write', 'patch', 'modify', 'edit', 'create', 'update', 'append', 'replace', 'delete', 'remove'];
+const SEARCH_TOOL_KEYWORDS = ['search', 'websearch', 'web_fetch', 'webfetch', 'web-request', 'web_request', 'internet'];
+const SHELL_TOOL_NAMES = new Set(['shell_command', 'shell', 'bash']);
+const SHELL_HEREDOC_PATTERN = /<<\s*['"]?[a-z0-9_-]+/i;
+const SHELL_WRITE_PATTERNS = [
+    'apply_patch',
+    'sed -i',
+    'perl -pi',
+    'tee ',
+    'cat <<',
+    'cat >',
+    'printf >',
+    'touch ',
+    'truncate',
+    'mkdir',
+    'mktemp',
+    'rmdir',
+    'rm ',
+    'rm-',
+    'unlink',
+    'mv ',
+    'cp ',
+    'ln -',
+    'chmod',
+    'chown',
+    'chgrp',
+    'tar ',
+    'git add',
+    'git commit',
+    'git apply',
+    'git am',
+    'git rebase',
+    'git checkout',
+    'git merge',
+    'patch <<',
+    'npm install',
+    'pnpm install',
+    'yarn add',
+    'yarn install',
+    'pip install',
+    'pip3 install',
+    'brew install',
+    'cargo add',
+    'cargo install',
+    'go install',
+    'make install'
+];
+const SHELL_SEARCH_PATTERNS = [
+    'rg ',
+    'rg-',
+    'grep ',
+    'grep-',
+    'ripgrep',
+    'find ',
+    'fd ',
+    'locate ',
+    'search ',
+    'ack ',
+    'ag ',
+    'where ',
+    'which ',
+    'codesearch'
+];
+const SHELL_READ_PATTERNS = [
+    'ls',
+    'dir ',
+    'pwd',
+    'cat ',
+    'type ',
+    'head ',
+    'tail ',
+    'stat',
+    'tree',
+    'wc ',
+    'du ',
+    'printf "',
+    'python - <<',
+    'python -c',
+    'node - <<',
+    'node -e'
+];
 export function buildRoutingFeatures(request, metadata) {
     const latestUserMessage = getLatestUserMessage(request.messages);
     const assistantMessages = request.messages.filter((msg) => msg.role === 'assistant');
@@ -7,17 +127,18 @@ export function buildRoutingFeatures(request, metadata) {
     const normalizedUserText = latestUserText.toLowerCase();
     const hasTools = Array.isArray(request.tools) && request.tools.length > 0;
     const hasToolCallResponses = assistantMessages.some((msg) => Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0);
-    const estimatedTokens = estimateTokens(latestUserText, latestUserText ? 1 : 0);
+    const estimatedTokens = computeRequestTokens(request, latestUserText);
     const hasThinking = detectKeyword(normalizedUserText, THINKING_KEYWORDS);
     const hasVisionTool = detectVisionTool(request);
     const hasImageAttachment = hasVisionTool && detectImageAttachment(latestUserMessage);
     const hasCodingTool = detectCodingTool(request);
     const hasWebTool = detectWebTool(request);
     const hasThinkingKeyword = hasThinking || detectExtendedThinkingKeyword(normalizedUserText);
+    const lastAssistantTool = detectLastAssistantToolCategory(assistantMessages);
     return {
         requestId: metadata.requestId,
         model: request.model,
-        totalMessages: latestUserText ? 1 : 0,
+        totalMessages: request.messages?.length ?? 0,
         userTextSample: latestUserText.slice(0, 2000),
         toolCount: request.tools?.length ?? 0,
         hasTools,
@@ -28,6 +149,8 @@ export function buildRoutingFeatures(request, metadata) {
         hasCodingTool,
         hasThinkingKeyword,
         estimatedTokens,
+        lastAssistantToolCategory: lastAssistantTool?.category,
+        lastAssistantToolName: lastAssistantTool?.name,
         metadata: {
             ...metadata
         }
@@ -97,12 +220,15 @@ function detectCodingTool(request) {
         return false;
     }
     return request.tools.some((tool) => {
-        const functionName = extractToolName(tool);
-        const description = extractToolDescription(tool);
-        const chineseDesc = description;
-        return (/write_file|apply_patch|modify_file|edit_file|create_file|shell|terminal|bash|run_shell/i.test(functionName) ||
-            /write file|apply patch|modify file|edit file|create file|shell|terminal|bash|run shell/i.test(description || '') ||
-            /创建文件|修改文件|写入文件|执行shell|执行终端/.test(chineseDesc || ''));
+        const functionName = extractToolName(tool).toLowerCase();
+        const description = (extractToolDescription(tool) || '').toLowerCase();
+        if (!functionName && !description) {
+            return false;
+        }
+        if (WRITE_TOOL_EXACT.has(functionName)) {
+            return true;
+        }
+        return WRITE_TOOL_KEYWORDS.some((keyword) => functionName.includes(keyword.toLowerCase()) || description.includes(keyword.toLowerCase()));
     });
 }
 function detectWebTool(request) {
@@ -125,12 +251,20 @@ function detectExtendedThinkingKeyword(text) {
     const keywords = ['仔细分析', '思考', '超级思考', '深度思考', 'careful analysis', 'deep thinking', 'deliberate'];
     return keywords.some((keyword) => text.includes(keyword));
 }
-function estimateTokens(text, messageCount) {
+function computeRequestTokens(request, fallbackText) {
+    try {
+        return countRequestTokens(request);
+    }
+    catch {
+        return fallbackEstimateTokens(fallbackText, request.messages?.length ?? 0);
+    }
+}
+function fallbackEstimateTokens(text, messageCount) {
     if (!text) {
-        return Math.max(32, messageCount * 16);
+        return Math.max(32, Math.max(messageCount, 1) * 16);
     }
     const rough = Math.ceil(text.length / 4);
-    return Math.max(rough, messageCount * 32);
+    return Math.max(rough, Math.max(messageCount, 1) * 32);
 }
 function extractToolName(tool) {
     if (!tool || typeof tool !== 'object') {
@@ -160,3 +294,198 @@ function extractToolDescription(tool) {
     }
     return '';
 }
+function detectLastAssistantToolCategory(messages) {
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        const msg = messages[idx];
+        if (!msg || !Array.isArray(msg.tool_calls) || msg.tool_calls.length === 0) {
+            continue;
+        }
+        let fallback;
+        for (const call of msg.tool_calls) {
+            const classification = classifyToolCall(call);
+            if (!classification) {
+                continue;
+            }
+            if (!fallback) {
+                fallback = classification;
+            }
+            if (classification.category !== 'other') {
+                return classification;
+            }
+        }
+        if (fallback) {
+            return fallback;
+        }
+    }
+    return undefined;
+}
+function classifyToolCall(call) {
+    if (!call || typeof call !== 'object') {
+        return undefined;
+    }
+    const functionName = typeof call?.function?.name === 'string' && call.function.name.trim()
+        ? canonicalizeToolName(call.function.name)
+        : '';
+    if (!functionName) {
+        return undefined;
+    }
+    const argsObject = parseToolArguments(call?.function?.arguments);
+    const commandText = extractCommandText(argsObject);
+    const nameCategory = categorizeToolName(functionName);
+    if (nameCategory === 'write' || nameCategory === 'read' || nameCategory === 'search') {
+        return { category: nameCategory, name: functionName };
+    }
+    if (SHELL_TOOL_NAMES.has(functionName)) {
+        const shellCategory = classifyShellCommand(commandText);
+        return { category: shellCategory, name: functionName };
+    }
+    if (commandText) {
+        const derivedCategory = classifyShellCommand(commandText);
+        if (derivedCategory !== 'other') {
+            return { category: derivedCategory, name: functionName };
+        }
+    }
+    return { category: 'other', name: functionName };
+}
+function canonicalizeToolName(rawName) {
+    const trimmed = rawName.trim();
+    const markerIndex = trimmed.indexOf('arg_');
+    if (markerIndex > 0) {
+        return trimmed.slice(0, markerIndex);
+    }
+    return trimmed;
+}
+function parseToolArguments(rawArguments) {
+    if (!rawArguments) {
+        return undefined;
+    }
+    if (typeof rawArguments === 'string') {
+        try {
+            return JSON.parse(rawArguments);
+        }
+        catch {
+            return rawArguments;
+        }
+    }
+    if (typeof rawArguments === 'object') {
+        return rawArguments;
+    }
+    return undefined;
+}
+function extractCommandText(args) {
+    if (!args) {
+        return '';
+    }
+    if (typeof args === 'string') {
+        return args;
+    }
+    if (Array.isArray(args)) {
+        return args.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+    }
+    if (typeof args === 'object') {
+        const record = args;
+        const command = record.command;
+        const input = record.input;
+        const nestedArgs = record.args;
+        if (typeof command === 'string') {
+            return command;
+        }
+        if (Array.isArray(command)) {
+            return command.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+        }
+        if (typeof input === 'string') {
+            return input;
+        }
+        if (typeof nestedArgs === 'string') {
+            return nestedArgs;
+        }
+        if (Array.isArray(nestedArgs)) {
+            return nestedArgs.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+        }
+    }
+    return '';
+}
+function categorizeToolName(name) {
+    const normalized = name.toLowerCase();
+    if (SEARCH_TOOL_EXACT.has(normalized) ||
+        SEARCH_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()))) {
+        return 'search';
+    }
+    if (READ_TOOL_EXACT.has(normalized) ||
+        READ_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()))) {
+        return 'read';
+    }
+    if (WRITE_TOOL_EXACT.has(normalized) ||
+        WRITE_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()))) {
+        return 'write';
+    }
+    return 'other';
+}
+function classifyShellCommand(command) {
+    if (!command) {
+        return 'other';
+    }
+    if (SHELL_HEREDOC_PATTERN.test(command)) {
+        return 'write';
+    }
+    const segments = splitCommandSegments(command).map(stripShellWrapper);
+    if (segments.some((segment) => matchesAnyPattern(segment, SHELL_WRITE_PATTERNS))) {
+        return 'write';
+    }
+    if (segments.some((segment) => matchesAnyPattern(segment, SHELL_SEARCH_PATTERNS))) {
+        return 'search';
+    }
+    if (segments.some((segment) => matchesAnyPattern(segment, SHELL_READ_PATTERNS))) {
+        return 'read';
+    }
+    const stripped = stripShellWrapper(command);
+    if (matchesAnyPattern(stripped, SHELL_WRITE_PATTERNS)) {
+        return 'write';
+    }
+    if (matchesAnyPattern(stripped, SHELL_SEARCH_PATTERNS)) {
+        return 'search';
+    }
+    if (matchesAnyPattern(stripped, SHELL_READ_PATTERNS)) {
+        return 'read';
+    }
+    return 'other';
+}
+function splitCommandSegments(command) {
+    return command
+        .split(/(?:\r?\n|&&|\|\||;)/)
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+}
+function matchesAnyPattern(text, patterns) {
+    if (!text) {
+        return false;
+    }
+    const trimmed = text.trim().toLowerCase();
+    const normalized = trimmed.startsWith('sudo ') ? trimmed.slice(5).trim() : trimmed;
+    return patterns.some((pattern) => {
+        const lowered = pattern.toLowerCase().trim();
+        return normalized.startsWith(lowered);
+    });
+}
+function stripShellWrapper(segment) {
+    let normalized = segment.trim();
+    const wrappers = ['bash -lc ', 'bash -lc', 'sh -c ', 'sh -c', '/bin/sh -c ', '/bin/sh -c', 'env -i bash -lc ', 'env -i bash -lc'];
+    for (const wrapper of wrappers) {
+        if (normalized.toLowerCase().startsWith(wrapper)) {
+            normalized = normalized.slice(wrapper.length).trim();
+            break;
+        }
+    }
+    normalized = trimEnclosingQuotes(normalized);
+    if (normalized.startsWith('sudo ')) {
+        normalized = normalized.slice(5).trim();
+    }
+    return normalized;
+}
+function trimEnclosingQuotes(value) {
+    if ((value.startsWith('"') && value.endsWith('"') && value.length > 1) ||
+        (value.startsWith("'") && value.endsWith("'") && value.length > 1)) {
+        return value.slice(1, -1).trim();
+    }
+    return value;
+}

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

@@ -0,0 +1,2 @@
+import type { StandardizedRequest } from '../../conversion/hub/types/standardized.js';
+export declare function countRequestTokens(request: StandardizedRequest): number;

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/token-counter.js

@@ -0,0 +1,105 @@
+import { encoding_for_model, get_encoding } from 'tiktoken';
+const DEFAULT_ENCODING = 'cl100k_base';
+const encoderCache = new Map();
+let defaultEncoder = null;
+function getEncoder(model) {
+    if (model) {
+        const normalized = model.trim();
+        if (encoderCache.has(normalized)) {
+            return encoderCache.get(normalized);
+        }
+        try {
+            const encoder = encoding_for_model(normalized);
+            encoderCache.set(normalized, encoder);
+            return encoder;
+        }
+        catch {
+            // fall back to default encoder
+        }
+    }
+    if (!defaultEncoder) {
+        defaultEncoder = get_encoding(DEFAULT_ENCODING);
+    }
+    return defaultEncoder;
+}
+export function countRequestTokens(request) {
+    const encoder = getEncoder(request.model);
+    let total = 0;
+    for (const message of request.messages || []) {
+        total += countMessageTokens(message, encoder);
+    }
+    if (Array.isArray(request.tools)) {
+        for (const tool of request.tools) {
+            total += encodeText(JSON.stringify(tool ?? {}), encoder);
+        }
+    }
+    if (request.parameters) {
+        total += encodeText(JSON.stringify(request.parameters), encoder);
+    }
+    if (request.metadata) {
+        total += encodeText(JSON.stringify(request.metadata), encoder);
+    }
+    return total;
+}
+function countMessageTokens(message, encoder) {
+    let total = 0;
+    total += encodeText(message.role, encoder);
+    total += encodeContent(message.content, encoder);
+    if (Array.isArray(message.tool_calls)) {
+        for (const call of message.tool_calls) {
+            total += encodeText(JSON.stringify(call ?? {}), encoder);
+        }
+    }
+    if (Array.isArray(message.metadata?.toolRuns)) {
+        total += encodeText(JSON.stringify(message.metadata?.toolRuns), encoder);
+    }
+    if (message.name) {
+        total += encodeText(message.name, encoder);
+    }
+    if (message.metadata) {
+        total += encodeText(JSON.stringify(message.metadata), encoder);
+    }
+    if (message.tool_call_id) {
+        total += encodeText(message.tool_call_id, encoder);
+    }
+    return total;
+}
+function encodeContent(content, encoder) {
+    if (content === null || content === undefined) {
+        return 0;
+    }
+    if (typeof content === 'string') {
+        return encodeText(content, encoder);
+    }
+    if (Array.isArray(content)) {
+        let total = 0;
+        for (const part of content) {
+            if (typeof part === 'string') {
+                total += encodeText(part, encoder);
+            }
+            else if (part && typeof part === 'object') {
+                if (typeof part.text === 'string') {
+                    total += encodeText(part.text, encoder);
+                }
+                else {
+                    total += encodeText(JSON.stringify(part), encoder);
+                }
+            }
+        }
+        return total;
+    }
+    if (typeof content === 'object') {
+        return encodeText(JSON.stringify(content), encoder);
+    }
+    return encodeText(String(content), encoder);
+}
+function encodeText(value, encoder) {
+    if (value === null || value === undefined) {
+        return 0;
+    }
+    const text = typeof value === 'string' ? value : String(value);
+    if (!text.trim()) {
+        return 0;
+    }
+    return encoder.encode(text).length;
+}

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

@@ -96,6 +96,11 @@ export interface RouterMetadataInput {
     providerProtocol?: string;
     stage?: 'inbound' | 'outbound' | 'response';
     routeHint?: string;
+    responsesResume?: {
+        previousRequestId?: string;
+        restoredFromResponseId?: string;
+        [key: string]: unknown;
+    };
 }
 export interface RoutingFeatures {
     requestId: string;
@@ -111,6 +116,8 @@ export interface RoutingFeatures {
     hasCodingTool: boolean;
     hasThinkingKeyword: boolean;
     estimatedTokens: number;
+    lastAssistantToolCategory?: 'read' | 'write' | 'search' | 'other';
+    lastAssistantToolName?: string;
     metadata: RouterMetadataInput;
 }
 export interface ClassificationResult {
@@ -203,6 +210,7 @@ export interface ProviderErrorEvent {
     stage: string;
     status?: number;
     recoverable?: boolean;
+    affectsHealth?: boolean;
     runtime: ProviderErrorRuntimeMetadata;
     timestamp: number;
     details?: Record<string, unknown>;

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

@@ -4,11 +4,11 @@
 export const DEFAULT_ROUTE = 'default';
 export const ROUTE_PRIORITY = [
     'vision',
+    'longcontext',
     'websearch',
     'coding',
-    'tools',
-    'longcontext',
     'thinking',
+    'tools',
     'background',
     DEFAULT_ROUTE
 ];

package/node_modules/@jsonstudio/llms/dist/sse/sse-to-json/builders/response-builder.d.ts

@@ -77,6 +77,8 @@ export declare class ResponsesResponseBuilder {
      * 处理function_call.start事件
      */
     private handleFunctionCallStart;
+    private coerceArgumentsChunk;
+    private shouldOverrideArguments;
     /**
      * 处理function_call.delta事件
      */

package/node_modules/@jsonstudio/llms/dist/sse/sse-to-json/builders/response-builder.js

@@ -112,6 +112,7 @@ export class ResponsesResponseBuilder {
                     this.handleOutputItemDone(event);
                     break;
                 case 'required_action':
+                case 'response.required_action':
                     this.handleRequiredAction(event);
                     break;
                 case 'response.done':
@@ -395,6 +396,36 @@ export class ResponsesResponseBuilder {
         outputItemState.arguments = '';
         outputItemState.lastEventTime = event.timestamp;
     }
+    coerceArgumentsChunk(raw) {
+        if (typeof raw === 'string') {
+            return raw;
+        }
+        if (raw && typeof raw === 'object') {
+            try {
+                return JSON.stringify(raw);
+            }
+            catch {
+                return String(raw);
+            }
+        }
+        return undefined;
+    }
+    shouldOverrideArguments(current, incoming) {
+        if (!incoming) {
+            return false;
+        }
+        const trimmed = incoming.trim();
+        if (!current || !current.length) {
+            return trimmed.length > 0;
+        }
+        if (!trimmed.length) {
+            return false;
+        }
+        if (trimmed === '{}' || trimmed.toLowerCase() === 'null') {
+            return false;
+        }
+        return true;
+    }
     /**
      * 处理function_call.delta事件
      */
@@ -404,10 +435,10 @@ export class ResponsesResponseBuilder {
         if (!outputItemState) {
             throw new Error(`Output item not found: ${data.item_id}`);
         }
-        const chunk = (data && data.delta && typeof data.delta === 'object' && typeof data.delta.arguments === 'string')
-            ? String(data.delta.arguments)
-            : (typeof (data?.delta) === 'string' ? String(data.delta) : (typeof data?.arguments === 'string' ? String(data.arguments) : undefined));
-        if (typeof chunk === 'string') {
+        const chunk = this.coerceArgumentsChunk(data?.delta?.arguments) ??
+            this.coerceArgumentsChunk(data?.delta) ??
+            this.coerceArgumentsChunk(data?.arguments);
+        if (chunk) {
             outputItemState.arguments = (outputItemState.arguments || '') + chunk;
         }
         outputItemState.lastEventTime = event.timestamp;
@@ -445,8 +476,16 @@ export class ResponsesResponseBuilder {
                 outputItemState.name = data.name;
             if (typeof data.call_id === 'string' && data.call_id)
                 outputItemState.callId = data.call_id;
-            if (typeof data.arguments === 'string' && data.arguments)
-                outputItemState.arguments = data.arguments;
+            const finalChunk = this.coerceArgumentsChunk(data?.arguments) ??
+                this.coerceArgumentsChunk(data?.delta?.arguments) ??
+                this.coerceArgumentsChunk(data?.delta);
+            if (this.shouldOverrideArguments(outputItemState.arguments, finalChunk)) {
+                outputItemState.arguments = finalChunk;
+            }
+            else if (!outputItemState.arguments && finalChunk) {
+                // 没有任何累计增量时，保底写入 done 事件里的值
+                outputItemState.arguments = finalChunk;
+            }
         }
         catch { /* ignore */ }
         outputItemState.status = 'completed';
@@ -630,14 +669,17 @@ export class ResponsesResponseBuilder {
         this.state = 'error';
     }
     handleResponseCompleted(event) {
-        const data = event.data;
-        if (data?.usage) {
-            this.response.usage = data.usage;
+        const payload = event.data?.response ?? event.data;
+        const usage = (payload && payload.usage)
+            ? payload.usage
+            : event.data?.usage;
+        if (usage) {
+            this.response.usage = usage;
         }
         // 标准化完成态：部分上游的 response.completed 不包含 status 字段
         // 若未提供明确的完成状态，统一标记为 'completed'，而不是沿用之前的 in_progress。
-        this.response.status = (data && data.status != null)
-            ? data.status
+        this.response.status = (payload && payload.status != null)
+            ? payload.status
             : 'completed';
         // 将已聚合的输出写回并标记完成（若为空数组也重建）
         try {

package/node_modules/@jsonstudio/llms/dist/test-output/virtual-router/results.json

@@ -0,0 +1 @@
+[]

package/node_modules/@jsonstudio/llms/dist/test-output/virtual-router/summary.json

@@ -0,0 +1,12 @@
+{
+  "samplesRoot": "/Users/fanzhang/.routecodex/codex-samples",
+  "configPath": "/Users/fanzhang/Documents/github/sharedmodule/llmswitch-core/test/virtual-router/virtual-router.config.json",
+  "stats": {
+    "totalSamples": 0,
+    "processed": 0,
+    "routes": {},
+    "providers": {},
+    "errors": [],
+    "scenarios": {}
+  }
+}