plugin-sensitive-filter-xr 0.0.1

package/README.md

@@ -0,0 +1,64 @@
+# Xpert Plugin: Sensitive Filter Middleware
+
+`@xpert-ai/plugin-sensitive-filter` 为智能体提供输入/输出敏感内容过滤能力。
+
+## 功能说明
+
+- `beforeAgent`：检测输入命中，决策 `block / rewrite`
+- `wrapModelCall`：
+  - 输入命中 `block`：直接返回拦截提示，不调用模型
+  - 输入命中 `rewrite`：先改写最后一条 human 消息，再调用模型
+  - 输出命中后再次执行 `block / rewrite`
+- `afterAgent`：空实现（不输出审计日志）
+
+## 规则与优先级
+
+- 支持规则类型：`keyword`、`regex`
+- 支持生效范围：`input`、`output`、`both`
+- 冲突优先级：`high > medium`；同级按配置顺序第一条
+- `rewrite` 为整句替换，不做局部替换
+- `normalize=true` 时执行文本标准化（trim + 空白折叠 + 大小写归一）
+- regex 在中间件初始化时预编译，非法 pattern 会直接抛错
+
+## 配置接口
+
+```ts
+type SensitiveRule = {
+  id: string;
+  pattern: string;
+  type: 'keyword' | 'regex';
+  scope: 'input' | 'output' | 'both';
+  severity: 'high' | 'medium';
+  action: 'block' | 'rewrite';
+  replacementText?: string;
+};
+
+type GeneralPackConfig = {
+  enabled?: boolean;          // default false
+  profile?: 'strict' | 'balanced'; // default balanced
+};
+
+type SensitiveFilterConfig = {
+  rules?: Array<Partial<SensitiveRule> | null>; // 允许空，支持仅通用规则包
+  generalPack?: GeneralPackConfig;
+  caseSensitive?: boolean;    // default false
+  normalize?: boolean;        // default true
+};
+```
+
+## 通用规则包（General Pack）
+
+- `enabled=false`：不启用通用规则
+- `enabled=true, profile=balanced`：词库较小，命中后整句替换
+- `enabled=true, profile=strict`：词库更广，命中后直接拦截
+
+说明：通用规则包用于无内建审核能力的本地模型兜底，业务规则仍建议按场景自行配置。
+
+## 开发验证
+
+```bash
+pnpm -C xpertai exec nx build @xpert-ai/plugin-sensitive-filter
+pnpm -C xpertai exec nx test @xpert-ai/plugin-sensitive-filter
+pnpm -C plugin-dev-harness build
+node plugin-dev-harness/dist/index.js --workspace ./xpertai --plugin @xpert-ai/plugin-sensitive-filter
+```

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import type { XpertPlugin } from '@xpert-ai/plugin-sdk';
+declare const ConfigSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+declare const plugin: XpertPlugin<z.infer<typeof ConfigSchema>>;
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAexD,QAAA,MAAM,YAAY,gDAChB,CAAC;AAEH,QAAA,MAAM,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CA2BrD,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/index.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { SensitiveFilterPlugin } from './lib/sensitive-filter.module.js';
+import { SensitiveFilterIcon } from './lib/types.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf8'));
+const ConfigSchema = z.object({});
+const plugin = {
+    meta: {
+        name: packageJson.name,
+        version: packageJson.version,
+        category: 'middleware',
+        icon: {
+            type: 'svg',
+            value: SensitiveFilterIcon,
+        },
+        displayName: 'Sensitive Filter Middleware',
+        description: 'Filter sensitive content for agent input and model output with business rules and optional general pack.',
+        keywords: ['agent', 'middleware', 'sensitive', 'security', 'compliance'],
+        author: 'XpertAI Team',
+    },
+    config: {
+        schema: ConfigSchema,
+    },
+    register(ctx) {
+        ctx.logger.log('register sensitive filter middleware plugin');
+        return { module: SensitiveFilterPlugin, global: true };
+    },
+    async onStart(ctx) {
+        ctx.logger.log('sensitive filter middleware plugin started');
+    },
+    async onStop(ctx) {
+        ctx.logger.log('sensitive filter middleware plugin stopped');
+    },
+};
+export default plugin;

