plugin-sensitive-filter-xr 0.0.4 → 0.0.6

package/dist/lib/sensitiveFilter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sensitiveFilter.d.ts","sourceRoot":"","sources":["../../src/lib/sensitiveFilter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAa,oBAAoB,EAA8B,MAAM,kBAAkB,CAAA;AAGnG,OAAO,EACL,eAAe,EAGf,uBAAuB,EACvB,wBAAwB,EAEzB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAOL,qBAAqB,EAMtB,MAAM,YAAY,CAAA;AAwanB,qBAEa,yBAA0B,YAAW,wBAAwB,CAAC,qBAAqB,CAAC;IAE/F,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAY;IAEvC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CA6SlC;IAEK,gBAAgB,CACpB,OAAO,EAAE,qBAAqB,EAC9B,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,eAAe,CAAC;IAa3B,OAAO,CAAC,wBAAwB;IA+KhC,OAAO,CAAC,uBAAuB;CA2ShC;AAED,YAAY,EAAE,qBAAqB,EAAE,CAAA"}
+{"version":3,"file":"sensitiveFilter.d.ts","sourceRoot":"","sources":["../../src/lib/sensitiveFilter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAa,oBAAoB,EAA8B,MAAM,kBAAkB,CAAA;AAGnG,OAAO,EACL,eAAe,EAGf,uBAAuB,EACvB,wBAAwB,EAEzB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAOL,qBAAqB,EAMtB,MAAM,YAAY,CAAA;AAofnB,qBAEa,yBAA0B,YAAW,wBAAwB,CAAC,qBAAqB,CAAC;IAE/F,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAY;IAEvC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAqRlC;IAEK,gBAAgB,CACpB,OAAO,EAAE,qBAAqB,EAC9B,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,eAAe,CAAC;IAa3B,OAAO,CAAC,wBAAwB;IA+OhC,OAAO,CAAC,uBAAuB;CAwahC;AAED,YAAY,EAAE,qBAAqB,EAAE,CAAA"}

package/dist/lib/sensitiveFilter.js

@@ -11,7 +11,7 @@ const DEFAULT_OUTPUT_BLOCK_MESSAGE = '输出内容触发敏感策略，已拦截
 const DEFAULT_REWRITE_TEXT = '[已过滤]';
 const CONFIG_PARSE_ERROR = '敏感词过滤配置格式不正确，请检查填写内容。';
 const BUSINESS_RULES_VALIDATION_ERROR = '请至少配置 1 条有效业务规则（pattern/type/action/scope/severity），或启用通用规则包。';
-const LLM_MODE_VALIDATION_ERROR = '请完善 LLM 过滤配置：需填写过滤模型、生效范围、判定提示词、失败处理策略。';
+const LLM_MODE_VALIDATION_ERROR = '请完善 LLM 过滤配置：需填写过滤模型、生效范围、审核规则说明。';
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
@@ -212,6 +212,14 @@ function normalizeRuleDrafts(input) {
 function modeIncludesScope(scope, phase) {
     return scope === 'both' || scope === phase;
 }
+function buildInternalLlmPrompt(rulePrompt) {
+    return ('你是敏感内容审核器。请根据用户给出的审核规则判断文本是否命中敏感内容。' +
+        '\n你只能返回 JSON，不要输出额外说明。' +
+        '\nJSON字段: matched(boolean), action("block"|"rewrite"), replacementText(string), reason(string), categories(string[]).' +
+        '\n命中时请尽量给出 replacementText；未命中时返回 {"matched": false}。' +
+        '\n说明：系统会统一执行改写策略，即便你返回 action=block 也会按 rewrite 处理。' +
+        `\n\n用户审核规则：\n${rulePrompt}`);
+}
 function parseLlmDecision(raw, rewriteFallbackText) {
     let payload = raw;
     if (typeof payload === 'string') {
@@ -248,14 +256,6 @@ function parseLlmDecision(raw, rewriteFallbackText) {
             categories,
         };
     }
-    if (decision.action === 'block') {
-        return {
-            matched: true,
-            action: 'block',
-            reason,
-            categories,
-        };
-    }
     return {
         matched: true,
         action: 'rewrite',
@@ -270,30 +270,27 @@ function resolveRuntimeLlmConfig(config) {
     }
     const model = isRecord(config.model) ? config.model : null;
     const scope = toNonEmptyString(config.scope);
-    const systemPrompt = toNonEmptyString(config.systemPrompt);
-    const onLlmError = toNonEmptyString(config.onLlmError);
-    if (!model || !scope || !systemPrompt || !onLlmError) {
+    const rulePrompt = toNonEmptyString(config.rulePrompt) ?? toNonEmptyString(config.systemPrompt);
+    if (!model || !scope || !rulePrompt) {
         throw new Error(LLM_MODE_VALIDATION_ERROR);
     }
     const outputMethodRaw = toNonEmptyString(config.outputMethod);
     const outputMethod = ['functionCalling', 'jsonMode', 'jsonSchema'].includes(outputMethodRaw ?? '')
         ? outputMethodRaw
-        : 'jsonSchema';
-    const errorRewriteText = toNonEmptyString(config.errorRewriteText) ?? undefined;
-    if (onLlmError === 'rewrite' && !errorRewriteText) {
-        throw new Error('请完善 LLM 过滤配置：当失败处理为改写时，必须填写失败改写文本。');
-    }
+        : 'jsonMode';
     const timeoutMs = typeof config.timeoutMs === 'number' && Number.isFinite(config.timeoutMs) && config.timeoutMs > 0
         ? Math.min(Math.floor(config.timeoutMs), 120000)
         : undefined;
+    const legacyOnLlmError = toNonEmptyString(config.onLlmError);
+    const legacyErrorRewriteText = toNonEmptyString(config.errorRewriteText) ?? undefined;
     return {
         model,
         scope,
-        systemPrompt,
+        rulePrompt,
+        systemPrompt: buildInternalLlmPrompt(rulePrompt),
         outputMethod,
-        onLlmError,
-        errorRewriteText,
-        blockMessage: toNonEmptyString(config.blockMessage) ?? undefined,
+        legacyOnLlmError: legacyOnLlmError ?? undefined,
+        legacyErrorRewriteText,
         rewriteFallbackText: toNonEmptyString(config.rewriteFallbackText) ?? DEFAULT_REWRITE_TEXT,
         timeoutMs,
     };
@@ -317,6 +314,54 @@ function withTimeout(promise, timeoutMs) {
         });
     });
 }
+function normalizeConfigurable(input) {
+    if (!isRecord(input)) {
+        return null;
+    }
+    return input;
+}
+function buildOutputMethodCandidates(preferred) {
+    const queue = [preferred, 'functionCalling', 'jsonMode', 'jsonSchema'];
+    const unique = [];
+    for (const method of queue) {
+        if (!unique.includes(method)) {
+            unique.push(method);
+        }
+    }
+    return unique;
+}
+function getErrorText(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error ?? '');
+}
+function isUnsupportedStructuredOutputError(error) {
+    const message = getErrorText(error).toLowerCase();
+    const patterns = [
+        'response_format type is unavailable',
+        'invalid response_format',
+        'response_format',
+        'unsupported schema',
+        'not support',
+    ];
+    return patterns.some((pattern) => message.includes(pattern));
+}
+function isMissingWrapWorkflowHandlerError(error) {
+    const message = getErrorText(error).toLowerCase();
+    return message.includes('no handler found') && message.includes('wrapworkflownodeexecutioncommand');
+}
+async function runWithWrapWorkflowFallback(runTracked, runFallback) {
+    try {
+        return await runTracked();
+    }
+    catch (error) {
+        if (isMissingWrapWorkflowHandlerError(error)) {
+            return runFallback();
+        }
+        throw error;
+    }
+}
 let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
     constructor() {
         this.meta = {
@@ -534,19 +579,27 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
                                     },
                                 },
                             },
