@jsonstudio/rcc 0.90.814 → 0.90.876

package/node_modules/@jsonstudio/llms/dist/conversion/shared/tool-governor.js

@@ -13,6 +13,11 @@ import { resolveRccPath } from '../../runtime/user-data-paths.js';
 function isObject(v) { return !!v && typeof v === 'object' && !Array.isArray(v); }
 // Note: tool schema strict augmentation removed per alignment
 function enforceChatBudget(chat, _modelId) { return chat; }
+function logToolGovernorNonBlocking(stage, error) {
+    const message = error instanceof Error ? error.message : String(error ?? 'unknown');
+    // eslint-disable-next-line no-console
+    console.warn(`[tool-governor][non-blocking] stage=${stage} error=${message}`);
+}
 function tryWriteSnapshot(options, stage, data) {
     try {
         // 仅在 verbose 级别保存快照（环境变量）
@@ -37,7 +42,9 @@ function tryWriteSnapshot(options, stage, data) {
         const payload = JSON.stringify(data, null, 2);
         fs.writeFileSync(file, payload, 'utf-8');
     }
-    catch { /* ignore snapshot errors */ }
+    catch (error) {
+        logToolGovernorNonBlocking(`snapshot_write:${stage}`, error);
+    }
 }
 /**
  * Process OpenAI Chat request (messages/tools) with unified 标准 governance.
@@ -74,7 +81,9 @@ export function processChatRequestTools(request, opts) {
             out.tools = augmentOpenAITools(tools);
         }
     }
-    catch { /* best-effort: 保持原样 */ }
+    catch (error) {
+        logToolGovernorNonBlocking('request_minimal_tool_shape_repair', error);
+    }
     // 1) 移除工具 schema 严格化（与 统一标准，不在此处约束 tools 结构）
     // NOTE: system guidance injection removed by design (align with parameter-level strategy)
     try {
@@ -94,13 +103,16 @@ export function processChatRequestTools(request, opts) {
                 }
             }
         }
-        catch { /* ignore */ }
+        catch (error) {
+            logToolGovernorNonBlocking('request_tool_choice_policy', error);
+        }
         // 4) Enforce payload budget (context bytes) with minimal loss policy
         const modelId = typeof canonical?.model === 'string' ? String(canonical.model) : 'unknown';
         const budgeted = enforceChatBudget(canonical, modelId);
         return normalizeSpecialToolCallsOnRequest(budgeted);
     }
-    catch {
+    catch (error) {
+        logToolGovernorNonBlocking('process_chat_request_tools', error);
         return out;
     }
 }
@@ -150,19 +162,20 @@ export function normalizeApplyPatchToolCallsOnResponse(chat) {
                             // eslint-disable-next-line no-console
                             console.error(`\x1b[31m[apply_patch][precheck][response] validation_failed reason=${reason}${snippet ? ` args=${snippet}` : ''}\x1b[0m`);
                         }
-                        catch {
-                            // logging best-effort
+                        catch (error) {
+                            logToolGovernorNonBlocking('response_apply_patch_regression_capture', error);
                         }
                     }
                 }
-                catch {
-                    // best-effort per tool_call
+                catch (error) {
+                    logToolGovernorNonBlocking('response_tool_call_normalize_item', error);
                 }
             }
         }
         return out;
     }
-    catch {
+    catch (error) {
+        logToolGovernorNonBlocking('normalize_apply_patch_tool_calls_on_response', error);
         return chat;
     }
 }
@@ -232,8 +245,8 @@ function normalizeSpecialToolCallsOnRequest(request) {
                                 // eslint-disable-next-line no-console
                                 console.error(`\x1b[31m[apply_patch][precheck][request] validation_failed reason=${reason}${snippet ? ` args=${snippet}` : ''}\x1b[0m`);
                             }
-                            catch {
-                                // logging best-effort
+                            catch (error) {
+                                logToolGovernorNonBlocking('request_apply_patch_regression_capture', error);
                             }
                         }
                         continue;