package/dist/lib/sensitive-filter.module.d.ts

@@ -0,0 +1,7 @@
+import { IOnPluginBootstrap, IOnPluginDestroy } from '@xpert-ai/plugin-sdk';
+export declare class SensitiveFilterPlugin implements IOnPluginBootstrap, IOnPluginDestroy {
+    private logEnabled;
+    onPluginBootstrap(): void | Promise<void>;
+    onPluginDestroy(): void | Promise<void>;
+}
+//# sourceMappingURL=sensitive-filter.module.d.ts.map

package/dist/lib/sensitive-filter.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sensitive-filter.module.d.ts","sourceRoot":"","sources":["../../src/lib/sensitive-filter.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAI/F,qBAIa,qBAAsB,YAAW,kBAAkB,EAAE,gBAAgB;IAChF,OAAO,CAAC,UAAU,CAAQ;IAE1B,iBAAiB,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAMzC,eAAe,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAKxC"}

package/dist/lib/sensitive-filter.module.js

@@ -0,0 +1,27 @@
+var SensitiveFilterPlugin_1;
+import { __decorate } from "tslib";
+import { XpertServerPlugin } from '@xpert-ai/plugin-sdk';
+import chalk from 'chalk';
+import { SensitiveFilterMiddleware } from './sensitiveFilter.js';
+let SensitiveFilterPlugin = SensitiveFilterPlugin_1 = class SensitiveFilterPlugin {
+    constructor() {
+        this.logEnabled = true;
+    }
+    onPluginBootstrap() {
+        if (this.logEnabled) {
+            console.log(chalk.green(`${SensitiveFilterPlugin_1.name} is being bootstrapped...`));
+        }
+    }
+    onPluginDestroy() {
+        if (this.logEnabled) {
+            console.log(chalk.green(`${SensitiveFilterPlugin_1.name} is being destroyed...`));
+        }
+    }
+};
+SensitiveFilterPlugin = SensitiveFilterPlugin_1 = __decorate([
+    XpertServerPlugin({
+        imports: [],
+        providers: [SensitiveFilterMiddleware]
+    })
+], SensitiveFilterPlugin);
+export { SensitiveFilterPlugin };

package/dist/lib/sensitiveFilter.d.ts

@@ -0,0 +1,9 @@
+import { TAgentMiddlewareMeta } from '@metad/contracts';
+import { AgentMiddleware, IAgentMiddlewareContext, IAgentMiddlewareStrategy, PromiseOrValue } from '@xpert-ai/plugin-sdk';
+import { SensitiveFilterConfig } from './types.js';
+export declare class SensitiveFilterMiddleware implements IAgentMiddlewareStrategy<SensitiveFilterConfig> {
+    readonly meta: TAgentMiddlewareMeta;
+    createMiddleware(options: SensitiveFilterConfig, _context: IAgentMiddlewareContext): PromiseOrValue<AgentMiddleware>;
+}
+export type { SensitiveFilterConfig };
+//# sourceMappingURL=sensitiveFilter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sensitiveFilter.d.ts","sourceRoot":"","sources":["../../src/lib/sensitiveFilter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAEvD,OAAO,EACL,eAAe,EAEf,uBAAuB,EACvB,wBAAwB,EACxB,cAAc,EACf,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAGL,qBAAqB,EAKtB,MAAM,YAAY,CAAA;AAuQnB,qBAEa,yBAA0B,YAAW,wBAAwB,CAAC,qBAAqB,CAAC;IAC/F,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CA4IlC;IAED,gBAAgB,CACd,OAAO,EAAE,qBAAqB,EAC9B,QAAQ,EAAE,uBAAuB,GAChC,cAAc,CAAC,eAAe,CAAC;CA4GnC;AAED,YAAY,EAAE,qBAAqB,EAAE,CAAA"}

package/dist/lib/sensitiveFilter.js

