@jsonstudio/rcc 0.90.876 → 0.90.1270

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

@@ -14,6 +14,26 @@ const RESPONSE_FILTER_STAGES = [
     'response_post',
     'response_finalize'
 ];
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.stack || `${error.name}: ${error.message}`;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function logToolFilterNonBlockingError(stage, error, details) {
+    try {
+        const detailSuffix = Object.keys(details).length > 0 ? ` details=${JSON.stringify(details)}` : '';
+        console.warn(`[tool-filter-pipeline] ${stage} failed (non-blocking): ${formatUnknownError(error)}${detailSuffix}`);
+    }
+    catch {
+        // Never throw from non-blocking logging.
+    }
+}
 function assertStageCoverage(label, registeredStages, skeletonStages) {
     const allowed = new Set(skeletonStages);
     const uncovered = [];
@@ -62,8 +82,12 @@ export async function runChatRequestToolFilters(chatRequest, options = {}) {
             const { RequestToolListFilter } = await import('../../filters/index.js');
             register(new RequestToolListFilter());
         }
-        catch {
-            /* optional */
+        catch (error) {
+            logToolFilterNonBlockingError('request.import.RequestToolListFilter', error, {
+                requestId: reqCtxBase.requestId,
+                endpoint: reqCtxBase.endpoint,
+                profile: reqCtxBase.profile
+            });
         }
     }
     const { RequestToolCallsStringifyFilter, RequestToolChoicePolicyFilter } = await import('../../filters/index.js');
@@ -82,14 +106,24 @@ export async function runChatRequestToolFilters(chatRequest, options = {}) {
             return '{}';
         } })());
     }
-    catch { /* ignore */ }
+    catch (error) {
+        logToolFilterNonBlockingError('request.loadFieldMapConfig', error, {
+            requestId: reqCtxBase.requestId,
+            endpoint: reqCtxBase.endpoint,
+            profile: reqCtxBase.profile
+        });
+    }
     try {
         const { RequestOpenAIToolsNormalizeFilter, ToolPostConstraintsFilter } = await import('../../filters/index.js');
         register(new RequestOpenAIToolsNormalizeFilter());
         register(new ToolPostConstraintsFilter('request_finalize'));
     }
-    catch {
-        // optional; keep prior behavior when filter not available
+    catch (error) {
+        logToolFilterNonBlockingError('request.import.RequestOpenAIToolsNormalizeFilter', error, {
+            requestId: reqCtxBase.requestId,
+            endpoint: reqCtxBase.endpoint,
+            profile: reqCtxBase.profile
+        });
     }
     assertStageCoverage('request', registeredStages, REQUEST_FILTER_STAGES);
     let staged = preFiltered;
@@ -130,8 +164,12 @@ export async function runChatResponseToolFilters(chatJson, options = {}) {
             chatJson = normalizeChatResponseReasoningTools(chatJson, 'reasoning_choice');
         }
     }
-    catch {
-        // best-effort; do not block response flow on reasoning parsing issues
+    catch (error) {
+        logToolFilterNonBlockingError('response.normalizeChatResponseReasoningTools', error, {
+            requestId: resCtxBase.requestId,
+            endpoint: resCtxBase.endpoint,
+            profile: resCtxBase.profile
+        });
     }
     const engine = new FilterEngine();
     const registeredStages = new Set();
@@ -144,7 +182,13 @@ export async function runChatResponseToolFilters(chatJson, options = {}) {
     try {
         register(new ResponseToolArgumentsSchemaConvergeFilter());
     }
-    catch { /* optional */ }
+    catch (error) {
+        logToolFilterNonBlockingError('response.register.ResponseToolArgumentsSchemaConvergeFilter', error, {
+            requestId: resCtxBase.requestId,
+            endpoint: resCtxBase.endpoint,
+            profile: resCtxBase.profile
+        });
+    }
     register(new ResponseToolArgumentsBlacklistFilter());
     register(new ResponseToolArgumentsStringifyFilter());
     register(new ResponseFinishInvariantsFilter());
@@ -159,7 +203,13 @@ export async function runChatResponseToolFilters(chatJson, options = {}) {
             return '{}';
         } })());
     }
