@jsonstudio/rcc 0.90.814 → 0.90.872

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

@@ -30,20 +30,60 @@ export async function recordSnapshot(options) {
         // ignore hook errors
     });
 }
+const MAX_SNAPSHOT_QUEUE_SIZE = 2048;
+const SNAPSHOT_QUEUE_BATCH_SIZE = 64;
+const SNAPSHOT_QUEUE = [];
+let snapshotQueueDrainScheduled = false;
+function scheduleSnapshotQueueDrain() {
+    if (snapshotQueueDrainScheduled) {
+        return;
+    }
+    snapshotQueueDrainScheduled = true;
+    setImmediate(() => {
+        snapshotQueueDrainScheduled = false;
+        let processed = 0;
+        while (SNAPSHOT_QUEUE.length > 0 && processed < SNAPSHOT_QUEUE_BATCH_SIZE) {
+            const task = SNAPSHOT_QUEUE.shift();
+            if (!task) {
+                continue;
+            }
+            try {
+                task();
+            }
+            catch {
+                // snapshot write failures are non-blocking by design
+            }
+            processed += 1;
+        }
+        if (SNAPSHOT_QUEUE.length > 0) {
+            scheduleSnapshotQueueDrain();
+        }
+    });
+}
+function enqueueSnapshotTask(task) {
+    if (SNAPSHOT_QUEUE.length >= MAX_SNAPSHOT_QUEUE_SIZE) {
+        // keep newest writes; snapshot stream is best-effort and must not block request hot path
+        SNAPSHOT_QUEUE.shift();
+    }
+    SNAPSHOT_QUEUE.push(task);
+    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
+        enqueueSnapshotTask(() => {
+            void recordSnapshot({
+                stage,
+                requestId: opts.requestId,
+                endpoint,
+                folderHint: opts.folderHint,
+                providerKey: opts.providerKey,
+                groupRequestId: opts.groupRequestId,
+                data: payload
+            });
         });
     };
 }

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) {

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

@@ -1,8 +1,44 @@
 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 { resolveRccPath } from '../../runtime/user-data-paths.js';
 const pendingWrites = new Map();
+const STICKY_RUNTIME_REQUEST_ID = 'sticky-session-store';
+function isNodeErrorWithCode(error) {
+    return !!error && typeof error === 'object' && 'code' in error;
+}
+function shouldIgnoreUnlinkError(error) {
+    return isNodeErrorWithCode(error) && error.code === 'ENOENT';
+}
+function formatError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function emitStickyStoreError(code, stage, message, details) {
+    providerErrorCenter.emit({
+        code,
+        message,
+        stage,
+        timestamp: Date.now(),
+        runtime: {
+            requestId: STICKY_RUNTIME_REQUEST_ID,
+            providerProtocol: 'sticky-session-store',
+            providerType: 'internal'
+        },
+        details
+    });
+    try {
+        const op = typeof details.operation === 'string' ? details.operation : 'unknown';
+        const errMsg = typeof details.error === 'string' ? details.error : '';
+        console.warn(`[sticky-session-store] ${code} stage=${stage} op=${op}${errMsg ? ` error=${errMsg}` : ''}`);
+    }
+    catch {
+        // no-op
+    }
+}
 export class StickySessionKeyMissingError extends Error {
     key;
     constructor(key, message) {
@@ -78,9 +114,14 @@ function readPersistedStateFromFile(filepath) {
         try {
             parsed = JSON.parse(raw);
         }
-        catch {
+        catch (parseError) {
             const recovered = recoverPersistedJson(raw);
             if (!recovered) {
+                emitStickyStoreError('STICKY_STATE_READ_FAILED', 'sticky_session.read', 'failed to parse persisted sticky state JSON', {
+                    operation: 'read_parse_json',
+                    filepath,
+                    error: formatError(parseError)
+                });
                 return null;
             }
             parsed = recovered;
@@ -90,8 +131,12 @@ function readPersistedStateFromFile(filepath) {
                     : { version: 1, state: parsed };
                 atomicWriteFileSync(filepath, JSON.stringify(payload));
             }
-            catch {
-                // ignore rewrite failures
+            catch (rewriteError) {
+                emitStickyStoreError('STICKY_STATE_RECOVER_FAILED', 'sticky_session.recover', 'failed to rewrite recovered sticky state payload', {
+                    operation: 'recover_rewrite',
+                    filepath,
+                    error: formatError(rewriteError)
+                });
             }
         }
         const payload = parsed && typeof parsed.version === 'number'
@@ -102,7 +147,12 @@ function readPersistedStateFromFile(filepath) {
         }
         return deserializeRoutingInstructionState(payload);
     }
-    catch {
+    catch (error) {
+        emitStickyStoreError('STICKY_STATE_READ_FAILED', 'sticky_session.read', 'failed to read sticky session state from disk', {
+            operation: 'read_file',
+            filepath,
+            error: formatError(error)
+        });
         return null;
     }
 }
@@ -137,8 +187,14 @@ export function saveRoutingInstructionStateAsync(key, state) {
                 try {
                     await fs.promises.unlink(filepath);
                 }
-                catch {
-                    // ignore unlink errors (e.g. ENOENT)
+                catch (error) {
+                    if (!shouldIgnoreUnlinkError(error)) {
+                        emitStickyStoreError('STICKY_STATE_PERSIST_FAILED', 'sticky_session.persist', 'failed to unlink sticky session state file', {
+                            operation: 'unlink',
+                            filepath,
+                            error: formatError(error)
+                        });
+                    }
                 }
             });
         }
@@ -154,14 +210,24 @@ export function saveRoutingInstructionStateAsync(key, state) {
             try {
                 await fs.promises.mkdir(dir, { recursive: true });
             }
-            catch {
-                // ignore mkdir errors; write below will fail silently
+            catch (error) {
+                emitStickyStoreError('STICKY_STATE_PERSIST_FAILED', 'sticky_session.persist', 'failed to create sticky session state directory', {
+                    operation: 'mkdir',
+                    filepath,
+                    dir,
+                    error: formatError(error)
+                });
             }
             try {
                 await atomicWriteFile(filepath, JSON.stringify(payload));
             }
-            catch {
-                // ignore async write failures
+            catch (error) {
+                emitStickyStoreError('STICKY_STATE_PERSIST_FAILED', 'sticky_session.persist', 'failed to persist sticky session state file', {
+                    operation: 'write',
+                    filepath,
+                    dir,
+                    error: formatError(error)
+                });
             }
         });
     }
@@ -179,8 +245,14 @@ export function saveRoutingInstructionStateSync(key, state) {
             try {
                 fs.unlinkSync(filepath);
             }
-            catch {
-                // ignore unlink failures
+            catch (error) {
+                if (!shouldIgnoreUnlinkError(error)) {
+                    emitStickyStoreError('STICKY_STATE_PERSIST_FAILED', 'sticky_session.persist', 'failed to unlink sticky session state file', {
+                        operation: 'unlinkSync',
+                        filepath,
+                        error: formatError(error)
+                    });
+                }
             }
         }
         return;
@@ -194,14 +266,24 @@ export function saveRoutingInstructionStateSync(key, state) {
         try {
             fs.mkdirSync(dir, { recursive: true });
         }
-        catch {
-            // ignore mkdir errors
+        catch (error) {
+            emitStickyStoreError('STICKY_STATE_PERSIST_FAILED', 'sticky_session.persist', 'failed to create sticky session state directory', {
+                operation: 'mkdirSync',
+                filepath,
+                dir,
+                error: formatError(error)
+            });
         }
         try {
             atomicWriteFileSync(filepath, JSON.stringify(payload));
         }
-        catch {
-            // ignore sync write failures
+        catch (error) {
+            emitStickyStoreError('STICKY_STATE_PERSIST_FAILED', 'sticky_session.persist', 'failed to persist sticky session state file', {
+                operation: 'writeSync',
+                filepath,
+                dir,
+                error: formatError(error)
+            });
         }
     }
 }
@@ -209,8 +291,12 @@ function scheduleWrite(filepath, task) {
     const previous = pendingWrites.get(filepath) ?? Promise.resolve();
     const next = previous
         .then(task)
-        .catch(() => {
-        // swallow errors
+        .catch((error) => {
+        emitStickyStoreError('STICKY_STATE_PERSIST_FAILED', 'sticky_session.persist', 'unexpected sticky session async write task failure', {
+            operation: 'scheduleWrite',
+            filepath,
+            error: formatError(error)
+        });
     })
         .finally(() => {
         if (pendingWrites.get(filepath) === next) {