@@ -0,0 +1,444 @@
+import { __decorate } from "tslib";
+import { z as z4 } from 'zod/v4';
+import { AIMessage, HumanMessage } from '@langchain/core/messages';
+import { Injectable } from '@nestjs/common';
+import { AgentMiddlewareStrategy, } from '@xpert-ai/plugin-sdk';
+import { SensitiveFilterIcon, resolveGeneralPackRules, sensitiveFilterConfigSchema, } from './types.js';
+const SENSITIVE_FILTER_MIDDLEWARE_NAME = 'SensitiveFilterMiddleware';
+const DEFAULT_INPUT_BLOCK_MESSAGE = '输入内容触发敏感策略，已拦截。';
+const DEFAULT_OUTPUT_BLOCK_MESSAGE = '输出内容触发敏感策略，已拦截。';
+const DEFAULT_REWRITE_TEXT = '[已过滤]';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function toNonEmptyString(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+}
+function normalizeForMatching(text, normalize, caseSensitive) {
+    const source = normalize ? text.trim().replace(/\s+/g, ' ') : text;
+    return caseSensitive ? source : source.toLowerCase();
+}
+function extractPrimitiveText(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => {
+            if (typeof item === 'string') {
+                return item;
+            }
+            if (isRecord(item) && typeof item['text'] === 'string') {
+                return item['text'];
+            }
+            return '';
+        })
+            .join('');
+    }
+    return '';
+}
+function extractInputText(state, runtime) {
+    const runtimeState = runtime?.state;
+    const runtimeHuman = isRecord(runtimeState?.['human']) ? runtimeState['human'] : null;
+    const stateHuman = isRecord(state?.['human']) ? state['human'] : null;
+    const candidates = [
+        runtimeHuman?.['input'],
+        runtimeState?.['input'],
+        stateHuman?.['input'],
+        state?.['input'],
+    ];
+    for (const candidate of candidates) {
+        const text = extractPrimitiveText(candidate).trim();
+        if (text) {
+            return text;
+        }
+    }
+    return '';
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function getSeverityWeight(severity) {
+    return severity === 'high' ? 2 : 1;
+}
+function pickWinningRule(matches) {
+    if (matches.length === 0) {
+        return null;
+    }
+    let winner = matches[0];
+    for (const current of matches.slice(1)) {
+        const currentWeight = getSeverityWeight(current.severity);
+        const winnerWeight = getSeverityWeight(winner.severity);
+        if (currentWeight > winnerWeight) {
+            winner = current;
+            continue;
+        }
+        if (currentWeight === winnerWeight && current.index < winner.index) {
+            winner = current;
+        }
+    }
+    return winner;
+}
+function rewriteTextByRule(_source, rule, _caseSensitive) {
+    const replacement = rule.replacementText?.trim() || DEFAULT_REWRITE_TEXT;
+    // rewrite 按整句替换，避免局部替换造成语义残留
+    return replacement;
+}
+function findMatches(text, phase, rules, normalize, caseSensitive) {
+    if (!text) {
+        return [];
+    }
+    const matchTarget = normalizeForMatching(text, normalize, caseSensitive);
+    return rules.filter((rule) => {
+        if (rule.scope !== 'both' && rule.scope !== phase) {
+            return false;
+        }
+        if (rule.type === 'keyword') {
+            return matchTarget.includes(rule.normalizedPattern);
+        }
+        return Boolean(rule.matchRegex?.test(matchTarget));
+    });
+}
+function extractModelResponseText(response) {
+    if (typeof response === 'string') {
+        return response;
+    }
+    if (isRecord(response)) {
+        return extractPrimitiveText(response['content']);
+    }
+    return '';
+}
+function replaceModelResponseText(response, text) {
+    if (isRecord(response) && 'content' in response) {
+        response['content'] = text;
+        return response;
+    }
+    return new AIMessage(text);
+}
+function rewriteModelRequestInput(request, rewrittenText) {
+    if (!Array.isArray(request?.messages) || request.messages.length === 0) {
+        return request;
+    }
+    const messages = [...request.messages];
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        const messageType = typeof message?._getType === 'function' ? message._getType() : message?.type;
+        if (messageType !== 'human') {
+            continue;
+        }
+        const content = message?.content;
+        if (typeof content === 'string') {
+            messages[i] = new HumanMessage(rewrittenText);
+            return { ...request, messages };
+        }
+        if (Array.isArray(content)) {
+            let replaced = false;
+            const nextContent = content.map((part) => {
+                if (!replaced && isRecord(part) && part['type'] === 'text') {
+                    replaced = true;
+                    return {
+                        ...part,
+                        text: rewrittenText,
+                    };
+                }
+                return part;
+            });
+            if (!replaced) {
+                nextContent.push({
+                    type: 'text',
+                    text: rewrittenText,
+                });
+            }
+            messages[i] = new HumanMessage({ content: nextContent });
+            return { ...request, messages };
+        }
+        messages[i] = new HumanMessage(rewrittenText);
+        return { ...request, messages };
+    }
+    return request;
+}
+function normalizeRuleDrafts(input) {
+    const rules = [];
+    for (const draft of input) {
+        if (!isRecord(draft)) {
+            continue;
+        }
+        const id = toNonEmptyString(draft['id']);
+        const pattern = toNonEmptyString(draft['pattern']);
+        const type = toNonEmptyString(draft['type']);
+        const scope = toNonEmptyString(draft['scope']);
+        const severity = toNonEmptyString(draft['severity']);
+        const action = toNonEmptyString(draft['action']);
+        const replacementText = toNonEmptyString(draft['replacementText']) ?? undefined;
+        const hasAnyValue = Boolean(id || pattern || type || scope || severity || action || replacementText);
+        if (!hasAnyValue) {
+            continue;
+        }
+        if (!id || !pattern || !type || !scope || !severity || !action) {
+            continue;
+        }
+        if (!['keyword', 'regex'].includes(type)) {
+            continue;
+        }
+        if (!['input', 'output', 'both'].includes(scope)) {
+            continue;
+        }
+        if (!['high', 'medium'].includes(severity)) {
+            continue;
+        }
+        if (!['block', 'rewrite'].includes(action)) {
+            continue;
+        }
+        rules.push({
+            id,
+            pattern,
+            type,
+            scope,
+            severity,
+            action,
+            replacementText,
+        });
+    }
+    return rules;
+}
+let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
+    constructor() {
+        this.meta = {
+            name: SENSITIVE_FILTER_MIDDLEWARE_NAME,
+            label: {
+                en_US: 'Sensitive Filter Middleware',
+                zh_Hans: '敏感内容过滤中间件',
+            },
+            description: {
+                en_US: 'Filter sensitive content before input and after output using business rules and optional local general lexicon.',
+                zh_Hans: '基于业务规则进行输入/输出过滤，并可选启用本地开源通用词库（中英双语）作为兜底。',
+            },
+            icon: {
+                type: 'svg',
+                value: SensitiveFilterIcon,
+            },
+            configSchema: {
+                type: 'object',
+                properties: {
+                    rules: {
+                        type: 'array',
+                        title: {
+                            en_US: 'Business Rules',
+                            zh_Hans: '业务规则',
+                        },
+                        description: {
+                            en_US: 'Add at least one complete business rule. If you only need baseline protection, enable General Pack below.',
+                            zh_Hans: '建议至少添加一条完整业务规则；若仅需基础兜底，可直接启用下方“通用规则包”。',
+                        },
+                        items: {
+                            type: 'object',
+                            properties: {
+                                id: {
+                                    type: 'string',
+                                    title: { en_US: 'Rule ID', zh_Hans: '规则标识' },
+                                },
+                                pattern: {
+                                    type: 'string',
+                                    title: { en_US: 'Pattern', zh_Hans: '匹配内容' },
+                                },
+                                type: {
+                                    type: 'string',
+                                    title: { en_US: 'Type', zh_Hans: '匹配类型' },
+                                    enum: ['keyword', 'regex'],
+                                    'x-ui': {
+                                        enumLabels: {
+                                            keyword: { en_US: 'Keyword', zh_Hans: '关键词' },
+                                            regex: { en_US: 'Regex', zh_Hans: '正则表达式' },
+                                        },
+                                    },
+                                },
+                                scope: {
+                                    type: 'string',
+                                    title: { en_US: 'Scope', zh_Hans: '生效范围' },
+                                    enum: ['input', 'output', 'both'],
+                                    'x-ui': {
+                                        enumLabels: {
+                                            input: { en_US: 'Input', zh_Hans: '仅输入' },
+                                            output: { en_US: 'Output', zh_Hans: '仅输出' },
+                                            both: { en_US: 'Both', zh_Hans: '输入和输出' },
+                                        },
+                                    },
+                                },
+                                severity: {
+                                    type: 'string',
+                                    title: { en_US: 'Severity', zh_Hans: '优先级' },
+                                    enum: ['high', 'medium'],
+                                    'x-ui': {
+                                        enumLabels: {
+                                            high: { en_US: 'High', zh_Hans: '高' },
+                                            medium: { en_US: 'Medium', zh_Hans: '中' },
+                                        },
+                                    },
+                                },
+                                action: {
+                                    type: 'string',
+                                    title: { en_US: 'Action', zh_Hans: '命中动作' },
+                                    enum: ['block', 'rewrite'],
+                                    'x-ui': {
+                                        enumLabels: {
+                                            block: { en_US: 'Block', zh_Hans: '拦截' },
+                                            rewrite: { en_US: 'Rewrite', zh_Hans: '整句替换' },
+                                        },
+                                    },
+                                },
+                                replacementText: {
+                                    type: 'string',
+                                    title: { en_US: 'Replacement Text', zh_Hans: '替换文本（可选）' },
+                                },
+                            },
+                        },
+                    },
+                    generalPack: {
+                        type: 'object',
+                        title: {
+                            en_US: 'General Pack',
+                            zh_Hans: '通用规则包（本地开源词库）',
+                        },
+                        description: {
+                            en_US: 'For local models without built-in moderation. Uses local bilingual (ZH/EN) open-source lexicon.',
+                            zh_Hans: '用于没有内置安全过滤的本地模型兜底；采用本地中英双语开源词库。',
+                        },
+                        properties: {
+                            enabled: {
+                                type: 'boolean',
+                                default: false,
+                                title: { en_US: 'Enable', zh_Hans: '启用通用规则包' },
+                            },
+                            profile: {
+                                type: 'string',
+                                title: { en_US: 'Profile', zh_Hans: '策略档位' },
+                                enum: ['strict', 'balanced'],
+                                'x-ui': {
+                                    enumLabels: {
+                                        strict: { en_US: 'Strict', zh_Hans: '严格' },
+                                        balanced: { en_US: 'Balanced', zh_Hans: '平衡' },
+                                    },
+                                    tooltip: {
+                                        en_US: 'Strict: broader lexicon + block on hit. Balanced: base lexicon + sentence rewrite on hit.',
+                                        zh_Hans: '严格：词库范围更大，命中后直接拦截。平衡：词库范围较小，命中后整句替换再继续。',
+                                    },
+                                },
+                                default: 'balanced',
+                            },
+                        },
+                    },
+                    caseSensitive: {
+                        type: 'boolean',
+                        default: false,
+                        title: { en_US: 'Case Sensitive', zh_Hans: '区分大小写' },
+                    },
+                    normalize: {
+                        type: 'boolean',
+                        default: true,
+                        title: { en_US: 'Normalize Text', zh_Hans: '文本标准化' },
+                    },
+                },
+            },
+        };
+    }
+    createMiddleware(options, _context) {
+        const parsed = sensitiveFilterConfigSchema.safeParse(options ?? {});
+        if (!parsed.success) {
+            throw new Error(`Invalid sensitive filter middleware options: ${z4.prettifyError(parsed.error)}`);
+        }
+        const config = parsed.data;
+        const caseSensitive = config.caseSensitive ?? false;
+        const normalize = config.normalize ?? true;
+        const customRules = normalizeRuleDrafts(config.rules ?? []);
+        const generalRules = resolveGeneralPackRules(config.generalPack);
+        const allRules = [...customRules, ...generalRules];
+        const compiledRules = allRules.map((rule, index) => {
+            const normalizedPattern = rule.type === 'keyword' ? normalizeForMatching(rule.pattern, normalize, caseSensitive) : rule.pattern;
+            if (rule.type === 'regex') {
+                try {
+                    return {
+                        ...rule,
+                        index,
+                        normalizedPattern,
+                        matchRegex: new RegExp(rule.pattern, caseSensitive ? '' : 'i'),
+                        rewriteRegex: new RegExp(rule.pattern, caseSensitive ? 'g' : 'gi'),
+                    };
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    throw new Error(`Invalid regex pattern in rule '${rule.id}': ${message}`);
+                }
+            }
+            return {
+                ...rule,
+                index,
+                normalizedPattern,
+            };
+        });
+        let inputBlockedMessage = null;
+        let pendingInputRewrite = null;
+        return {
+            name: SENSITIVE_FILTER_MIDDLEWARE_NAME,
+            beforeAgent: async (state, runtime) => {
+                const safeState = state ?? {};
+                const safeRuntime = runtime ?? {};
+                inputBlockedMessage = null;
+                pendingInputRewrite = null;
+                if (compiledRules.length === 0) {
+                    return undefined;
+                }
+                const inputText = extractInputText(safeState, safeRuntime);
+                const inputMatches = findMatches(inputText, 'input', compiledRules, normalize, caseSensitive);
+                const winner = pickWinningRule(inputMatches);
+                if (!winner) {
+                    return undefined;
+                }
+                if (winner.action === 'block') {
+                    inputBlockedMessage = winner.replacementText?.trim() || DEFAULT_INPUT_BLOCK_MESSAGE;
+                    return undefined;
+                }
+                const rewrittenInput = rewriteTextByRule(inputText, winner, caseSensitive);
+                pendingInputRewrite = rewrittenInput;
+                return undefined;
+            },
+            wrapModelCall: async (request, handler) => {
+                if (compiledRules.length === 0) {
+                    return handler(request);
+                }
+                if (inputBlockedMessage) {
+                    return new AIMessage(inputBlockedMessage);
+                }
+                const modelRequest = pendingInputRewrite ? rewriteModelRequestInput(request, pendingInputRewrite) : request;
+                pendingInputRewrite = null;
+                const response = await handler(modelRequest);
+                const outputText = extractModelResponseText(response);
+                const outputMatches = findMatches(outputText, 'output', compiledRules, normalize, caseSensitive);
+                const winner = pickWinningRule(outputMatches);
+                if (!winner) {
+                    return response;
+                }
+                if (winner.action === 'block') {
+                    const blockedOutput = winner.replacementText?.trim() || DEFAULT_OUTPUT_BLOCK_MESSAGE;
+                    return replaceModelResponseText(response, blockedOutput);
+                }
+                const rewrittenOutput = rewriteTextByRule(outputText, winner, caseSensitive);
+                return replaceModelResponseText(response, rewrittenOutput);
+            },
+            afterAgent: async () => {
+                return undefined;
+            },
+        };
+    }
+};
+SensitiveFilterMiddleware = __decorate([
+    Injectable(),
+    AgentMiddlewareStrategy(SENSITIVE_FILTER_MIDDLEWARE_NAME)
+], SensitiveFilterMiddleware);
+export { SensitiveFilterMiddleware };