-                            systemPrompt: {
+                            rulePrompt: {
                                 type: 'string',
-                                title: { en_US: 'System Prompt', zh_Hans: '判定提示词' },
+                                title: { en_US: 'Rule Prompt', zh_Hans: '审核规则说明' },
+                                description: {
+                                    en_US: 'Describe your moderation rules in natural language. No JSON format is required.',
+                                    zh_Hans: '用自然语言描述审核规则，无需手写 JSON 格式。',
+                                },
                                 'x-ui': {
                                     component: 'textarea',
                                     span: 2,
+                                    placeholder: {
+                                        en_US: 'e.g. Rewrite violent/privacy-sensitive content into a safe neutral response.',
+                                        zh_Hans: '例如：涉及暴力或隐私泄露内容时，改写为安全中性表达。',
+                                    },
                                 },
                             },
                             outputMethod: {
                                 type: 'string',
                                 title: { en_US: 'Output Method', zh_Hans: '结构化输出方式' },
                                 enum: ['functionCalling', 'jsonMode', 'jsonSchema'],
-                                default: 'jsonSchema',
+                                default: 'jsonMode',
                                 'x-ui': {
                                     enumLabels: {
                                         functionCalling: { en_US: 'Function Calling', zh_Hans: '函数调用' },
@@ -555,25 +608,6 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
                                     },
                                 },
                             },
-                            onLlmError: {
-                                type: 'string',
-                                title: { en_US: 'On LLM Error', zh_Hans: 'LLM失败处理' },
-                                enum: ['block', 'rewrite'],
-                                'x-ui': {
-                                    enumLabels: {
-                                        block: { en_US: 'Block', zh_Hans: '拦截' },
-                                        rewrite: { en_US: 'Rewrite', zh_Hans: '改写' },
-                                    },
-                                },
-                            },
-                            errorRewriteText: {
-                                type: 'string',
-                                title: { en_US: 'Error Rewrite Text', zh_Hans: '失败改写文本' },
-                            },
-                            blockMessage: {
-                                type: 'string',
-                                title: { en_US: 'Block Message', zh_Hans: '拦截提示文本' },
-                            },
                             rewriteFallbackText: {
                                 type: 'string',
                                 title: { en_US: 'Rewrite Fallback Text', zh_Hans: '改写兜底文本' },
@@ -583,21 +617,7 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
                                 title: { en_US: 'Timeout (ms)', zh_Hans: '超时毫秒' },
                             },
                         },
