@jsonstudio/llms 0.6.567 → 0.6.568

package/dist/router/virtual-router/tool-signals.js

@@ -101,7 +101,25 @@ const SHELL_READ_PATTERNS = [
     'python - <<',
     'python -c',
     'node - <<',
-    'node -e'
+    'node -e',
+    'sed -n',
+    'sed --quiet',
+    'sed ',
+    'rg ',
+    ' ripgrep',
+    'grep ',
+    'egrep ',
+    'fgrep ',
+    'ag ',
+    'ack ',
+    'find ',
+    'nl ',
+    'less',
+    'more',
+    'awk ',
+    'perl -ne',
+    'perl -pe',
+    'strings '
 ];
 export function detectVisionTool(request) {
     if (!Array.isArray(request.tools)) {
@@ -197,21 +215,49 @@ function classifyToolCall(call) {
     }
     const argsObject = parseToolArguments(call?.function?.arguments);
     const commandText = extractCommandText(argsObject);
-    const nameCategory = categorizeToolName(functionName);
     const snippet = buildCommandSnippet(commandText);
-    if (nameCategory === 'write' || nameCategory === 'read' || nameCategory === 'search') {
-        return { category: nameCategory, name: functionName, commandSnippet: snippet };
-    }
-    if (SHELL_TOOL_NAMES.has(functionName)) {
-        const shellCategory = classifyShellCommand(commandText);
-        return { category: shellCategory, name: functionName, commandSnippet: snippet };
-    }
-    if (commandText) {
+    const normalizedName = functionName.toLowerCase();
+    const normalizedCmd = commandText.toLowerCase();
+    // 1) Web search 优先：函数名或命令文本中命中 web 搜索关键字时，一律归类为 search，优先级最高。
+    const isWebSearch = WEB_TOOL_KEYWORDS.some((keyword) => normalizedName.includes(keyword)) ||
+        WEB_TOOL_KEYWORDS.some((keyword) => normalizedCmd.includes(keyword));
+    // 2) 基于工具名的初步分类（read / write / search / other）
+    const nameCategory = categorizeToolName(functionName);
+    // 3) shell_command / exec_command 根据内部命令判断读写性质
+    let shellCategory = 'other';
+    if (SHELL_TOOL_NAMES.has(functionName) || functionName === 'exec_command') {
+        shellCategory = classifyShellCommand(commandText);
+    }
+    // 按优先级合并分类结果：
+    //   1. web search
+    //   2. 写文件（任一维度命中写）
+    //   3. 读文件（任一维度命中读）
+    //   4. 其他搜索（非 web search）
+    //   5. 其它工具
+    // Priority 1: Web search
+    if (isWebSearch) {
+        return { category: 'search', name: functionName, commandSnippet: snippet };
+    }
+    // Priority 2: Write (写文件) — 名称或内部命令任一判断为写，都按写处理
+    if (nameCategory === 'write' || shellCategory === 'write') {
+        return { category: 'write', name: functionName, commandSnippet: snippet };
+    }
+    // Priority 3: Read (读文件) — 仅在没有写的情况下，再看读
+    if (nameCategory === 'read' || shellCategory === 'read') {
+        return { category: 'read', name: functionName, commandSnippet: snippet };
+    }
+    // Priority 4: 其他 search 类工具（非 web search）
+    if (nameCategory === 'search') {
+        return { category: 'search', name: functionName, commandSnippet: snippet };
+    }
+    // Priority 5: 兜底用命令文本再判断一次 shell 风格读写（非 shell/exec_command 的工具）
+    if (!SHELL_TOOL_NAMES.has(functionName) && functionName !== 'exec_command' && commandText) {
         const derivedCategory = classifyShellCommand(commandText);
-        if (derivedCategory !== 'other') {
+        if (derivedCategory === 'write' || derivedCategory === 'read') {
             return { category: derivedCategory, name: functionName, commandSnippet: snippet };
         }
     }
+    // 最终兜底：other
     return { category: 'other', name: functionName, commandSnippet: snippet };
 }
 function extractToolName(tool) {

package/dist/router/virtual-router/types.d.ts

@@ -172,6 +172,11 @@ export interface RouterMetadataInput {
      * 强制路由模式，从消息中的 <**...**> 指令解析得出
      */
     routingMode?: RoutingInstructionMode;
+    /**
+     * 当 disableStickyRoutes=true 时，本次请求仍使用 sticky session 状态，
+     * 但不继承 sticky target，允许后续路由重新选择 provider。
+     */
+    disableStickyRoutes?: boolean;
     /**
      * 允许的 provider 白名单
      */
@@ -343,3 +348,28 @@ export interface ProviderErrorEvent {
 export interface FeatureBuilder {
     build(request: StandardizedRequest, metadata: RouterMetadataInput): RoutingFeatures;
 }
+export interface ProviderCooldownState {
+    providerKey: string;
+    cooldownExpiresAt: number;
+    reason?: string;
+}
+export interface VirtualRouterHealthSnapshot {
+    providers: ProviderHealthState[];
+    cooldowns: ProviderCooldownState[];
+}
+export interface VirtualRouterHealthStore {
+    /**
+     * 在 VirtualRouterEngine 初始化时提供上一次持久化的健康快照。
+     * 调用方应仅返回仍在有效期内的 cooldown/熔断信息，或返回 null 表示无可恢复状态。
+     */
+    loadInitialSnapshot(): VirtualRouterHealthSnapshot | null;
+    /**
+     * 当 VirtualRouterEngine 更新 provider 健康状态或 cooldown 时，可选地持久化最新快照。
+     * 实现应保证内部吞掉 I/O 错误，不影响路由主流程。
+     */
+    persistSnapshot?(snapshot: VirtualRouterHealthSnapshot): void;
+    /**
+     * 可选：记录原始 ProviderErrorEvent，便于后续离线统计与诊断。
+     */
+    recordProviderError?(event: ProviderErrorEvent): void;
+}

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

@@ -8,8 +8,8 @@ export const ROUTE_PRIORITY = [
     'longcontext',
     'web_search',
     'search',
-    'coding',
     'thinking',
+    'coding',
     'tools',
     'background',
     DEFAULT_ROUTE

package/dist/servertool/engine.js

@@ -94,6 +94,9 @@ function resolveRouteHint(adapterContext, flowId) {
     if (!routeId) {
         return undefined;
     }
+    if (routeId.toLowerCase() === 'default') {
+        return undefined;
+    }
     if (flowId && routeId.toLowerCase() === flowId.toLowerCase()) {
         return undefined;
     }

package/dist/servertool/handlers/iflow-model-error-retry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/servertool/handlers/iflow-model-error-retry.js

@@ -0,0 +1,93 @@
+import { registerServerToolHandler } from '../registry.js';
+import { cloneJson } from '../server-side-tools.js';
+const FLOW_ID = 'iflow_model_error_retry';
+const handler = async (ctx) => {
+    if (!ctx.options.reenterPipeline) {
+        return null;
+    }
+    const adapterRecord = ctx.adapterContext;
+    // 避免在 followup 请求里再次触发，防止循环。
+    const followupRaw = adapterRecord.serverToolFollowup;
+    if (followupRaw === true || (typeof followupRaw === 'string' && followupRaw.trim().toLowerCase() === 'true')) {
+        return null;
+    }
+    // 仅针对 openai-chat 协议 + iflow.* providerKey 的 /v1/responses 路径启用。
+    if (ctx.options.providerProtocol !== 'openai-chat') {
+        return null;
+    }
+    const entryEndpoint = (ctx.options.entryEndpoint || '').toLowerCase();
+    if (!entryEndpoint.includes('/v1/responses')) {
+        return null;
+    }
+    const providerKey = typeof adapterRecord.providerKey === 'string' && adapterRecord.providerKey.trim()
+        ? adapterRecord.providerKey.trim().toLowerCase()
+        : '';
+    if (!providerKey.startsWith('iflow.')) {
+        return null;
+    }
+    // 仅在上游返回 error_code（HTTP 200 + 业务错误）时触发一次自动重试。
+    const base = ctx.base;
+    const errorCode = base.error_code;
+    const msg = base.msg;
+    if (typeof errorCode !== 'number' || errorCode === 0) {
+        return null;
+    }
+    if (typeof msg !== 'string' || !msg.trim().length) {
+        return null;
+    }
+    const captured = getCapturedRequest(ctx.adapterContext);
+    if (!captured) {
+        return null;
+    }
+    const followupPayload = buildRetryFollowupPayload(captured);
+    if (!followupPayload) {
+        return null;
+    }
+    return {
+        chatResponse: ctx.base,
+        execution: {
+            flowId: FLOW_ID,
+            followup: {
+                requestIdSuffix: ':retry',
+                payload: followupPayload,
+                metadata: {
+                    serverToolFollowup: true
+                }
+            }
+        }
+    };
+};
+registerServerToolHandler('iflow_model_error_retry', handler, { trigger: 'auto' });
+function getCapturedRequest(adapterContext) {
+    if (!adapterContext || typeof adapterContext !== 'object') {
+        return null;
+    }
+    const captured = adapterContext.capturedChatRequest;
+    if (!captured || typeof captured !== 'object' || Array.isArray(captured)) {
+        return null;
+    }
+    return captured;
+}
+function buildRetryFollowupPayload(source) {
+    if (!source || typeof source !== 'object') {
+        return null;
+    }
+    const payload = {};
+    if (typeof source.model === 'string' && source.model.trim()) {
+        payload.model = source.model.trim();
+    }
+    const rawMessages = source.messages;
+    if (Array.isArray(rawMessages)) {
+        payload.messages = cloneJson(rawMessages);
+    }
+    const rawTools = source.tools;
+    if (Array.isArray(rawTools) && rawTools.length) {
+        payload.tools = cloneJson(rawTools);
+    }
+    const parameters = source.parameters;
+    if (parameters && typeof parameters === 'object' && !Array.isArray(parameters)) {
+        const params = cloneJson(parameters);
+        Object.assign(payload, params);
+    }
+    return payload;
+}

package/dist/servertool/handlers/stop-message-auto.js

@@ -1,24 +1,52 @@
 import { registerServerToolHandler } from '../registry.js';
 import { cloneJson } from '../server-side-tools.js';
 import { loadRoutingInstructionStateSync, saveRoutingInstructionStateAsync } from '../../router/virtual-router/sticky-session-store.js';
+const STOPMESSAGE_DEBUG = (process.env.ROUTECODEX_STOPMESSAGE_DEBUG || '').trim() === '1';
+function debugLog(message, extra) {
+    if (!STOPMESSAGE_DEBUG) {
+        return;
+    }
+    try {
+        // eslint-disable-next-line no-console
+        console.log(`\x1b[38;5;33m[stopMessage][debug] ${message}` +
+            (extra ? ` ${JSON.stringify(extra)}` : '') +
+            '\x1b[0m');
+    }
+    catch {
+        /* ignore logging failures */
+    }
+}
 const FLOW_ID = 'stop_message_flow';
 const handler = async (ctx) => {
     const record = ctx.adapterContext;
+    debugLog('handler_start', {
+        requestId: record.requestId,
+        providerProtocol: record.providerProtocol
+    });
     const followupRaw = record.serverToolFollowup;
     if (followupRaw === true || (typeof followupRaw === 'string' && followupRaw.trim().toLowerCase() === 'true')) {
+        debugLog('skip_servertool_followup_flag');
+        return null;
+    }
+    const connectionState = resolveClientConnectionState(record.clientConnectionState);
+    if (connectionState?.disconnected === true) {
+        debugLog('skip_client_disconnected');
         return null;
     }
     const clientDisconnectedRaw = record.clientDisconnected;
     if (clientDisconnectedRaw === true ||
         (typeof clientDisconnectedRaw === 'string' && clientDisconnectedRaw.trim().toLowerCase() === 'true')) {
+        debugLog('skip_client_disconnected_flag');
         return null;
     }
     const stickyKey = resolveStickyKey(record);
     if (!stickyKey) {
+        debugLog('skip_no_sticky_key');
         return null;
     }
     const state = loadRoutingInstructionStateSync(stickyKey);
     if (!state || !state.stopMessageText || !state.stopMessageMaxRepeats) {
+        debugLog('skip_no_state', { stickyKey });
         return null;
     }
     const text = typeof state.stopMessageText === 'string' ? state.stopMessageText.trim() : '';
@@ -26,25 +54,45 @@ const handler = async (ctx) => {
         ? Math.max(1, Math.floor(state.stopMessageMaxRepeats))
         : 0;
     if (!text || maxRepeats <= 0) {
+        debugLog('skip_invalid_text_or_maxRepeats', {
+            stickyKey,
+            textLength: text.length,
+            maxRepeats
+        });
         return null;
     }
     const used = typeof state.stopMessageUsed === 'number' && Number.isFinite(state.stopMessageUsed)
         ? Math.max(0, Math.floor(state.stopMessageUsed))
         : 0;
     if (used >= maxRepeats) {
+        debugLog('skip_reached_max_repeats', {
+            stickyKey,
+            used,
+            maxRepeats
+        });
         return null;
     }
     if (!isStopFinishReason(ctx.base)) {
+        debugLog('skip_not_stop_finish_reason', {
+            stickyKey
+        });
         return null;
     }
     const captured = getCapturedRequest(ctx.adapterContext);
     if (!captured) {
+        debugLog('skip_no_captured_request', {
+            stickyKey
+        });
         return null;
     }
     state.stopMessageUsed = used + 1;
+    state.stopMessageLastUsedAt = Date.now();
     saveRoutingInstructionStateAsync(stickyKey, state);
     const followupPayload = buildStopMessageFollowupPayload(captured, text);
     if (!followupPayload) {
+        debugLog('skip_failed_build_followup', {
+            stickyKey
+        });
         return null;
     }
     return {
@@ -56,7 +104,10 @@ const handler = async (ctx) => {
                 payload: followupPayload,
                 metadata: {
                     serverToolFollowup: true,
-                    stream: false
+                    stream: false,
+                    preserveRouteHint: false,
+                    disableStickyRoutes: true,
+                    ...(connectionState ? { clientConnectionState: connectionState } : {})
                 }
             }
         }
@@ -65,12 +116,12 @@ const handler = async (ctx) => {
 registerServerToolHandler('stop_message_auto', handler, { trigger: 'auto' });
 function resolveStickyKey(record) {
     const sessionId = typeof record.sessionId === 'string' && record.sessionId.trim() ? record.sessionId.trim() : '';
-    if (sessionId) {
-        return `session:${sessionId}`;
-    }
     const conversationId = typeof record.conversationId === 'string' && record.conversationId.trim()
         ? record.conversationId.trim()
         : '';
+    if (sessionId) {
+        return `session:${sessionId}`;
+    }
     if (conversationId) {
         return `conversation:${conversationId}`;
     }
@@ -145,3 +196,9 @@ function buildStopMessageFollowupPayload(source, text) {
     }
     return payload;
 }
+function resolveClientConnectionState(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}

package/dist/servertool/server-side-tools.d.ts

@@ -3,6 +3,7 @@ import type { ServerSideToolEngineOptions, ServerSideToolEngineResult, ToolCall
 import './handlers/web-search.js';
 import './handlers/vision.js';
 import './handlers/gemini-empty-reply-continue.js';
+import './handlers/iflow-model-error-retry.js';
 import './handlers/stop-message-auto.js';
 export declare function runServerSideToolEngine(options: ServerSideToolEngineOptions): Promise<ServerSideToolEngineResult>;
 export declare function extractToolCalls(chatResponse: JsonObject): ToolCall[];

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

@@ -2,12 +2,16 @@ import { getServerToolHandler, listAutoServerToolHandlers } from './registry.js'
 import './handlers/web-search.js';
 import './handlers/vision.js';
 import './handlers/gemini-empty-reply-continue.js';
+import './handlers/iflow-model-error-retry.js';
 import './handlers/stop-message-auto.js';
 export async function runServerSideToolEngine(options) {
     const base = asObject(options.chatResponse);
     if (!base) {
         return { mode: 'passthrough', finalChatResponse: options.chatResponse };
     }
+    if (isClientDisconnected(options.adapterContext)) {
+        return { mode: 'passthrough', finalChatResponse: base };
+    }
     const toolCalls = extractToolCalls(base);
     const contextBase = {
         base,
@@ -91,6 +95,29 @@ function getArray(value) {
 export function cloneJson(value) {
     return JSON.parse(JSON.stringify(value));
 }
+function isClientDisconnected(adapterContext) {
+    if (!adapterContext || typeof adapterContext !== 'object') {
+        return false;
+    }
+    const state = adapterContext.clientConnectionState;
+    if (state && typeof state === 'object' && !Array.isArray(state)) {
+        const disconnected = state.disconnected;
+        if (disconnected === true) {
+            return true;
+        }
+        if (typeof disconnected === 'string' && disconnected.trim().toLowerCase() === 'true') {
+            return true;
+        }
+    }
+    const raw = adapterContext.clientDisconnected;
+    if (raw === true) {
+        return true;
+    }
+    if (typeof raw === 'string' && raw.trim().toLowerCase() === 'true') {
+        return true;
+    }
+    return false;
+}
 export function extractTextFromChatLike(payload) {
     let current = payload;
     const visited = new Set();

package/dist/sse/sse-to-json/builders/anthropic-response-builder.js

@@ -132,6 +132,22 @@ export function createAnthropicResponseBuilder(options) {
         },
         getResult() {
             if (!state.completed) {
+                // 对部分实现（或网络提前关闭）导致缺失 message_stop 的 SSE 流，
+                // 只要已经累计到可用内容，就以最佳努力方式返回结果，而不是直接抛错。
+                if (state.content.length > 0) {
+                    return {
+                        success: true,
+                        response: {
+                            id: state.id || `msg_${Date.now()}`,
+                            type: 'message',
+                            role: state.role || 'assistant',
+                            model: state.model || 'unknown',
+                            content: state.content,
+                            usage: state.usage,
+                            stop_reason: state.stopReason ?? 'end_turn'
+                        }
+                    };
+                }
                 return { success: false, error: new Error('Anthropic SSE stream incomplete') };
             }
             return {

package/dist/tools/apply-patch-structured.d.ts

@@ -0,0 +1,20 @@
+export type StructuredApplyPatchKind = 'insert_after' | 'insert_before' | 'replace' | 'delete' | 'create_file' | 'delete_file';
+export interface StructuredApplyPatchChange {
+    file?: string;
+    kind: StructuredApplyPatchKind | string;
+    anchor?: string;
+    target?: string;
+    lines?: string[] | string;
+    use_anchor_indent?: boolean;
+}
+export interface StructuredApplyPatchPayload extends Record<string, unknown> {
+    instructions?: string;
+    file?: string;
+    changes: StructuredApplyPatchChange[];
+}
+export declare class StructuredApplyPatchError extends Error {
+    reason: string;
+    constructor(reason: string, message: string);
+}
+export declare function buildStructuredPatch(payload: StructuredApplyPatchPayload): string;
+export declare function isStructuredApplyPatchPayload(candidate: unknown): candidate is StructuredApplyPatchPayload;