package/dist/lib/types.d.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod/v3';
+export type SensitiveRule = {
+    id: string;
+    pattern: string;
+    type: 'keyword' | 'regex';
+    scope: 'input' | 'output' | 'both';
+    severity: 'high' | 'medium';
+    action: 'block' | 'rewrite';
+    replacementText?: string;
+};
+export type GeneralPackConfig = {
+    enabled?: boolean;
+    profile?: 'strict' | 'balanced';
+};
+export type SensitiveFilterConfig = {
+    rules?: Array<Partial<SensitiveRule> | null>;
+    generalPack?: GeneralPackConfig;
+    caseSensitive?: boolean;
+    normalize?: boolean;
+};
+export type CompiledSensitiveRule = SensitiveRule & {
+    index: number;
+    normalizedPattern: string;
+    matchRegex?: RegExp;
+    rewriteRegex?: RegExp;
+};
+export declare const SensitiveFilterIcon = "<svg width=\"800px\" height=\"800px\" viewBox=\"0 0 24 24\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M12 2l7 3v6c0 5.2-3.3 9.9-7 11-3.7-1.1-7-5.8-7-11V5l7-3zm0 2.1L7 6v5c0 3.9 2.3 7.8 5 8.9 2.7-1.1 5-5 5-8.9V6l-5-1.9zM8.8 12.6l1.4-1.4 1.8 1.8 3.8-3.8 1.4 1.4-5.2 5.2-3.2-3.2z\"/></svg>";
+export declare const sensitiveFilterConfigSchema: z.ZodObject<{
+    rules: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNullable<z.ZodObject<{
+        id: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        pattern: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        type: z.ZodNullable<z.ZodOptional<z.ZodEnum<["keyword", "regex"]>>>;
+        scope: z.ZodNullable<z.ZodOptional<z.ZodEnum<["input", "output", "both"]>>>;
+        severity: z.ZodNullable<z.ZodOptional<z.ZodEnum<["high", "medium"]>>>;
+        action: z.ZodNullable<z.ZodOptional<z.ZodEnum<["block", "rewrite"]>>>;
+        replacementText: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        pattern?: string;
+        type?: "keyword" | "regex";
+        scope?: "input" | "output" | "both";
+        severity?: "high" | "medium";
+        action?: "block" | "rewrite";
+        replacementText?: string;
+    }, {
+        id?: string;
+        pattern?: string;
+        type?: "keyword" | "regex";
+        scope?: "input" | "output" | "both";
+        severity?: "high" | "medium";
+        action?: "block" | "rewrite";
+        replacementText?: string;
+    }>>, "many">>>;
+    generalPack: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        profile: z.ZodOptional<z.ZodDefault<z.ZodEnum<["strict", "balanced"]>>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean;
+        profile?: "strict" | "balanced";
+    }, {
+        enabled?: boolean;
+        profile?: "strict" | "balanced";
+    }>>;
+    caseSensitive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    normalize: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    rules?: {
+        id?: string;
+        pattern?: string;
+        type?: "keyword" | "regex";
+        scope?: "input" | "output" | "both";
+        severity?: "high" | "medium";
+        action?: "block" | "rewrite";
+        replacementText?: string;
+    }[];
+    generalPack?: {
+        enabled?: boolean;
+        profile?: "strict" | "balanced";
+    };
+    caseSensitive?: boolean;
+    normalize?: boolean;
+}, {
+    rules?: {
+        id?: string;
+        pattern?: string;
+        type?: "keyword" | "regex";
+        scope?: "input" | "output" | "both";
+        severity?: "high" | "medium";
+        action?: "block" | "rewrite";
+        replacementText?: string;
+    }[];
+    generalPack?: {
+        enabled?: boolean;
+        profile?: "strict" | "balanced";
+    };
+    caseSensitive?: boolean;
+    normalize?: boolean;
+}>;
+export declare function resolveGeneralPackRules(config?: GeneralPackConfig): SensitiveRule[];
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA,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,qBAAqB,GAAG;IAClC,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,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;AAmC9T,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKtC,CAAA;AAYF,wBAAgB,uBAAuB,CAAC,MAAM,CAAC,EAAE,iBAAiB,GAAG,aAAa,EAAE,CA6CnF"}