-                        required: ['model', 'scope', 'systemPrompt', 'onLlmError'],
-                        allOf: [
-                            {
-                                if: {
-                                    properties: {
-                                        onLlmError: {
-                                            const: 'rewrite',
-                                        },
-                                    },
-                                },
-                                then: {
-                                    required: ['errorRewriteText'],
-                                },
-                            },
-                        ],
+                        required: ['model', 'scope', 'rulePrompt'],
                     },
                 },
                 required: ['mode'],
@@ -626,9 +646,9 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
         if (parsed.data.mode === 'llm') {
             return this.createLlmModeMiddleware(parsed.data, context);
         }
-        return this.createRuleModeMiddleware(parsed.data);
+        return this.createRuleModeMiddleware(parsed.data, context);
     }
-    createRuleModeMiddleware(config) {
+    createRuleModeMiddleware(config, context) {
         const caseSensitive = config.caseSensitive ?? false;
         const normalize = config.normalize ?? true;
         const customRules = normalizeRuleDrafts(config.rules ?? []);
@@ -669,6 +689,7 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
         let pendingInputRewrite = null;
         let finalAction = 'pass';
         let auditEntries = [];
+        let runtimeConfigurable = null;
         const resetRunState = () => {
             inputBlockedMessage = null;
             pendingInputRewrite = null;
@@ -682,10 +703,72 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
                 mode: 'rule',
             });
         };
+        const assignRuntimeConfigurable = (runtimeLike) => {
+            const configurable = normalizeConfigurable(runtimeLike?.configurable);
+            if (!configurable) {
+                return;
+            }
+            if (configurable.thread_id && configurable.executionId) {
+                runtimeConfigurable = configurable;
+            }
+        };
+        const buildAuditSnapshot = () => {
+            const summary = {
+                total: auditEntries.length,
+                matched: auditEntries.filter((entry) => entry.matched).length,
+                blocked: auditEntries.filter((entry) => entry.action === 'block').length,
+                rewritten: auditEntries.filter((entry) => entry.action === 'rewrite').length,
+                errorPolicyTriggered: auditEntries.filter((entry) => entry.errorPolicyTriggered).length,
+            };
+            return {
+                mode: 'rule',
+                finalAction,
+                records: auditEntries,
+                summary,
+            };
+        };
+        const persistAuditSnapshot = async () => {
+            const configurable = runtimeConfigurable;
+            if (!configurable?.thread_id || !configurable.executionId || !this.commandBus) {
+                return;
+            }
+            const { thread_id, checkpoint_ns, checkpoint_id, subscriber, executionId } = configurable;
+            const snapshot = buildAuditSnapshot();
+            const writeSnapshot = async () => {
+                return {
+                    state: snapshot,
+                    output: snapshot,
+                };
+            };
+            await runWithWrapWorkflowFallback(async () => {
+                await this.commandBus.execute(new WrapWorkflowNodeExecutionCommand(writeSnapshot, {
+                    execution: {
+                        category: 'workflow',
+                        type: 'middleware',
+                        title: `${context.node.title} Audit`,
+                        inputs: {
+                            mode: snapshot.mode,
+                            total: snapshot.summary.total,
+                        },
+                        parentId: executionId,
+                        threadId: thread_id,
+                        checkpointNs: checkpoint_ns,
+                        checkpointId: checkpoint_id,
+                        agentKey: context.node.key,
+                    },
+                    subscriber,
+                }));
+                return undefined;
+            }, async () => {
+                await writeSnapshot();
+                return undefined;
+            });
+        };
         return {
             name: SENSITIVE_FILTER_MIDDLEWARE_NAME,
             beforeAgent: async (state, runtime) => {
                 resetRunState();
+                assignRuntimeConfigurable(runtime);
                 if (!hasEffectiveRules) {
                     throw new Error(BUSINESS_RULES_VALIDATION_ERROR);
                 }
@@ -722,6 +805,7 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
                 return undefined;
             },
             wrapModelCall: async (request, handler) => {
+                assignRuntimeConfigurable(request?.runtime);
                 if (!hasEffectiveRules) {
                     throw new Error(BUSINESS_RULES_VALIDATION_ERROR);
                 }
@@ -762,11 +846,7 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
                 return replaceModelResponseText(response, rewrittenOutput);
             },
             afterAgent: async () => {
-                console.log('[SensitiveFilterMiddleware][audit]', JSON.stringify({
-                    mode: 'rule',
-                    finalAction,
-                    records: auditEntries,
-                }, null, 2));
+                await persistAuditSnapshot();
                 return undefined;
             },
         };