-    catch { /* ignore */ }
+    catch (error) {
+        logToolFilterNonBlockingError('response.loadFieldMapConfig', error, {
+            requestId: resCtxBase.requestId,
+            endpoint: resCtxBase.endpoint,
+            profile: resCtxBase.profile
+        });
+    }
     assertStageCoverage('response', registeredStages, RESPONSE_FILTER_STAGES);
     let staged = chatJson;
     for (const stage of RESPONSE_FILTER_STAGES) {

package/node_modules/@jsonstudio/llms/dist/conversion/shared/tool-governor-guards.d.ts

@@ -1,4 +1,4 @@
-import type { ToolValidationOptions } from '../../tools/tool-registry.js';
+import { type ToolValidationOptions } from '../../tools/tool-registry.js';
 type Unknown = Record<string, unknown>;
 export declare function resolveExecCommandGuardValidationOptions(payload: Unknown): ToolValidationOptions | undefined;
 export declare function rewriteExecCommandApplyPatchCall(fn: Record<string, unknown> | undefined): boolean;

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

@@ -223,56 +223,67 @@ export function buildBlockedApplyPatchArgs(rawArgs, reason, message) {
 }
 const EXEC_COMMAND_NAME_AS_COMMAND_PATTERN = /^(?:rg|wc|cat|ls|find|grep|git|sed|head|tail|awk|bash|sh|zsh|node|npm|pnpm|yarn|bd|echo|cp|mv|rm|mkdir|python|python3|perl|ruby)\b/i;
 export function repairCommandNameAsExecToolCall(fn, validationOptions) {
+    if (!fn || typeof fn !== 'object') {
+        return false;
+    }
+    const rawName = typeof fn.name === 'string' ? String(fn.name).trim() : '';
+    if (!rawName) {
+        return false;
+    }
+    const lowered = rawName.toLowerCase();
+    if (lowered === 'exec_command' ||
+        lowered === 'execute_command' ||
+        lowered === 'execute-command' ||
+        lowered === 'shell_command' ||
+        lowered === 'shell' ||
+        lowered === 'bash' ||
+        lowered === 'terminal') {
+        return false;
+    }
+    if (!EXEC_COMMAND_NAME_AS_COMMAND_PATTERN.test(rawName)) {
+        return false;
+    }
+    const argsStr = repairArgumentsToString(fn.arguments);
+    let parsed = {};
     try {
-        if (!fn)
-            return false;
-        const rawName = typeof fn.name === 'string' ? String(fn.name).trim() : '';
-        if (!rawName)
-            return false;
-        const lowered = rawName.toLowerCase();
-        if (lowered === 'exec_command' || lowered === 'shell_command' || lowered === 'shell' || lowered === 'bash') {
-            return false;
+        const json = JSON.parse(argsStr);
+        if (json && typeof json === 'object' && !Array.isArray(json)) {
+            parsed = json;
         }
-        if (!EXEC_COMMAND_NAME_AS_COMMAND_PATTERN.test(rawName)) {
-            return false;
-        }
-        const repaired = repairArgumentsToString(fn.arguments);
-        let parsed;
-        try {
-            parsed = JSON.parse(repaired);
-        }
-        catch {
-            parsed = parseLenient(repaired);
-        }
-        const argsObj = parsed && typeof parsed === 'object' && !Array.isArray(parsed)
-            ? { ...parsed }
-            : {};
-        const existingCmd = typeof argsObj.cmd === 'string' && String(argsObj.cmd).trim().length
-            ? String(argsObj.cmd).trim()
-            : typeof argsObj.command === 'string' && String(argsObj.command).trim().length
-                ? String(argsObj.command).trim()
-                : '';
-        const cmd = existingCmd || rawName;
-        argsObj.cmd = cmd;
-        argsObj.command = cmd;
-        if (typeof argsObj.cwd === 'string' && (!argsObj.workdir || typeof argsObj.workdir !== 'string')) {
-            argsObj.workdir = String(argsObj.cwd);
+    }
+    catch {
+        const lenient = parseLenient(argsStr);
+        if (lenient && typeof lenient === 'object' && !Array.isArray(lenient)) {
+            parsed = lenient;
         }
-        const validation = validateToolCall('exec_command', JSON.stringify(argsObj), validationOptions);
-        if (validation.ok && typeof validation.normalizedArgs === 'string') {
-            fn.arguments = validation.normalizedArgs;
+    }
+    const hasExplicitCommand = typeof parsed.cmd === 'string' ||
+        typeof parsed.command === 'string' ||
+        typeof parsed.toon === 'string' ||
+        typeof parsed.script === 'string';
+    const normalized = {
+        ...parsed,
+        ...(hasExplicitCommand ? {} : { cmd: rawName })
+    };
+    let nextArgs = '{}';
+    try {
+        const validation = validateToolCall('exec_command', JSON.stringify(normalized), validationOptions);
+        if (validation && validation.ok && typeof validation.normalizedArgs === 'string') {
+            nextArgs = validation.normalizedArgs;
         }
         else {
-            const fallback = { cmd, command: cmd };
-            if (typeof argsObj.workdir === 'string' && String(argsObj.workdir).trim().length > 0) {
-                fallback.workdir = String(argsObj.workdir).trim();
-            }
-            fn.arguments = JSON.stringify(fallback);
+            nextArgs = JSON.stringify(normalized);
         }
-        fn.name = 'exec_command';
-        return true;
     }
     catch {
-        return false;
+        try {
+            nextArgs = JSON.stringify(normalized);
+        }
+        catch {
+            nextArgs = '{}';
+        }
     }
+    fn.name = 'exec_command';
+    fn.arguments = nextArgs;
+    return true;
 }

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

@@ -7,7 +7,8 @@ import { validateToolCall } from '../../tools/tool-registry.js';
 import { captureApplyPatchRegression } from '../../tools/patch-regression-capturer.js';
 import { normalizeExecCommandArgs } from '../../tools/exec-command/normalize.js';
 import { buildBlockedApplyPatchArgs, buildBlockedExecCommandArgs, injectNestedApplyPatchPolicyNotice, repairCommandNameAsExecToolCall, resolveExecCommandGuardValidationOptions, rewriteExecCommandApplyPatchCall } from './tool-governor-guards.js';
-import { normalizeChatResponseReasoningToolsWithNative } from '../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
+import { applyRespProcessToolGovernanceWithNative, prepareRespProcessToolGovernancePayloadWithNative } from '../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
+import { normalizeChatResponseReasoningToolsWithNative as normalizeChatResponseReasoningToolsLegacy } from '../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
 import { parseLenientJsonishWithNative as parseLenient, repairArgumentsToStringWithNative as repairArgumentsToString } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 import { resolveRccPath } from '../../runtime/user-data-paths.js';
 function isObject(v) { return !!v && typeof v === 'object' && !Array.isArray(v); }
@@ -34,7 +35,7 @@ function tryWriteSnapshot(options, stage, data) {
         const ep = String(snap.endpoint || 'chat').toLowerCase();
         const group = ep.includes('responses') ? 'openai-responses' : ep.includes('messages') ? 'anthropic-messages' : 'openai-chat';
         const rid = String(snap.requestId || `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`);
-        const dir = path.join(base, group, '__pending__', rid);
+        const dir = path.join(base, group, rid);
         const file = path.join(dir, `govern-${stage}.json`);
         if (fs.existsSync(file))
             return; // 不重复
@@ -46,6 +47,26 @@ function tryWriteSnapshot(options, stage, data) {
         logToolGovernorNonBlocking(`snapshot_write:${stage}`, error);
     }
 }
+function hasRecoveredResponseToolCalls(payload) {
+    const choices = Array.isArray(payload?.choices) ? payload.choices : [];
+    return choices.some((choice) => {
+        const toolCalls = Array.isArray(choice?.message?.tool_calls) ? choice.message.tool_calls : [];
+        return toolCalls.length > 0;
+    });
+}
+function shouldAttemptLegacyNamedToolSalvage(payload) {
+    try {
+        const raw = JSON.stringify(payload ?? {});
+        if (!raw)
+            return false;
+        const hasToolCallsMarker = /"tool_calls"|'tool_calls'|\btool_calls\b/i.test(raw);
+        const hasExplicitNameMarker = /\\"name\\"\s*:|"name"\s*:|'name'\s*:|\bname\s*:/i.test(raw);
+        return hasToolCallsMarker && hasExplicitNameMarker;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Process OpenAI Chat request (messages/tools) with unified 标准 governance.
  * - Augment tools (strict schemas)
@@ -145,7 +166,7 @@ export function normalizeApplyPatchToolCallsOnResponse(chat) {
                         fn.arguments = validation.normalizedArgs;
                     }
                     else if (validation && !validation.ok) {
-                        fn.arguments = buildBlockedApplyPatchArgs(rawArgs, validation.reason, validation.message);
+                        fn.arguments = argsStr;
                         try {
                             const reason = validation.reason ?? 'unknown';
                             captureApplyPatchRegression({
@@ -393,11 +414,30 @@ function enhanceResponseToolArguments(chat) {
                     }
                     else if (name === 'exec_command') {
                         const validation = validateToolCall('exec_command', repaired, validationOptions);
-                        if (validation.ok && typeof validation.normalizedArgs === 'string') {
+                        if (validation && validation.ok && typeof validation.normalizedArgs === 'string') {
                             finalStr = validation.normalizedArgs;
                         }
-                        else if (!validation.ok) {
-                            finalStr = buildBlockedExecCommandArgs(repaired, validation.reason, validation.message);
+                        else {
+                            let parsed;
+                            try {
+                                parsed = JSON.parse(repaired);
+                            }
+                            catch (error) {
+                                logToolGovernorNonBlocking('enhance_response_tool_arguments_exec_command_parse_json', error);
+                                parsed = parseLenient(repaired);
+                            }
+                            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                                const normalized = normalizeExecCommandArgs(parsed);
+                                if (normalized.ok) {
+                                    try {
+                                        finalStr = JSON.stringify(normalized.normalized ?? {});
+                                    }
+                                    catch (error) {
+                                        logToolGovernorNonBlocking('enhance_response_tool_arguments_exec_command_json_stringify', error);
+                                        finalStr = repaired;
+                                    }
+                                }
+                            }
                         }
                     }
                     if (fn)
@@ -435,8 +475,22 @@ export function processChatResponseTools(resp) {
     if (!isObject(resp))
         return resp;
     try {
-        const canon = normalizeChatResponseReasoningToolsWithNative(resp);
-        const withPatch = normalizeApplyPatchToolCallsOnResponse(canon);
+        const requestId = `tool_governor_${Date.now()}`;
+        const prepared = prepareRespProcessToolGovernancePayloadWithNative(resp);
+        const governed = applyRespProcessToolGovernanceWithNative({
+            payload: prepared.preparedPayload,
+            clientProtocol: 'openai-chat',
+            entryEndpoint: '/v1/chat/completions',
+            requestId
+        });
+        let canonical = governed.governedPayload;
+        if (!hasRecoveredResponseToolCalls(canonical) && shouldAttemptLegacyNamedToolSalvage(resp)) {
+            const salvaged = normalizeChatResponseReasoningToolsLegacy(resp);
+            if (hasRecoveredResponseToolCalls(salvaged)) {
+                canonical = salvaged;
+            }
+        }
+        const withPatch = normalizeApplyPatchToolCallsOnResponse(canonical);
         return enhanceResponseToolArguments(withPatch);
     }
     catch (error) {

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

@@ -1,4 +1,86 @@
 import { shouldRecordSnapshotsWithNative, writeSnapshotViaHooksWithNative } from '../router/virtual-router/engine-selection/native-snapshot-hooks.js';
+const DEFAULT_SNAPSHOT_ALLOWED_STAGES = Object.freeze([
+    'provider-request',
+    'provider-response'
+]);
+let cachedSnapshotStageSelector = '';
+let cachedSnapshotStagePolicy = null;
+function normalizeStageToken(value) {
+    return value.trim().toLowerCase();
+}
+function splitStageTokens(raw) {
+    return raw
+        .split(/[,\s]+/)
+        .map((token) => normalizeStageToken(token))
+        .filter((token) => token.length > 0);
+}
+function readSnapshotStageSelector() {
+    return String(process.env.ROUTECODEX_SNAPSHOT_STAGES
+        ?? process.env.RCC_SNAPSHOT_STAGES
+        ?? '').trim();
+}
+function compileSnapshotStagePolicy(selectorRaw) {
+    const selector = selectorRaw.trim();
+    if (!selector) {
+        return {
+            allowAll: false,
+            exact: new Set(DEFAULT_SNAPSHOT_ALLOWED_STAGES),
+            prefixes: []
+        };
+    }
+    const tokens = splitStageTokens(selector);
+    if (!tokens.length) {
+        return {
+            allowAll: false,
+            exact: new Set(DEFAULT_SNAPSHOT_ALLOWED_STAGES),
+            prefixes: []
+        };
+    }
+    if (tokens.some((token) => token === '*' || token === 'all')) {
+        return {
+            allowAll: true,
+            exact: new Set(),
+            prefixes: []
+        };
+    }
+    const exact = new Set();
+    const prefixes = [];
+    for (const token of tokens) {
+        if (token.endsWith('*') && token.length > 1) {
+            prefixes.push(token.slice(0, -1));
+            continue;
+        }
+        exact.add(token);
+    }
+    return {
+        allowAll: false,
+        exact,
+        prefixes
+    };
+}
+function resolveSnapshotStagePolicy() {
+    const selector = readSnapshotStageSelector();
+    if (cachedSnapshotStagePolicy && cachedSnapshotStageSelector === selector) {
+        return cachedSnapshotStagePolicy;
+    }
+    cachedSnapshotStageSelector = selector;
+    cachedSnapshotStagePolicy = compileSnapshotStagePolicy(selector);
+    return cachedSnapshotStagePolicy;
+}
+function shouldCaptureSnapshotStage(stage) {
+    const normalized = normalizeStageToken(stage || '');
+    if (!normalized) {
+        return false;
+    }
+    const policy = resolveSnapshotStagePolicy();
+    if (policy.allowAll) {
+        return true;
+    }
+    if (policy.exact.has(normalized)) {
+        return true;
+    }
+    return policy.prefixes.some((prefix) => normalized.startsWith(prefix));
+}
 export function shouldRecordSnapshots() {
     return shouldRecordSnapshotsWithNative();
 }
@@ -17,6 +99,8 @@ export async function writeSnapshotViaHooks(options) {
 export async function recordSnapshot(options) {
     if (!shouldRecordSnapshots())
         return;
+    if (!shouldCaptureSnapshotStage(options.stage))
+        return;
     const endpoint = options.endpoint || '/v1/chat/completions';
     const prepared = coerceSnapshotPayloadForWrite(options.stage, options.data);
     void writeSnapshotViaHooks({
@@ -48,6 +132,28 @@ function resolvePositiveIntegerFromEnv(names, fallback) {
     }
     return fallback;
 }
+function resolveBoolFromEnv(names, fallback) {
+    for (const name of names) {
+        const raw = String(process.env[name] ?? '').trim().toLowerCase();
+        if (!raw) {
+            continue;
+        }
+        if (raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on') {
+            return true;
+        }
+        if (raw === '0' || raw === 'false' || raw === 'no' || raw === 'off') {
+            return false;
+        }
+    }
+    return fallback;
+}
+function shouldPreserveFullSnapshotPayload(stage) {
+    if (resolveBoolFromEnv(['ROUTECODEX_SNAPSHOT_FULL', 'RCC_SNAPSHOT_FULL'], false)) {
+        return true;
+    }
+    const normalized = String(stage || '').trim().toLowerCase();
+    return normalized.startsWith('provider-request') || normalized.startsWith('provider-response');
+}
 function resolveSnapshotPayloadMaxBytes() {
     return resolvePositiveIntegerFromEnv(['ROUTECODEX_SNAPSHOT_PAYLOAD_MAX_BYTES', 'RCC_SNAPSHOT_PAYLOAD_MAX_BYTES'], DEFAULT_SNAPSHOT_PAYLOAD_MAX_BYTES);
 }
@@ -149,6 +255,13 @@ function summarizeSnapshotPayload(value) {
     };
 }
 function coerceSnapshotPayloadForWrite(stage, payload) {
+    if (shouldPreserveFullSnapshotPayload(stage)) {
+        const estimatedBytes = estimateSnapshotPayloadBytes(payload, { maxBytes: Number.POSITIVE_INFINITY });
+        return {
+            data: payload,
+            sizeBytes: Math.max(1, estimatedBytes)
+        };
+    }
     const maxBytes = resolveSnapshotPayloadMaxBytes();
     const estimatedBytes = estimateSnapshotPayloadBytes(payload, { maxBytes: maxBytes + 1 });
     if (estimatedBytes <= maxBytes) {
@@ -158,14 +271,8 @@ function coerceSnapshotPayloadForWrite(stage, payload) {
         };
     }
     return {
-        data: {
-            __snapshot_truncated: true,
-            stage,
-            maxBytes,
-            estimatedBytes,
-            summary: summarizeSnapshotPayload(payload)
-        },
-        sizeBytes: 512
+        data: undefined,
+        sizeBytes: 0
     };
 }
 function scheduleSnapshotQueueDrain() {
@@ -217,7 +324,13 @@ export function createSnapshotWriter(opts) {
     }
     const endpoint = opts.endpoint || '/v1/chat/completions';
     return (stage, payload) => {
+        if (!shouldCaptureSnapshotStage(stage)) {
+            return;
+        }
         const prepared = coerceSnapshotPayloadForWrite(stage, payload);
+        if (prepared.data === undefined) {
+            return;
+        }
         enqueueSnapshotTask(() => {
             void recordSnapshot({
                 stage,

package/node_modules/@jsonstudio/llms/dist/filters/engine.js

@@ -1,5 +1,25 @@
 import { writeFilterSnapshot } from './utils/snapshot-writer.js';
 // Lightweight, dependency-free filter engine. Field-mapping supports a minimal dot-path subset.
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.stack || `${error.name}: ${error.message}`;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function logFilterEngineNonBlockingError(stage, error, details) {
+    try {
+        const detailSuffix = Object.keys(details).length > 0 ? ` details=${JSON.stringify(details)}` : '';
+        console.warn(`[filter-engine] ${stage} failed (non-blocking): ${formatUnknownError(error)}${detailSuffix}`);
+    }
+    catch {
+        // Never throw from non-blocking logging.
+    }
+}
 export class FilterEngine {
     filters = [];
     fieldMap;
@@ -13,7 +33,14 @@ export class FilterEngine {
         try {
             await writeFilterSnapshot({ requestId: ctx.requestId, endpoint: ctx.endpoint, profile: ctx.profile, stage, tag: 'begin', data: out });
         }
-        catch { /* ignore */ }
+        catch (error) {
+            logFilterEngineNonBlockingError('snapshot.begin', error, {
+                requestId: ctx.requestId,
+                endpoint: ctx.endpoint,
+                profile: ctx.profile,
+                stage
+            });
+        }
         // stage pre filters
         for (const f of this.filters) {
             if (f.stage !== stage)
@@ -25,7 +52,15 @@ export class FilterEngine {
             try {
                 await writeFilterSnapshot({ requestId: ctx.requestId, endpoint: ctx.endpoint, profile: ctx.profile, stage, name: f.name, tag: 'after', data: out });
             }
-            catch { /* ignore */ }
+            catch (error) {
+                logFilterEngineNonBlockingError('snapshot.after_filter', error, {
+                    requestId: ctx.requestId,
+                    endpoint: ctx.endpoint,
+                    profile: ctx.profile,
+                    stage,
+                    filter: f.name
+                });
+            }
         }
         // field map in map stages
         if (stage === 'request_map' || stage === 'response_map') {
@@ -33,17 +68,38 @@ export class FilterEngine {
             try {
                 await writeFilterSnapshot({ requestId: ctx.requestId, endpoint: ctx.endpoint, profile: ctx.profile, stage, tag: 'map_before', data: out });
             }
-            catch { /* ignore */ }
+            catch (error) {
+                logFilterEngineNonBlockingError('snapshot.map_before', error, {
+                    requestId: ctx.requestId,
+                    endpoint: ctx.endpoint,
+                    profile: ctx.profile,
+                    stage
+                });
+            }
             out = this.applyFieldMap(out, rules);
             try {
                 await writeFilterSnapshot({ requestId: ctx.requestId, endpoint: ctx.endpoint, profile: ctx.profile, stage, tag: 'map_after', data: out });
             }
-            catch { /* ignore */ }
+            catch (error) {
+                logFilterEngineNonBlockingError('snapshot.map_after', error, {
+                    requestId: ctx.requestId,
+                    endpoint: ctx.endpoint,
+                    profile: ctx.profile,
+                    stage
+                });
+            }
         }
         try {
             await writeFilterSnapshot({ requestId: ctx.requestId, endpoint: ctx.endpoint, profile: ctx.profile, stage, tag: 'end', data: out });
         }
-        catch { /* ignore */ }
+        catch (error) {
+            logFilterEngineNonBlockingError('snapshot.end', error, {
+                requestId: ctx.requestId,
+                endpoint: ctx.endpoint,
+                profile: ctx.profile,
+                stage
+            });
+        }
         return out;
     }
     applyFieldMap(input, rules) {
@@ -162,6 +218,8 @@ export class FilterEngine {
                 cur = cur[p];
             }
         }
-        catch { /* ignore */ }
+        catch (error) {
+            logFilterEngineNonBlockingError('set_by_path', error, { path });
+        }
     }
 }