@@ -253,7 +266,8 @@ function normalizeSpecialToolCallsOnRequest(request) {
                             try {
                                 parsed = JSON.parse(argsStr);
                             }
-                            catch {
+                            catch (error) {
+                                logToolGovernorNonBlocking('request_exec_command_parse_json', error);
                                 parsed = parseLenient(argsStr);
                             }
                             if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
@@ -262,15 +276,16 @@ function normalizeSpecialToolCallsOnRequest(request) {
                                 try {
                                     fn.arguments = JSON.stringify(next ?? {});
                                 }
-                                catch {
+                                catch (error) {
+                                    logToolGovernorNonBlocking('request_exec_command_json_stringify', error);
                                     fn.arguments = '{}';
                                 }
                             }
                         }
                     }
                 }
-                catch {
-                    // best-effort per tool_call
+                catch (error) {
+                    logToolGovernorNonBlocking('request_tool_call_normalize_item', error);
                 }
             }
         }
@@ -279,7 +294,8 @@ function normalizeSpecialToolCallsOnRequest(request) {
         }
         return out;
     }
-    catch {
+    catch (error) {
+        logToolGovernorNonBlocking('normalize_special_tool_calls_on_request', error);
         return request;
     }
 }
@@ -319,7 +335,8 @@ function enhanceResponseToolArguments(chat) {
                     out = out.replace(/(?<!\\)\(/g, '\\(').replace(/(?<!\\)\)/g, '\\)');
                     return out;
                 }
-                catch {
+                catch (error) {
+                    logToolGovernorNonBlocking('enhance_response_tool_arguments_repair_find_meta', error);
                     return s;
                 }
             };