package/dist/lib/types.js

@@ -0,0 +1,86 @@
+import { z } from 'zod/v3';
+export const SensitiveFilterIcon = `<svg width="800px" height="800px" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path d="M12 2l7 3v6c0 5.2-3.3 9.9-7 11-3.7-1.1-7-5.8-7-11V5l7-3zm0 2.1L7 6v5c0 3.9 2.3 7.8 5 8.9 2.7-1.1 5-5 5-8.9V6l-5-1.9zM8.8 12.6l1.4-1.4 1.8 1.8 3.8-3.8 1.4 1.4-5.2 5.2-3.2-3.2z"/></svg>`;
+/**
+ * 本地通用词库来源（中英双语，V1 子集）:
+ * - English: LDNOOBW
+ * - Chinese: ToolGood.Words 社区词表
+ */
+const OPEN_SOURCE_LEXICON = {
+    en: {
+        balanced: ['fuck', 'shit', 'bitch', 'asshole', 'bastard', 'motherfucker', 'dumbass', 'cunt'],
+        strictExtra: ['slut', 'whore', 'retard', 'nigger', 'faggot'],
+    },
+    zh: {
+        balanced: ['傻逼', '操你妈', '他妈的', '王八蛋', '滚蛋', '去死', '脑残', '妈的'],
+        strictExtra: ['强奸', '炸弹', '杀人', '自杀', '毒品'],
+    },
+};
+const sensitiveRuleDraftSchema = z
+    .object({
+    id: z.string().optional().nullable(),
+    pattern: z.string().optional().nullable(),
+    type: z.enum(['keyword', 'regex']).optional().nullable(),
+    scope: z.enum(['input', 'output', 'both']).optional().nullable(),
+    severity: z.enum(['high', 'medium']).optional().nullable(),
+    action: z.enum(['block', 'rewrite']).optional().nullable(),
+    replacementText: z.string().optional().nullable(),
+})
+    .nullable();
+const generalPackSchema = z.object({
+    enabled: z.boolean().default(false),
+    profile: z.enum(['strict', 'balanced']).default('balanced').optional(),
+});
+export const sensitiveFilterConfigSchema = z.object({
+    rules: z.array(sensitiveRuleDraftSchema).optional().default([]),
+    generalPack: generalPackSchema.optional(),
+    caseSensitive: z.boolean().optional().default(false),
+    normalize: z.boolean().optional().default(true),
+});
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function buildLexiconRegex(words) {
+    const unique = Array.from(new Set(words.map((w) => w.trim()).filter(Boolean)));
+    const escaped = unique.map((w) => escapeRegExp(w));
+    return escaped.length ? `(?:${escaped.join('|')})` : '';
+}
+export function resolveGeneralPackRules(config) {
+    if (!config?.enabled) {
+        return [];
+    }
+    const profile = config.profile ?? 'balanced';
+    const enWords = [
+        ...OPEN_SOURCE_LEXICON.en.balanced,
+        ...(profile === 'strict' ? OPEN_SOURCE_LEXICON.en.strictExtra : []),
+    ];
+    const zhWords = [
+        ...OPEN_SOURCE_LEXICON.zh.balanced,
+        ...(profile === 'strict' ? OPEN_SOURCE_LEXICON.zh.strictExtra : []),
+    ];
+    const enPattern = buildLexiconRegex(enWords);
+    const zhPattern = buildLexiconRegex(zhWords);
+    const action = profile === 'strict' ? 'block' : 'rewrite';
+    const severity = profile === 'strict' ? 'high' : 'medium';
+    const replacementText = profile === 'strict' ? '内容触发通用敏感词策略，已拦截。' : '[通用敏感词已过滤]';
+    const rules = [
+        {
+            id: 'general-open-lexicon-en',
+            pattern: enPattern,
+            type: 'regex',
+            scope: 'both',
+            severity,
+            action,
+            replacementText,
+        },
+        {
+            id: 'general-open-lexicon-zh',
+            pattern: zhPattern,
+            type: 'regex',
+            scope: 'both',
+            severity,
+            action,
+            replacementText,
+        },
+    ];
+    return rules.filter((rule) => Boolean(rule.pattern));
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "plugin-sensitive-filter-xr",
+  "version": "0.0.1",
+  "author": {
+    "name": "XpertAI",
+    "url": "https://xpertai.cn"
+  },
+  "license": "AGPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xpert-ai/xpert-plugins.git"
+  },
+  "bugs": {
+    "url": "https://github.com/xpert-ai/xpert-plugins/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@xpert-plugins-starter/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "peerDependencies": {
+    "zod": "3.25.67",
+    "@xpert-ai/plugin-sdk": "^3.7.0",
+    "chalk": "4.1.2",
+    "@langchain/core": "0.3.72",
+    "@nestjs/common": "^11.1.6",
+    "@metad/contracts": "^3.7.0"
+  }
+}