@@ -775,7 +855,7 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
         const llmDraftConfig = config.llm;
         let resolvedLlmConfig = null;
         let modelPromise = null;
-        let structuredModelPromise = null;
+        const structuredModelPromises = new Map();
         const getLlmConfig = () => {
             if (!resolvedLlmConfig) {
                 resolvedLlmConfig = resolveRuntimeLlmConfig(llmDraftConfig);
@@ -786,34 +866,36 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
             const llmConfig = getLlmConfig();
             if (!modelPromise) {
                 modelPromise = this.commandBus.execute(new CreateModelClientCommand(llmConfig.model, {
-                    usageCallback: (event) => {
-                        console.log('[SensitiveFilterMiddleware][LLM] Model Usage:', event);
-                    },
+                    usageCallback: () => { },
                 }));
             }
             return modelPromise;
         };
-        const ensureStructuredModel = async () => {
-            const llmConfig = getLlmConfig();
-            if (!structuredModelPromise) {
-                structuredModelPromise = (async () => {
+        const ensureStructuredModel = async (method) => {
+            if (!structuredModelPromises.has(method)) {
+                structuredModelPromises.set(method, (async () => {
                     const model = await ensureModel();
                     return model.withStructuredOutput?.(llmDecisionSchema, {
-                        method: llmConfig.outputMethod,
+                        method,
                     }) ?? null;
-                })();
+                })());
             }
-            return structuredModelPromise;
+            return structuredModelPromises.get(method);
         };
-        let inputBlockedMessage = null;
         let pendingInputRewrite = null;
         let finalAction = 'pass';
         let auditEntries = [];
+        let runtimeConfigurable = null;
+        let resolvedOutputMethod;
+        let fallbackTriggered = false;
+        let methodAttempts = [];
         const resetRunState = () => {
-            inputBlockedMessage = null;
             pendingInputRewrite = null;
             finalAction = 'pass';
             auditEntries = [];
+            resolvedOutputMethod = undefined;
+            fallbackTriggered = false;
+            methodAttempts = [];
         };
         const pushAudit = (entry) => {
             auditEntries.push({
@@ -822,6 +904,84 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
                 mode: 'llm',
             });
         };
+        const assignRuntimeConfigurable = (runtimeLike) => {
+            const configurable = normalizeConfigurable(runtimeLike?.configurable);
+            if (!configurable) {
+                return;
+            }
+            if (configurable.thread_id && configurable.executionId) {
+                runtimeConfigurable = configurable;
+            }
+        };
+        const captureLlmOutputTrace = (trace) => {
+            for (const method of trace.methodAttempts) {
+                if (!methodAttempts.includes(method)) {
+                    methodAttempts.push(method);
+                }
+            }
+            resolvedOutputMethod = trace.resolvedOutputMethod;
+            fallbackTriggered = fallbackTriggered || trace.fallbackTriggered;
+        };
+        const buildAuditSnapshot = () => {
+            const summary = {
+                total: auditEntries.length,
+                matched: auditEntries.filter((entry) => entry.matched).length,
+                blocked: auditEntries.filter((entry) => entry.action === 'block').length,
+                rewritten: auditEntries.filter((entry) => entry.action === 'rewrite').length,
+                errorPolicyTriggered: auditEntries.filter((entry) => entry.errorPolicyTriggered).length,
+            };
+            return {
+                mode: 'llm',
+                finalAction,
+                records: auditEntries,
+                summary,
+                llmOutput: resolvedLlmConfig
+                    ? {
+                        requestedOutputMethod: resolvedLlmConfig.outputMethod,
+                        resolvedOutputMethod,
+                        methodAttempts,
+                        fallbackTriggered,
+                    }
+                    : undefined,
+            };
+        };
+        const persistAuditSnapshot = async () => {
+            const configurable = runtimeConfigurable;
+            if (!configurable?.thread_id || !configurable.executionId || !this.commandBus) {
+                return;
+            }
+            const { thread_id, checkpoint_ns, checkpoint_id, subscriber, executionId } = configurable;
+            const snapshot = buildAuditSnapshot();
+            const writeSnapshot = async () => {
+                return {
+                    state: snapshot,
+                    output: snapshot,
+                };
+            };
+            await runWithWrapWorkflowFallback(async () => {
+                await this.commandBus.execute(new WrapWorkflowNodeExecutionCommand(writeSnapshot, {
+                    execution: {
+                        category: 'workflow',
+                        type: 'middleware',
+                        title: `${context.node.title} Audit`,
+                        inputs: {
+                            mode: snapshot.mode,
+                            total: snapshot.summary.total,
+                        },
+                        parentId: executionId,
+                        threadId: thread_id,
+                        checkpointNs: checkpoint_ns,
+                        checkpointId: checkpoint_id,
+                        agentKey: context.node.key,
+                    },
+                    subscriber,
+                }));
+                return undefined;
+            }, async () => {
+                await writeSnapshot();
+                return undefined;
+            });
+        };
         const buildEvaluationMessages = (phase, text, llmConfig) => {
             return [
                 { role: 'system', content: llmConfig.systemPrompt },
@@ -836,14 +996,49 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
         const invokeAndTrack = async (phase, text, runtime, llmConfig) => {
             const invokeCore = async () => {
                 const messages = buildEvaluationMessages(phase, text, llmConfig);
-                const [model, structuredModel] = await Promise.all([ensureModel(), ensureStructuredModel()]);
-                if (structuredModel) {
-                    return withTimeout(structuredModel.invoke(messages), llmConfig.timeoutMs);
+                const model = await ensureModel();
+                const candidates = buildOutputMethodCandidates(llmConfig.outputMethod);
+                const attempts = [];
+                for (const method of candidates) {
+                    attempts.push(method);
+                    try {
+                        const structuredModel = await ensureStructuredModel(method);
+                        if (!structuredModel) {
+                            throw new Error(`Structured output is not available for method: ${method}`);
+                        }
+                        const raw = await withTimeout(structuredModel.invoke(messages), llmConfig.timeoutMs);
+                        return {
+                            raw,
+                            trace: {
+                                requestedOutputMethod: llmConfig.outputMethod,
+                                resolvedOutputMethod: method,
+                                methodAttempts: attempts,
+                                fallbackTriggered: method !== llmConfig.outputMethod || attempts.length > 1,
+                            },
+                        };
+                    }
+                    catch (error) {
+                        if (isUnsupportedStructuredOutputError(error)) {
+                            continue;
+                        }
+                        throw error;
+                    }
                 }
-                return withTimeout(model.invoke(messages), llmConfig.timeoutMs);
+                attempts.push('plainText');
+                const raw = await withTimeout(model.invoke(messages), llmConfig.timeoutMs);
+                return {
+                    raw,
+                    trace: {
+                        requestedOutputMethod: llmConfig.outputMethod,
+                        resolvedOutputMethod: 'plainText',
+                        methodAttempts: attempts,
+                        fallbackTriggered: true,
+                    },
+                };
             };
             const parseCore = async () => {
-                const raw = await invokeCore();
+                const { raw, trace } = await invokeCore();
+                captureLlmOutputTrace(trace);
                 return parseLlmDecision(raw, llmConfig.rewriteFallbackText);
             };
             const configurable = (runtime?.configurable ?? {});
@@ -851,55 +1046,56 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
             if (!thread_id || !executionId) {
                 return parseCore();
             }
-            const tracked = await this.commandBus.execute(new WrapWorkflowNodeExecutionCommand(async () => {
-                const decision = await parseCore();
-                return {
-                    state: decision,
-                    output: decision,
-                };
-            }, {
-                execution: {
-                    category: 'workflow',
-                    type: 'middleware',
-                    inputs: {
-                        phase,
-                        text,
+            let trackedDecision = null;
+            await runWithWrapWorkflowFallback(async () => {
+                await this.commandBus.execute(new WrapWorkflowNodeExecutionCommand(async () => {
+                    const decision = await parseCore();
+                    trackedDecision = decision;
+                    return {
+                        state: decision,
+                        output: decision,
+                    };
+                }, {
+                    execution: {
+                        category: 'workflow',
+                        type: 'middleware',
+                        inputs: {
+                            phase,
+                            text,
+                        },
+                        parentId: executionId,
+                        threadId: thread_id,
+                        checkpointNs: checkpoint_ns,
+                        checkpointId: checkpoint_id,
+                        agentKey: context.node.key,
+                        title: context.node.title,
                     },
-                    parentId: executionId,
-                    threadId: thread_id,
-                    checkpointNs: checkpoint_ns,
-                    checkpointId: checkpoint_id,
-                    agentKey: context.node.key,
-                    title: context.node.title,
-                },
-                subscriber,
-            }));
-            return tracked;
+                    subscriber,
+                }));
+                return undefined;
+            }, async () => {
+                trackedDecision = await parseCore();
+                return undefined;
+            });
+            if (!trackedDecision) {
+                throw new Error('LLM decision tracking failed: no decision resolved');
+            }
+            return trackedDecision;
         };
         const resolveOnErrorDecision = (llmConfig, error) => {
             const reason = `llm-error:${error instanceof Error ? error.message : String(error)}`;
-            if (llmConfig.onLlmError === 'block') {
-                return {
-                    matched: true,
-                    action: 'block',
-                    reason,
-                };
-            }
             return {
                 matched: true,
                 action: 'rewrite',
-                replacementText: llmConfig.errorRewriteText ?? llmConfig.rewriteFallbackText,
+                replacementText: llmConfig.legacyErrorRewriteText ?? llmConfig.rewriteFallbackText,
                 reason,
             };
         };
-        const resolveBlockMessage = (llmConfig, phase) => {
-            return llmConfig.blockMessage ??
-                (phase === 'input' ? DEFAULT_INPUT_BLOCK_MESSAGE : DEFAULT_OUTPUT_BLOCK_MESSAGE);
-        };
         return {
             name: SENSITIVE_FILTER_MIDDLEWARE_NAME,
             beforeAgent: async (state, runtime) => {
                 resetRunState();
+                assignRuntimeConfigurable(runtime);
                 const llmConfig = getLlmConfig();
                 if (!modeIncludesScope(llmConfig.scope, 'input')) {
                     pushAudit({
@@ -942,20 +1138,13 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
                 if (!decision.matched || !decision.action) {
                     return undefined;
                 }
-                if (decision.action === 'block') {
-                    finalAction = 'block';
-                    inputBlockedMessage = resolveBlockMessage(llmConfig, 'input');
-                    return undefined;
-                }
                 finalAction = 'rewrite';
                 pendingInputRewrite = toNonEmptyString(decision.replacementText) ?? llmConfig.rewriteFallbackText;
                 return undefined;
             },
             wrapModelCall: async (request, handler) => {
+                assignRuntimeConfigurable(request?.runtime);
                 const llmConfig = getLlmConfig();
-                if (inputBlockedMessage) {
-                    return new AIMessage(inputBlockedMessage);
-                }
                 const modelRequest = pendingInputRewrite ? rewriteModelRequestInput(request, pendingInputRewrite) : request;
                 pendingInputRewrite = null;
                 const response = await handler(modelRequest);
@@ -1000,19 +1189,11 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
                 if (!decision.matched || !decision.action) {
                     return response;
                 }
-                if (decision.action === 'block') {
-                    finalAction = 'block';
-                    return replaceModelResponseText(response, resolveBlockMessage(llmConfig, 'output'));
-                }
                 finalAction = 'rewrite';
                 return replaceModelResponseText(response, toNonEmptyString(decision.replacementText) ?? llmConfig.rewriteFallbackText);
             },
             afterAgent: async () => {
-                console.log('[SensitiveFilterMiddleware][audit]', JSON.stringify({
-                    mode: 'llm',
-                    finalAction,
-                    records: auditEntries,
-                }, null, 2));
+                await persistAuditSnapshot();
                 return undefined;
             },
         };

package/dist/lib/types.d.ts

@@ -26,6 +26,7 @@ export type LlmErrorAction = 'block' | 'rewrite';
 export type LlmFilterConfig = {
     model?: ICopilotModel;
     scope?: LlmScope;
+    rulePrompt?: string;
     systemPrompt?: string;
     outputMethod?: LlmOutputMethod;
     onLlmError?: LlmErrorAction;
@@ -64,17 +65,17 @@ export declare const sensitiveFilterConfigSchema: z.ZodUnion<[z.ZodObject<{
         action: z.ZodNullable<z.ZodOptional<z.ZodEnum<["block", "rewrite"]>>>;
         replacementText: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     }, "strip", z.ZodTypeAny, {
-        type?: "keyword" | "regex";
         id?: string;
         pattern?: string;
+        type?: "keyword" | "regex";
         scope?: "input" | "output" | "both";
         severity?: "high" | "medium";
         action?: "block" | "rewrite";
         replacementText?: string;
     }, {
-        type?: "keyword" | "regex";
         id?: string;
         pattern?: string;
+        type?: "keyword" | "regex";
         scope?: "input" | "output" | "both";
         severity?: "high" | "medium";
         action?: "block" | "rewrite";
@@ -94,13 +95,11 @@ export declare const sensitiveFilterConfigSchema: z.ZodUnion<[z.ZodObject<{
     normalize: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     llm: z.ZodOptional<z.ZodUnknown>;
 }, "strip", z.ZodTypeAny, {
-    normalize?: boolean;
-    llm?: unknown;
     mode?: "rule";
     rules?: {
-        type?: "keyword" | "regex";
         id?: string;
         pattern?: string;
+        type?: "keyword" | "regex";
         scope?: "input" | "output" | "both";
         severity?: "high" | "medium";
         action?: "block" | "rewrite";
@@ -111,14 +110,14 @@ export declare const sensitiveFilterConfigSchema: z.ZodUnion<[z.ZodObject<{
         profile?: "strict" | "balanced";
     };
     caseSensitive?: boolean;
-}, {
     normalize?: boolean;
     llm?: unknown;
+}, {
     mode?: "rule";
     rules?: {
-        type?: "keyword" | "regex";
         id?: string;
         pattern?: string;
+        type?: "keyword" | "regex";
         scope?: "input" | "output" | "both";
         severity?: "high" | "medium";
         action?: "block" | "rewrite";
@@ -129,11 +128,14 @@ export declare const sensitiveFilterConfigSchema: z.ZodUnion<[z.ZodObject<{
         profile?: "strict" | "balanced";
     };
     caseSensitive?: boolean;
+    normalize?: boolean;
+    llm?: unknown;
 }>, z.ZodObject<{
     mode: z.ZodLiteral<"llm">;
     llm: z.ZodDefault<z.ZodNullable<z.ZodOptional<z.ZodObject<{
         model: z.ZodNullable<z.ZodOptional<z.ZodType<ICopilotModel, z.ZodTypeDef, ICopilotModel>>>;
         scope: z.ZodNullable<z.ZodOptional<z.ZodEnum<["input", "output", "both"]>>>;
+        rulePrompt: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         systemPrompt: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         outputMethod: z.ZodDefault<z.ZodOptional<z.ZodEnum<["functionCalling", "jsonMode", "jsonSchema"]>>>;
         onLlmError: z.ZodNullable<z.ZodOptional<z.ZodEnum<["block", "rewrite"]>>>;
@@ -142,8 +144,9 @@ export declare const sensitiveFilterConfigSchema: z.ZodUnion<[z.ZodObject<{
         rewriteFallbackText: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         timeoutMs: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
     }, "strip", z.ZodTypeAny, {
-        model?: ICopilotModel;
         scope?: "input" | "output" | "both";
+        model?: ICopilotModel;
+        rulePrompt?: string;
         systemPrompt?: string;
         outputMethod?: "functionCalling" | "jsonMode" | "jsonSchema";
         onLlmError?: "block" | "rewrite";
@@ -152,8 +155,9 @@ export declare const sensitiveFilterConfigSchema: z.ZodUnion<[z.ZodObject<{
         rewriteFallbackText?: string;
         timeoutMs?: number;
     }, {
-        model?: ICopilotModel;
         scope?: "input" | "output" | "both";
+        model?: ICopilotModel;
+        rulePrompt?: string;
         systemPrompt?: string;
         outputMethod?: "functionCalling" | "jsonMode" | "jsonSchema";
         onLlmError?: "block" | "rewrite";
@@ -167,10 +171,15 @@ export declare const sensitiveFilterConfigSchema: z.ZodUnion<[z.ZodObject<{
     caseSensitive: z.ZodOptional<z.ZodUnknown>;
     normalize: z.ZodOptional<z.ZodUnknown>;
 }, "strip", z.ZodTypeAny, {
+    mode?: "llm";
+    rules?: unknown;
+    generalPack?: unknown;
+    caseSensitive?: unknown;
     normalize?: unknown;
     llm?: {
-        model?: ICopilotModel;
         scope?: "input" | "output" | "both";
+        model?: ICopilotModel;
+        rulePrompt?: string;
         systemPrompt?: string;
         outputMethod?: "functionCalling" | "jsonMode" | "jsonSchema";
         onLlmError?: "block" | "rewrite";
@@ -179,15 +188,16 @@ export declare const sensitiveFilterConfigSchema: z.ZodUnion<[z.ZodObject<{
         rewriteFallbackText?: string;
         timeoutMs?: number;
     };
+}, {
     mode?: "llm";
     rules?: unknown;
     generalPack?: unknown;
     caseSensitive?: unknown;
-}, {
     normalize?: unknown;
     llm?: {
-        model?: ICopilotModel;
         scope?: "input" | "output" | "both";
+        model?: ICopilotModel;
+        rulePrompt?: string;
         systemPrompt?: string;
         outputMethod?: "functionCalling" | "jsonMode" | "jsonSchema";
         onLlmError?: "block" | "rewrite";
@@ -196,14 +206,10 @@ export declare const sensitiveFilterConfigSchema: z.ZodUnion<[z.ZodObject<{
         rewriteFallbackText?: string;
         timeoutMs?: number;
     };
-    mode?: "llm";
-    rules?: unknown;
-    generalPack?: unknown;
-    caseSensitive?: unknown;
 }>]>;
-export declare const llmDecisionSchema: z.ZodEffects<z.ZodObject<{
+export declare const llmDecisionSchema: z.ZodObject<{
     matched: z.ZodBoolean;
-    action: z.ZodOptional<z.ZodEnum<["block", "rewrite"]>>;
+    action: z.ZodNullable<z.ZodOptional<z.ZodEnum<["block", "rewrite"]>>>;
     replacementText: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     reason: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     categories: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
@@ -219,18 +225,6 @@ export declare const llmDecisionSchema: z.ZodEffects<z.ZodObject<{
     matched?: boolean;
     reason?: string;
     categories?: string[];
-}>, {
-    action?: "block" | "rewrite";
-    replacementText?: string;
-    matched?: boolean;
-    reason?: string;
-    categories?: string[];
-}, {
-    action?: "block" | "rewrite";
-    replacementText?: string;
-    matched?: boolean;
-    reason?: string;
-    categories?: string[];
 }>;
 export declare function resolveGeneralPackRules(config?: GeneralPackConfig): SensitiveRule[];
 //# sourceMappingURL=types.d.ts.map

package/dist/lib/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AACrD,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,SAAS,GAAG,OAAO,CAAA;IACzB,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAA;IAClC,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAA;IAC3B,MAAM,EAAE,OAAO,GAAG,SAAS,CAAA;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,OAAO,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAA;CAChC,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,CAAA;IAC5C,WAAW,CAAC,EAAE,iBAAiB,CAAA;IAC/B,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAA;AAClD,MAAM,MAAM,eAAe,GAAG,iBAAiB,GAAG,UAAU,GAAG,YAAY,CAAA;AAC3E,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,SAAS,CAAA;AAEhD,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,CAAC,EAAE,aAAa,CAAA;IACrB,KAAK,CAAC,EAAE,QAAQ,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,YAAY,CAAC,EAAE,eAAe,CAAA;IAE9B,UAAU,CAAC,EAAE,cAAc,CAAA;IAE3B,gBAAgB,CAAC,EAAE,MAAM,CAAA;IAEzB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,KAAK,CAAA;IACX,GAAG,CAAC,EAAE,eAAe,GAAG,IAAI,CAAA;CAC7B,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG,cAAc,GAAG,aAAa,CAAA;AAElE,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC5B,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,UAAU,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAA;CAC7B,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG,aAAa,GAAG;IAClD,KAAK,EAAE,MAAM,CAAA;IACb,iBAAiB,EAAE,MAAM,CAAA;IACzB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,mBAAmB,wSAA8R,CAAA;AAmE9T,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAuD,CAAA;AAE/F,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;EAO1B,CAAA;AAYJ,wBAAgB,uBAAuB,CAAC,MAAM,CAAC,EAAE,iBAAiB,GAAG,aAAa,EAAE,CA6CnF"}

package/dist/lib/types.js

@@ -34,8 +34,9 @@ const llmConfigSchema = z
     .object({
     model: z.custom().optional().nullable(),
     scope: z.enum(['input', 'output', 'both']).optional().nullable(),
+    rulePrompt: z.string().optional().nullable(),
     systemPrompt: z.string().optional().nullable(),
-    outputMethod: z.enum(['functionCalling', 'jsonMode', 'jsonSchema']).optional().default('jsonSchema'),
+    outputMethod: z.enum(['functionCalling', 'jsonMode', 'jsonSchema']).optional().default('jsonMode'),
     onLlmError: z.enum(['block', 'rewrite']).optional().nullable(),
     errorRewriteText: z.string().optional().nullable(),
     blockMessage: z.string().optional().nullable(),
@@ -62,19 +63,10 @@ export const sensitiveFilterConfigSchema = z.union([ruleModeConfigSchema, llmMod
 export const llmDecisionSchema = z
     .object({
     matched: z.boolean(),
-    action: z.enum(['block', 'rewrite']).optional(),
+    action: z.enum(['block', 'rewrite']).optional().nullable(),
     replacementText: z.string().optional().nullable(),
     reason: z.string().optional().nullable(),
     categories: z.array(z.string()).optional().nullable(),
-})
-    .superRefine((data, ctx) => {
-    if (data.matched && !data.action) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ['action'],
-            message: 'action is required when matched is true',
-        });
-    }
 });
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plugin-sensitive-filter-xr",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "author": {
     "name": "XpertAI",
     "url": "https://xpertai.cn"