@@ -337,7 +354,8 @@ function enhanceResponseToolArguments(chat) {
                         try {
                             parsed = JSON.parse(repaired);
                         }
-                        catch {
+                        catch (error) {
+                            logToolGovernorNonBlocking('enhance_response_tool_arguments_parse_json', error);
                             parsed = parseLenient(repaired);
                         }
                         if (parsed && typeof parsed === 'object') {
@@ -367,7 +385,8 @@ function enhanceResponseToolArguments(chat) {
                             try {
                                 finalStr = JSON.stringify(parsed);
                             }
-                            catch {
+                            catch (error) {
+                                logToolGovernorNonBlocking('enhance_response_tool_arguments_json_stringify', error);
                                 finalStr = repaired;
                             }
                         }
@@ -384,23 +403,31 @@ function enhanceResponseToolArguments(chat) {
                     if (fn)
                         fn.arguments = finalStr;
                 }
-                catch { /* keep original */ }
+                catch (error) {
+                    logToolGovernorNonBlocking('enhance_response_tool_arguments_item', error);
+                }
             }
             // Ensure finish_reason/tool_calls invariant if missing (idempotent with canonicalizer)
             try {
                 if (!ch.finish_reason)
                     ch.finish_reason = 'tool_calls';
             }
-            catch { /* ignore */ }
+            catch (error) {
+                logToolGovernorNonBlocking('enhance_response_tool_arguments_finish_reason', error);
+            }
             try {
-                if (msg && typeof msg === 'object' && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0)
+                if (msg && typeof msg === 'object' && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
                     msg.content = null;
+                }
+            }
+            catch (error) {
+                logToolGovernorNonBlocking('enhance_response_tool_arguments_message_content', error);
             }
-            catch { /* ignore */ }
         }
         return out;
     }
-    catch {
+    catch (error) {
+        logToolGovernorNonBlocking('enhance_response_tool_arguments', error);
         return chat;
     }
 }
@@ -412,7 +439,8 @@ export function processChatResponseTools(resp) {
         const withPatch = normalizeApplyPatchToolCallsOnResponse(canon);
         return enhanceResponseToolArguments(withPatch);
     }
-    catch {
+    catch (error) {
+        logToolGovernorNonBlocking('process_chat_response_tools', error);
         return resp;
     }
 }
@@ -432,21 +460,27 @@ export function governTools(payload, ctx) {
         const opts = { snapshot: ctx?.snapshot || { enabled: true, endpoint: ep, requestId: ctx?.requestId } };
         tryWriteSnapshot(opts, 'response_before_canonicalize', payload);
     }
-    catch { /* ignore */ }
+    catch (error) {
+        logToolGovernorNonBlocking('govern_tools_snapshot_before_canonicalize', error);
+    }
     let out = processChatResponseTools(payload);
     // 变更后快照：响应侧 canonicalize 之后
     try {
         const opts = { snapshot: ctx?.snapshot || { enabled: true, endpoint: ep, requestId: ctx?.requestId } };
         tryWriteSnapshot(opts, 'response_after_canonicalize', out);
     }
-    catch { /* ignore */ }
+    catch (error) {
+        logToolGovernorNonBlocking('govern_tools_snapshot_after_canonicalize', error);
+    }
     if (ep === 'responses' && ctx?.stream !== true && ctx?.produceRequiredAction !== false) {
         // 变更前快照：构造 required_action 之前
         try {
             const opts = { snapshot: ctx?.snapshot || { enabled: true, endpoint: ep, requestId: ctx?.requestId } };
             tryWriteSnapshot(opts, 'response_before_required_action', out);
         }
-        catch { /* ignore */ }
+        catch (error) {
+            logToolGovernorNonBlocking('govern_tools_snapshot_before_required_action', error);
+        }
         try {
             const { buildResponsesPayloadFromChat } = require('../responses/responses-openai-bridge.js');
             const res = buildResponsesPayloadFromChat(out, { requestId: ctx?.requestId });
@@ -454,10 +488,14 @@ export function governTools(payload, ctx) {
                 const opts = { snapshot: ctx?.snapshot || { enabled: true, endpoint: ep, requestId: ctx?.requestId } };
                 tryWriteSnapshot(opts, 'response_after_required_action', res);
             }
-            catch { /* ignore */ }
+            catch (error) {
+                logToolGovernorNonBlocking('govern_tools_snapshot_after_required_action', error);
+            }
             return res;
         }
-        catch { /* ignore mapping errors and return canonicalized chat */ }
+        catch (error) {
+            logToolGovernorNonBlocking('govern_tools_required_action_bridge', error);
+        }
     }
     return out;
 }

package/node_modules/@jsonstudio/llms/dist/conversion/snapshot-utils.js

@@ -18,32 +18,216 @@ export async function recordSnapshot(options) {
     if (!shouldRecordSnapshots())
         return;
     const endpoint = options.endpoint || '/v1/chat/completions';
+    const prepared = coerceSnapshotPayloadForWrite(options.stage, options.data);
     void writeSnapshotViaHooks({
         endpoint,
         stage: options.stage,
         requestId: options.requestId,
         providerKey: options.providerKey,
         groupRequestId: options.groupRequestId,
-        data: options.data,
+        data: prepared.data,
         verbosity: 'verbose'
     }).catch(() => {
         // ignore hook errors
     });
 }
+const DEFAULT_SNAPSHOT_QUEUE_MAX_ITEMS = 10;
+const SNAPSHOT_QUEUE_BATCH_SIZE = 64;
+const DEFAULT_SNAPSHOT_PAYLOAD_MAX_BYTES = 256 * 1024;
+const DEFAULT_SNAPSHOT_QUEUE_MEMORY_BUDGET_BYTES = 8 * 1024 * 1024;
+const SNAPSHOT_QUEUE = [];
+let snapshotQueueBytes = 0;
+let snapshotQueueDrainScheduled = false;
+function resolvePositiveIntegerFromEnv(names, fallback) {
+    for (const name of names) {
+        const raw = process.env[name];
+        const parsed = Number.parseInt(String(raw ?? '').trim(), 10);
+        if (Number.isFinite(parsed) && parsed > 0) {
+            return parsed;
+        }
+    }
+    return fallback;
+}
+function resolveSnapshotPayloadMaxBytes() {
+    return resolvePositiveIntegerFromEnv(['ROUTECODEX_SNAPSHOT_PAYLOAD_MAX_BYTES', 'RCC_SNAPSHOT_PAYLOAD_MAX_BYTES'], DEFAULT_SNAPSHOT_PAYLOAD_MAX_BYTES);
+}
+function resolveSnapshotQueueMemoryBudgetBytes() {
+    return resolvePositiveIntegerFromEnv(['ROUTECODEX_SNAPSHOT_QUEUE_MEMORY_BUDGET_BYTES', 'RCC_SNAPSHOT_QUEUE_MEMORY_BUDGET_BYTES'], DEFAULT_SNAPSHOT_QUEUE_MEMORY_BUDGET_BYTES);
+}
+function resolveSnapshotQueueMaxItems() {
+    return resolvePositiveIntegerFromEnv(['ROUTECODEX_SNAPSHOT_QUEUE_MAX_ITEMS', 'RCC_SNAPSHOT_QUEUE_MAX_ITEMS'], DEFAULT_SNAPSHOT_QUEUE_MAX_ITEMS);
+}
+function estimateSnapshotPayloadBytes(value, options) {
+    const maxBytes = options?.maxBytes ?? Number.POSITIVE_INFINITY;
+    const depth = options?.depth ?? 0;
+    const seen = options?.seen ?? new Set();
+    if (value === null || value === undefined) {
+        return 4;
+    }
+    const valueType = typeof value;
+    if (valueType === 'string') {
+        return Math.min(maxBytes + 1, value.length * 2 + 2);
+    }
+    if (valueType === 'number') {
+        return 8;
+    }
+    if (valueType === 'boolean') {
+        return 4;
+    }
+    if (valueType === 'bigint') {
+        return String(value).length + 8;
+    }
+    if (valueType === 'symbol' || valueType === 'function') {
+        return 16;
+    }
+    if (seen.has(value)) {
+        return 8;
+    }
+    seen.add(value);
+    if (depth >= 8) {
+        return 64;
+    }
+    let bytes = 0;
+    if (Array.isArray(value)) {
+        bytes += 2;
+        for (const item of value) {
+            bytes += estimateSnapshotPayloadBytes(item, {
+                maxBytes: Math.max(0, maxBytes - bytes),
+                depth: depth + 1,
+                seen
+            });
+            if (bytes > maxBytes) {
+                return maxBytes + 1;
+            }
+        }
+        return bytes;
+    }
+    if (value && typeof value === 'object') {
+        bytes += 2;
+        for (const [key, child] of Object.entries(value)) {
+            bytes += key.length * 2 + 4;
+            bytes += estimateSnapshotPayloadBytes(child, {
+                maxBytes: Math.max(0, maxBytes - bytes),
+                depth: depth + 1,
+                seen
+            });
+            if (bytes > maxBytes) {
+                return maxBytes + 1;
+            }
+        }
+        return bytes;
+    }
+    return 16;
+}
+function summarizeSnapshotPayload(value) {
+    if (Array.isArray(value)) {
+        return {
+            type: 'array',
+            length: value.length,
+            sampleTypes: value.slice(0, 8).map((item) => typeof item)
+        };
+    }
+    if (value && typeof value === 'object') {
+        const record = value;
+        const keys = Object.keys(record);
+        return {
+            type: 'object',
+            keyCount: keys.length,
+            keys: keys.slice(0, 24)
+        };
+    }
+    if (typeof value === 'string') {
+        return {
+            type: 'string',
+            length: value.length,
+            preview: value.length > 160 ? `${value.slice(0, 160)}…` : value
+        };
+    }
+    return {
+        type: typeof value,
+        value: value ?? null
+    };
+}
+function coerceSnapshotPayloadForWrite(stage, payload) {
+    const maxBytes = resolveSnapshotPayloadMaxBytes();
+    const estimatedBytes = estimateSnapshotPayloadBytes(payload, { maxBytes: maxBytes + 1 });
+    if (estimatedBytes <= maxBytes) {
+        return {
+            data: payload,
+            sizeBytes: Math.max(1, estimatedBytes)
+        };
+    }
+    return {
+        data: {
+            __snapshot_truncated: true,
+            stage,
+            maxBytes,
+            estimatedBytes,
+            summary: summarizeSnapshotPayload(payload)
+        },
+        sizeBytes: 512
+    };
+}
+function scheduleSnapshotQueueDrain() {
+    if (snapshotQueueDrainScheduled) {
+        return;
+    }
+    snapshotQueueDrainScheduled = true;
+    setImmediate(() => {
+        snapshotQueueDrainScheduled = false;
+        let processed = 0;
+        while (SNAPSHOT_QUEUE.length > 0 && processed < SNAPSHOT_QUEUE_BATCH_SIZE) {
+            const item = SNAPSHOT_QUEUE.shift();
+            if (!item) {
+                continue;
+            }
+            snapshotQueueBytes = Math.max(0, snapshotQueueBytes - Math.max(1, item.sizeBytes));
+            try {
+                item.task();
+            }
+            catch {
+                // snapshot write failures are non-blocking by design
+            }
+            processed += 1;
+        }
+        if (SNAPSHOT_QUEUE.length > 0) {
+            scheduleSnapshotQueueDrain();
+        }
+    });
+}
+function enqueueSnapshotTask(task, sizeBytes) {
+    const normalizedSize = Math.max(1, Math.floor(sizeBytes));
+    const queueBudgetBytes = resolveSnapshotQueueMemoryBudgetBytes();
+    const queueMaxItems = resolveSnapshotQueueMaxItems();
+    while (SNAPSHOT_QUEUE.length > 0
+        && (SNAPSHOT_QUEUE.length >= queueMaxItems || snapshotQueueBytes + normalizedSize > queueBudgetBytes)) {
+        const dropped = SNAPSHOT_QUEUE.shift();
+        if (!dropped) {
+            break;
+        }
+        snapshotQueueBytes = Math.max(0, snapshotQueueBytes - Math.max(1, dropped.sizeBytes));
+    }
+    SNAPSHOT_QUEUE.push({ task, sizeBytes: normalizedSize });
+    snapshotQueueBytes += normalizedSize;
+    scheduleSnapshotQueueDrain();
+}
 export function createSnapshotWriter(opts) {
     if (!shouldRecordSnapshots()) {
         return undefined;
     }
     const endpoint = opts.endpoint || '/v1/chat/completions';
     return (stage, payload) => {
-        void recordSnapshot({
-            stage,
-            requestId: opts.requestId,
-            endpoint,
-            folderHint: opts.folderHint,
-            providerKey: opts.providerKey,
-            groupRequestId: opts.groupRequestId,
-            data: payload
-        });
+        const prepared = coerceSnapshotPayloadForWrite(stage, payload);
+        enqueueSnapshotTask(() => {
+            void recordSnapshot({
+                stage,
+                requestId: opts.requestId,
+                endpoint,
+                folderHint: opts.folderHint,
+                providerKey: opts.providerKey,
+                groupRequestId: opts.groupRequestId,
+                data: prepared.data
+            });
+        }, prepared.sizeBytes);
     };
 }

package/node_modules/@jsonstudio/llms/dist/quota/quota-state.js

@@ -153,10 +153,10 @@ export function applyErrorEvent(state, event, nowMs = event.timestampMs ?? Date.
             ? COOLDOWN_SCHEDULE_FATAL_MS
             : COOLDOWN_SCHEDULE_DEFAULT_MS;
     const rawNextCount = sameErrorKey ? state.consecutiveErrorCount + 1 : 1;
-    const nextCount = rawNextCount > schedule.length ? 1 : rawNextCount;
+    const nextCount = Math.min(rawNextCount, Math.max(1, schedule.length));
     const cooldownMs = computeTransientKeepPoolCooldownMs(series, nextCount) ?? computeCooldownMsBySeries(series, nextCount);
     const nextUntil = cooldownMs ? nowMs + cooldownMs : null;
-    const existingUntil = typeof state.cooldownUntil === 'number' ? state.cooldownUntil : null;
+    const existingUntil = sameErrorKey && typeof state.cooldownUntil === 'number' ? state.cooldownUntil : null;
     const cooldownUntil = typeof nextUntil === 'number' && Number.isFinite(nextUntil)
         ? typeof existingUntil === 'number' && existingUntil > nextUntil
             ? existingUntil

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

@@ -1,4 +1,36 @@
 import { mergeStopMessageFromPersisted } from '../../stop-message-state-sync.js';
+import { providerErrorCenter } from '../../error-center.js';
+function formatError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function emitRoutingStateRefreshError(key, error) {
+    const errorMessage = formatError(error);
+    providerErrorCenter.emit({
+        code: 'STICKY_STATE_REFRESH_FAILED',
+        message: 'failed to refresh in-memory routing state from persisted sticky store',
+        stage: 'sticky_session.refresh',
+        timestamp: Date.now(),
+        runtime: {
+            requestId: 'routing-state-store',
+            providerProtocol: 'sticky-session-store',
+            providerType: 'internal'
+        },
+        details: {
+            operation: 'refresh_existing_state',
+            key,
+            error: errorMessage
+        }
+    });
+    try {
+        console.warn(`[routing-state-store] STICKY_STATE_REFRESH_FAILED key=${key} error=${errorMessage}`);
+    }
+    catch {
+        // no-op
+    }
+}
 function readToken(value) {
     if (typeof value !== 'string') {
         return '';
@@ -66,8 +98,9 @@ export function getRoutingInstructionState(stickyKey, routingInstructionState, r
                 existing.preCommandUpdatedAt = persisted.preCommandUpdatedAt;
             }
         }
-        catch {
-            // 刷新失败不影响原有内存状态
+        catch (error) {
+            // 刷新失败不影响原有内存状态，但必须显式上报，禁止静默吞错
+            emitRoutingStateRefreshError(key, error);
         }
         return existing;
     }

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

@@ -64,20 +64,20 @@ export class VirtualRouterEngine {
         }
         const parsed = JSON.parse(raw);
         emitStopMessageMarkerParseLog(parseLog);
-        // Keep legacy observable behavior for callers/tests that inspect the request object
-        // after route(): instruction markers are stripped from forwarded payload structures.
         cleanStopMessageMarkersInPlace(request);
         const stopScope = parseLog?.stopScope || resolveStopMessageScope(metadata);
         const stopState = stopScope ? this.getStopMessageState(metadata) : null;
         const forceStopStatusLabel = Boolean(parseLog?.stopMessageTypes.length ||
             parseLog?.scopedTypes.some((type) => type === 'stopMessageSet' || type === 'stopMessageMode' || type === 'stopMessageClear'));
-        emitVirtualRouterHitLog(parsed, {
-            requestId: metadata.requestId,
-            sessionId: resolveVirtualRouterLogSessionId(metadata),
-            stopScope,
-            stopState,
-            forceStopStatusLabel
-        });
+        if (metadata.__rt?.disableVirtualRouterHitLog !== true) {
+            emitVirtualRouterHitLog(parsed, {
+                requestId: metadata.requestId,
+                sessionId: resolveVirtualRouterLogSessionId(metadata),
+                stopScope,
+                stopState,
+                forceStopStatusLabel
+            });
+        }
         return parsed;
     }
     getStopMessageState(metadata) {