plugin-sensitive-filter-xr 0.0.9 → 0.1.7

package/README.md

@@ -1,134 +1,72 @@
-# Xpert Plugin: Sensitive Filter Middleware
+# Sensitive Filter Middleware
 
-`@xpert-ai/plugin-sensitive-filter` 提供输入/输出敏感内容过滤，支持两种互斥模式：
+`@xpert-ai/plugin-sensitive-filter` filters sensitive content for both input and output in two mutually exclusive modes:
 
-- `rule`：规则匹配过滤（关键词/正则）
-- `llm`：自然语言规则过滤（固定改写策略）
+- `rule`: deterministic rules (`keyword` / `regex`)
+- `llm`: natural-language policy evaluation with rewrite-only enforcement
 
-## 快速上手
+## Lifecycle Hooks
 
-1. 在工作流中添加“敏感内容过滤中间件”。
-2. 选择 `mode`：`rule` 或 `llm`（二选一）。
-3. `rule` 模式填写规则表；`llm` 模式只需填写模型、范围、审核规则说明。
-4. 运行工作流验证输入与输出阶段效果。
-5. 查看日志中的审计记录。
+- `beforeAgent`: evaluates and optionally rewrites/blocks input
+- `wrapModelCall`: evaluates and optionally rewrites/blocks output
+- `afterAgent`: writes audit snapshot
 
-## 执行流程
+## Configuration
 
-- `beforeAgent`：处理输入
-- `wrapModelCall`：处理输出
-- `afterAgent`：记录审计
+### Top-level
 
-## 顶层参数
+| Field | Type | Required | Default | Description |
+| --- | --- | --- | --- | --- |
+| `mode` | `'rule' \| 'llm'` | Yes | `rule` | Select one mode. |
+| `rules` | `Array<Rule>` | Runtime-required in `rule` mode | `[]` | Business rules for `rule` mode. |
+| `caseSensitive` | `boolean` | No | `false` | Case-sensitive matching in `rule` mode. |
+| `normalize` | `boolean` | No | `true` | Whitespace normalization in `rule` mode. |
+| `llm` | `object` | Runtime-required in `llm` mode | - | LLM mode configuration. |
 
-| 参数 | 类型 | 必填 | 默认值 | 说明 |
-|---|---|---|---|---|
-| `mode` | `'rule' \| 'llm'` | 是 | `rule` | 过滤模式（互斥）。 |
-| `rules` | `Array<Rule>` | `rule` 模式建议配置 | `[]` | 业务规则，仅 `rule` 模式生效。 |
-| `generalPack` | `object` | 否 | 见子项 | 通用规则包（本地词库兜底），仅 `rule` 模式生效。 |
-| `caseSensitive` | `boolean` | 否 | `false` | 是否区分大小写，仅 `rule` 模式生效。 |
-| `normalize` | `boolean` | 否 | `true` | 是否标准化文本，仅 `rule` 模式生效。 |
-| `llm` | `object` | `llm` 模式执行期必填 | - | LLM 过滤配置，仅 `llm` 模式生效。 |
+### Rule Mode (`mode=rule`)
 
-## rule 模式参数
+`rules[]` fields:
 
-### rules[]
+| Field | Type | Required | Description |
+| --- | --- | --- | --- |
+| `id` | `string` | No | Auto-generated when empty (`rule-{index+1}`). |
+| `pattern` | `string` | Yes | Match pattern. |
+| `type` | `'keyword' \| 'regex'` | Yes | Match type. |
+| `scope` | `'input' \| 'output' \| 'both'` | Yes | Match phase. |
+| `severity` | `'high' \| 'medium'` | Yes | Conflict priority (`high` > `medium`). |
+| `action` | `'block' \| 'rewrite'` | Yes | Hit action. |
+| `replacementText` | `string` | No | Optional replacement/block message. |
 
-| 字段 | 类型 | 必填 | 默认值 | 说明 |
-|---|---|---|---|---|
-| `id` | `string` | 否 | 自动生成 `rule-{index+1}` | 规则标识。 |
-| `pattern` | `string` | 是 | - | 匹配内容。 |
-| `type` | `'keyword' \| 'regex'` | 是 | - | 匹配方式。 |
-| `scope` | `'input' \| 'output' \| 'both'` | 是 | - | 生效阶段。 |
-| `severity` | `'high' \| 'medium'` | 是 | - | 冲突优先级（`high > medium`）。 |
-| `action` | `'block' \| 'rewrite'` | 是 | - | 命中动作。 |
-| `replacementText` | `string` | 否 | `[已过滤]`（rewrite 时） | 自定义拦截/改写文本。 |
+Runtime validation requires at least one valid rule with:
+`pattern/type/action/scope/severity`.
 
-### generalPack
+### LLM Mode (`mode=llm`)
 
-| 字段 | 类型 | 必填 | 默认值 | 说明 |
-|---|---|---|---|---|
-| `enabled` | `boolean` | 否 | `false` | 是否启用通用规则包。 |
-| `profile` | `'strict' \| 'balanced'` | 否 | `balanced` | `strict` 更严格，`balanced` 更保守。 |
+| Field | Type | Required (runtime) | Default | Description |
+| --- | --- | --- | --- | --- |
+| `model` | `ICopilotModel` | Yes | - | Policy evaluation model. |
+| `scope` | `'input' \| 'output' \| 'both'` | Yes | - | Evaluation phase scope. |
+| `rulePrompt` | `string` | Yes | - | Natural-language policy description. |
+| `rewriteFallbackText` | `string` | No | `[已过滤]` | Fallback rewrite text. |
+| `timeoutMs` | `number` | No | unlimited | Per-evaluation timeout (max `120000`). |
 
-## llm 模式参数（简化版）
+Notes:
 
-### llm
+- The middleware internally enforces rewrite-only behavior for LLM hits.
+- Structured output method is internally adaptive; the UI does not expose method selection.
+- Internal decision traces are muted from chat output.
 
-| 字段 | 类型 | 必填（执行期） | 默认值 | 说明 |
-|---|---|---|---|---|
-| `model` | `ICopilotModel` | 是 | - | 用于判定的过滤模型。 |
-| `scope` | `'input' \| 'output' \| 'both'` | 是 | - | 生效范围。 |
-| `rulePrompt` | `string` | 是 | - | 审核规则说明（自然语言，不需要 JSON）。 |
-| `rewriteFallbackText` | `string` | 否 | `[已过滤]` | 命中但未返回改写文本时兜底文案。 |
-| `timeoutMs` | `number` | 否 | 不限 | 判定超时（毫秒，上限 `120000`）。 |
+## Backward Compatibility
 
-### llm 模式行为说明
+Historical configurations may still include `generalPack`.
 
-- 用户只需填写自然语言规则，不需要书写 JSON 协议。
-- `outputMethod` 由中间件内部自动自适应（兼容历史配置读取），默认不在配置面板展示。
-- 命中后统一执行 `rewrite`。
-- LLM 调用异常时也统一执行 `rewrite`。
-- 若配置了 `timeoutMs` 且判定超时，会直接使用 `rewriteFallbackText` 作为改写结果。
-- 若模型不支持当前 `outputMethod` 的 `response_format`，会自动尝试其它结构化方式并最终降级到纯文本 JSON 解析。
-- 若历史配置仍携带 `onLlmError/systemPrompt/errorRewriteText`，会按兼容逻辑处理并给出弃用告警。
-- 内部判定与审计追踪默认静默执行，不会把 `{"matched":false}` 这类内部 JSON 透传到聊天回复。
+Current behavior:
 
-## 界面怎么填（最简）
+- The field is ignored.
+- Execution continues.
+- Rule/LLM behavior is driven only by current supported fields.
 
-`mode=llm` 时，最少只需要填这 3 项：
-
-1. `llm.model`：选择过滤用模型（建议稳定、低延迟模型）。
-2. `llm.scope`：建议先用 `both`。
-3. `llm.rulePrompt`：写自然语言审核规则，不需要 JSON。
-
-示例（个人信息场景）：
-
-- `llm.rulePrompt`：如果文本包含手机号、身份证号、银行卡号、家庭住址等个人敏感信息，请判定为命中并给出脱敏改写内容。
-- `llm.rewriteFallbackText`：`[已过滤]`
-
-说明：
-
-- `llm` 模式是“只改写不拦截”。如果你要“直接拦截”，请改用 `mode=rule` 并配置 `action=block`。
-
-## 超时与速度说明
-
-- `timeoutMs` 是“单次 LLM 判定调用的最长等待时间（毫秒）”，不是整条工作流总超时。
-- 设置过小（例如 `3000`）时，慢模型更容易超时，超时后会直接走 `rewriteFallbackText`。
-- 不设置 `timeoutMs` 时，判定会一直等待模型返回，稳定性更高，但最坏延迟会变大。
-- 命中输出过滤时，通常会感觉更慢：因为需要先拿到可判定内容，再统一改写返回。
-- 你看到多个 `success` 卡片是正常的：输入判定、输出判定、收尾审计是不同执行步骤。
-
-## 配置示例
-
-### 示例 1：rule 模式
-
-```json
-{
-  "mode": "rule",
-  "rules": [
-    {
-      "pattern": "炸弹",
-      "type": "keyword",
-      "scope": "both",
-      "severity": "high",
-      "action": "block"
-    },
-    {
-      "pattern": "(身份证|手机号)",
-      "type": "regex",
-      "scope": "output",
-      "severity": "medium",
-      "action": "rewrite",
-      "replacementText": "该回答包含敏感信息，已处理。"
-    }
-  ],
-  "normalize": true,
-  "caseSensitive": false
-}
-```
-
-### 示例 2：llm 模式（推荐）
+## Minimal LLM Example
 
 ```json
 {
@@ -136,37 +74,24 @@
   "llm": {
     "model": { "provider": "openai", "model": "gpt-4o-mini" },
     "scope": "both",
-    "rulePrompt": "若内容包含违法、暴力或隐私泄露，请改写为安全且中性的表达。",
+    "rulePrompt": "If content contains ID cards, phone numbers, bank cards, or home addresses, rewrite it into a privacy-safe response.",
     "rewriteFallbackText": "[已过滤]",
     "timeoutMs": 3000
   }
 }
 ```
 
-## 常见问题
+## Troubleshooting
 
-### 1) 为什么没生效？
+1. No effect in `rule` mode:
+- Ensure at least one valid rule contains `pattern/type/action/scope/severity`.
 
-按顺序检查：
+2. No effect in `llm` mode:
+- Ensure `model/scope/rulePrompt` are all present.
 
-1. `mode` 是否正确。
-2. `rule` 模式是否至少有 1 条有效规则（`pattern/type/action/scope/severity`）。
-3. `llm` 模式是否填写了 `model/scope/rulePrompt`。
-4. `scope` 是否覆盖当前阶段（输入或输出）。
+3. Unexpected rewrites in LLM mode:
+- Check audit records for `source=error-policy` and `reason` starting with `llm-error:`.
 
-### 2) 为什么提示中文校验错误？
+## Validation Commands
 
-中间件采用“编辑期容错、执行期校验”。编辑阶段允许先保存草稿，执行时再提示缺项。
 
-### 3) 旧配置里的 systemPrompt 还能用吗？
-
-可以。若未填写 `rulePrompt`，会兼容读取 `systemPrompt`。建议迁移到 `rulePrompt`。
-
-## 开发验证
-
-```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 ./middlewares/sensitive-filter
-```

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;AAqgBnB,qBAEa,yBAA0B,YAAW,wBAAwB,CAAC,qBAAqB,CAAC;IAE/F,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAY;IAEvC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAwQlC;IAEK,gBAAgB,CACpB,OAAO,EAAE,qBAAqB,EAC9B,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,eAAe,CAAC;IAa3B,OAAO,CAAC,wBAAwB;IA8OhC,OAAO,CAAC,uBAAuB;CA4ahC;AAED,YAAY,EAAE,qBAAqB,EAAE,CAAA"}
+{"version":3,"file":"sensitiveFilter.d.ts","sourceRoot":"","sources":["../../src/lib/sensitiveFilter.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAa,oBAAoB,EAA8B,MAAM,kBAAkB,CAAA;AAGnG,OAAO,EACL,eAAe,EAGf,uBAAuB,EACvB,wBAAwB,EAEzB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAML,qBAAqB,EAKtB,MAAM,YAAY,CAAA;AAixBnB,qBAEa,yBAA0B,YAAW,wBAAwB,CAAC,qBAAqB,CAAC;IAE/F,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAY;IAEvC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CA6NlC;IAEK,gBAAgB,CACpB,OAAO,EAAE,qBAAqB,EAC9B,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,eAAe,CAAC;IAa3B,OAAO,CAAC,wBAAwB;IAgThC,OAAO,CAAC,uBAAuB;CA2fhC;AAED,YAAY,EAAE,qBAAqB,EAAE,CAAA"}

package/dist/lib/sensitiveFilter.js

@@ -1,20 +1,26 @@
 import { __decorate, __metadata } from "tslib";
 import { z as z4 } from 'zod/v4';
-import { AIMessage, HumanMessage } from '@langchain/core/messages';
+import { AIMessage, AIMessageChunk, HumanMessage } from '@langchain/core/messages';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
 import { Inject, Injectable } from '@nestjs/common';
 import { CommandBus } from '@nestjs/cqrs';
 import { AgentMiddlewareStrategy, CreateModelClientCommand, WrapWorkflowNodeExecutionCommand, } from '@xpert-ai/plugin-sdk';
-import { SensitiveFilterIcon, llmDecisionSchema, resolveGeneralPackRules, sensitiveFilterConfigSchema, } from './types.js';
+import { SensitiveFilterIcon, llmDecisionSchema, sensitiveFilterConfigSchema, } from './types.js';
 const SENSITIVE_FILTER_MIDDLEWARE_NAME = 'SensitiveFilterMiddleware';
 const DEFAULT_INPUT_BLOCK_MESSAGE = '输入内容触发敏感策略，已拦截。';
 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 BUSINESS_RULES_VALIDATION_ERROR = '请至少配置 1 条有效业务规则（pattern/type/action/scope/severity）。';
 const LLM_MODE_VALIDATION_ERROR = '请完善 LLM 过滤配置：需填写过滤模型、生效范围、审核规则说明。';
 const INTERNAL_LLM_INVOKE_TAG = 'sensitive-filter/internal-eval';
+const INTERNAL_SOURCE_STREAM_TAG = 'sensitive-filter/internal-source-stream';
 const INTERNAL_LLM_INVOKE_OPTIONS = {
     tags: [INTERNAL_LLM_INVOKE_TAG],
+    metadata: {
+        internal: true,
+    },
 };
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
@@ -33,6 +39,7 @@ function buildInternalModelConfig(model) {
         options: {
             ...options,
             streaming: false,
+            temperature: typeof options['temperature'] === 'number' ? options['temperature'] : 0,
         },
     };
 }
@@ -103,7 +110,7 @@ function pickWinningRule(matches) {
 }
 function rewriteTextByRule(_source, rule, _caseSensitive) {
     const replacement = rule.replacementText?.trim() || DEFAULT_REWRITE_TEXT;
-    // rewrite 按整句替换，避免局部替换造成语义残留
+    // Rewrite replaces the full sentence to avoid semantic leftovers.
     return replacement;
 }
 function findMatches(text, phase, rules, normalize, caseSensitive) {
@@ -137,6 +144,144 @@ function replaceModelResponseText(response, text) {
     }
     return new AIMessage(text);
 }
+function cloneAiMessage(source) {
+    return new AIMessage({
+        content: source.content,
+        additional_kwargs: source.additional_kwargs,
+        response_metadata: source.response_metadata,
+        tool_calls: source.tool_calls,
+        invalid_tool_calls: source.invalid_tool_calls,
+        usage_metadata: source.usage_metadata,
+        id: source.id,
+        name: source.name,
+    });
+}
+function cloneAiMessageWithText(source, text) {
+    const cloned = cloneAiMessage(source);
+    cloned.content = text;
+    return cloned;
+}
+function toAiMessageChunk(value) {
+    if (value instanceof AIMessageChunk) {
+        return value;
+    }
+    if (!isRecord(value) || !('content' in value)) {
+        return null;
+    }
+    return new AIMessageChunk({
+        content: value['content'],
+        additional_kwargs: isRecord(value['additional_kwargs']) ? value['additional_kwargs'] : {},
+        response_metadata: isRecord(value['response_metadata']) ? value['response_metadata'] : {},
+        tool_call_chunks: Array.isArray(value['tool_call_chunks']) ? value['tool_call_chunks'] : [],
+        tool_calls: Array.isArray(value['tool_calls']) ? value['tool_calls'] : [],
+        invalid_tool_calls: Array.isArray(value['invalid_tool_calls']) ? value['invalid_tool_calls'] : [],
+        usage_metadata: isRecord(value['usage_metadata']) ? value['usage_metadata'] : undefined,
+        id: typeof value['id'] === 'string' ? value['id'] : undefined,
+    });
+}
+function toAiMessage(value) {
+    if (value instanceof AIMessage) {
+        return value;
+    }
+    if (value instanceof AIMessageChunk) {
+        return new AIMessage({
+            content: value.content,
+            additional_kwargs: value.additional_kwargs,
+            response_metadata: value.response_metadata,
+            tool_calls: value.tool_calls,
+            invalid_tool_calls: value.invalid_tool_calls,
+            usage_metadata: value.usage_metadata,
+            id: value.id,
+            name: value.name,
+        });
+    }
+    if (isRecord(value) && 'content' in value) {
+        return new AIMessage({
+            content: value['content'],
+            additional_kwargs: isRecord(value['additional_kwargs']) ? value['additional_kwargs'] : {},
+            response_metadata: isRecord(value['response_metadata']) ? value['response_metadata'] : {},
+            tool_calls: Array.isArray(value['tool_calls']) ? value['tool_calls'] : [],
+            invalid_tool_calls: Array.isArray(value['invalid_tool_calls']) ? value['invalid_tool_calls'] : [],
+            usage_metadata: isRecord(value['usage_metadata']) ? value['usage_metadata'] : undefined,
+            id: typeof value['id'] === 'string' ? value['id'] : undefined,
+            name: typeof value['name'] === 'string' ? value['name'] : undefined,
+        });
+    }
+    return new AIMessage(extractPrimitiveText(value));
+}
+function buildInternalSourceOptions(options) {
+    const tags = Array.isArray(options?.tags) ? options.tags : [];
+    const metadata = isRecord(options?.metadata) ? options.metadata : {};
+    return {
+        ...(options ?? {}),
+        tags: [...tags, INTERNAL_SOURCE_STREAM_TAG],
+        metadata: {
+            ...metadata,
+            internal: true,
+        },
+    };
+}
+class BufferedOutputProxyChatModel extends BaseChatModel {
+    constructor(innerModel, resolveOutput) {
+        super({});
+        this.innerModel = innerModel;
+        this.resolveOutput = resolveOutput;
+    }
+    _llmType() {
+        return 'sensitive-filter-output-proxy';
+    }
+    async collectInnerMessage(messages, options) {
+        const internalOptions = buildInternalSourceOptions(options);
+        const streamFn = this.innerModel?.stream;
+        if (typeof streamFn === 'function') {
+            let mergedChunk = null;
+            for await (const rawChunk of streamFn.call(this.innerModel, messages, internalOptions)) {
+                const chunk = toAiMessageChunk(rawChunk);
+                if (!chunk) {
+                    continue;
+                }
+                mergedChunk = mergedChunk ? mergedChunk.concat(chunk) : chunk;
+            }
+            if (mergedChunk) {
+                return toAiMessage(mergedChunk);
+            }
+        }
+        return toAiMessage(await this.innerModel.invoke(messages, internalOptions));
+    }
+    async finalizeMessage(messages, options) {
+        const sourceMessage = await this.collectInnerMessage(messages, options);
+        return this.resolveOutput(sourceMessage, extractPrimitiveText(sourceMessage.content));
+    }
+    async _generate(messages, options, _runManager) {
+        const resolved = await this.finalizeMessage(messages, options);
+        return {
+            generations: [
+                {
+                    text: extractPrimitiveText(resolved.finalMessage.content),
+                    message: resolved.finalMessage,
+                },
+            ],
+        };
+    }
+    async *_streamResponseChunks(messages, options, runManager) {
+        const resolved = await this.finalizeMessage(messages, options);
+        const finalText = extractPrimitiveText(resolved.finalMessage.content);
+        if (!finalText) {
+            return;
+        }
+        const generationChunk = new ChatGenerationChunk({
+            message: new AIMessageChunk({
+                content: finalText,
+                id: resolved.finalMessage.id,
+            }),
+            text: finalText,
+        });
+        yield generationChunk;
+        await runManager?.handleLLMNewToken(finalText, undefined, undefined, undefined, undefined, {
+            chunk: generationChunk,
+        });
+    }
+}
 function rewriteModelRequestInput(request, rewrittenText) {
     if (!Array.isArray(request?.messages) || request.messages.length === 0) {
         return request;
@@ -227,21 +372,74 @@ function modeIncludesScope(scope, phase) {
     return scope === 'both' || scope === phase;
 }
 function buildInternalLlmPrompt(rulePrompt) {
-    return ('你是敏感内容审核器。请根据用户给出的审核规则判断文本是否命中敏感内容。' +
+    return ('你不是聊天助手，你是严格的敏感内容分类器。' +
+        '\n你的唯一任务是根据审核规则判断文本是否命中，不要提供安全建议、解释性回复或扩展内容。' +
+        '\n这是硬规则匹配任务：当审核规则写明“出现/包含/只要命中/必须命中”时，必须严格按字面执行，不允许自由裁量。' +
         '\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 extractFirstJsonObject(text) {
+    const start = text.indexOf('{');
+    if (start < 0) {
+        return null;
+    }
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    for (let i = start; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            if (escape) {
+                escape = false;
+                continue;
+            }
+            if (ch === '\\') {
+                escape = true;
+                continue;
+            }
+            if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            continue;
+        }
+        if (ch === '{') {
+            depth++;
+            continue;
+        }
+        if (ch === '}') {
+            depth--;
+            if (depth === 0) {
+                return text.slice(start, i + 1);
+            }
+        }
+    }
+    return null;
+}
 function parseLlmDecision(raw, rewriteFallbackText) {
     let payload = raw;
     if (typeof payload === 'string') {
+        const rawText = payload;
         try {
             payload = JSON.parse(payload);
         }
         catch {
-            throw new Error('LLM decision is not valid JSON string');
+            const extracted = extractFirstJsonObject(rawText);
+            if (!extracted) {
+                throw new Error('LLM decision is not valid JSON string');
+            }
+            try {
+                payload = JSON.parse(extracted);
+            }
+            catch {
+                throw new Error('LLM decision is not valid JSON string');
+            }
         }
     }
     if (isRecord(payload) && !('matched' in payload) && 'content' in payload) {
@@ -253,7 +451,16 @@ function parseLlmDecision(raw, rewriteFallbackText) {
             payload = JSON.parse(content);
         }
         catch {
-            throw new Error('LLM decision content is not valid JSON');
+            const extracted = extractFirstJsonObject(content);
+            if (!extracted) {
+                throw new Error('LLM decision content is not valid JSON');
+            }
+            try {
+                payload = JSON.parse(extracted);
+            }
+            catch {
+                throw new Error('LLM decision content is not valid JSON');
+            }
         }
     }
     const parsed = llmDecisionSchema.safeParse(payload);
@@ -365,6 +572,14 @@ function isMissingWrapWorkflowHandlerError(error) {
     const message = getErrorText(error).toLowerCase();
     return message.includes('no handler found') && message.includes('wrapworkflownodeexecutioncommand');
 }
+function isMissingCreateModelHandlerError(error) {
+    const message = getErrorText(error).toLowerCase();
+    return (message.includes('no handler found') &&
+        (message.includes('createmodelclientcommand') || message.includes('create model client')));
+}
+function shouldFailOpenOnLlmError(error) {
+    return isMissingWrapWorkflowHandlerError(error) || isMissingCreateModelHandlerError(error);
+}
 async function runWithWrapWorkflowFallback(runTracked, runFallback) {
     try {
         return await runTracked();
@@ -495,47 +710,6 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
                             required: ['pattern', 'type', 'action', 'scope', 'severity'],
                         },
                     },
-                    generalPack: {
-                        type: 'object',
-                        'x-ui': {
-                            span: 2,
-                        },
-                        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: '策略档位' },
-                                description: {
-                                    en_US: 'Strict blocks on hit with broader lexicon; Balanced rewrites on hit with smaller lexicon.',
-                                    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,
@@ -653,8 +827,7 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
         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 allRules = [...customRules];
         const hasEffectiveRules = allRules.length > 0;
         let compiledRulesCache = null;
         const getCompiledRules = () => {
@@ -688,12 +861,14 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
         };
         let inputBlockedMessage = null;
         let pendingInputRewrite = null;
+        let bufferedOutputResolution = null;
         let finalAction = 'pass';
         let auditEntries = [];
         let runtimeConfigurable = null;
         const resetRunState = () => {
             inputBlockedMessage = null;
             pendingInputRewrite = null;
+            bufferedOutputResolution = null;
             finalAction = 'pass';
             auditEntries = [];
         };
@@ -815,7 +990,63 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
                 }
                 const modelRequest = pendingInputRewrite ? rewriteModelRequestInput(request, pendingInputRewrite) : request;
                 pendingInputRewrite = null;
-                const response = await handler(modelRequest);
+                bufferedOutputResolution = null;
+                const shouldBufferOutput = compiledRules.some((rule) => rule.scope === 'output' || rule.scope === 'both');
+                const effectiveRequest = shouldBufferOutput
+                    ? {
+                        ...modelRequest,
+                        model: new BufferedOutputProxyChatModel(modelRequest.model, async (message, outputText) => {
+                            if (message.tool_calls?.length || message.invalid_tool_calls?.length) {
+                                bufferedOutputResolution = {
+                                    finalMessage: cloneAiMessage(message),
+                                    matched: false,
+                                    source: 'rule',
+                                    reason: 'tool-call-skip',
+                                    errorPolicyTriggered: false,
+                                };
+                                return bufferedOutputResolution;
+                            }
+                            const outputMatches = findMatches(outputText, 'output', compiledRules, normalize, caseSensitive);
+                            const winner = pickWinningRule(outputMatches);
+                            if (!winner) {
+                                bufferedOutputResolution = {
+                                    finalMessage: cloneAiMessage(message),
+                                    matched: false,
+                                    source: 'rule',
+                                    errorPolicyTriggered: false,
+                                };
+                                return bufferedOutputResolution;
+                            }
+                            const finalText = winner.action === 'block'
+                                ? winner.replacementText?.trim() || DEFAULT_OUTPUT_BLOCK_MESSAGE
+                                : rewriteTextByRule(outputText, winner, caseSensitive);
+                            bufferedOutputResolution = {
+                                finalMessage: cloneAiMessageWithText(message, finalText),
+                                matched: true,
+                                source: 'rule',
+                                action: winner.action,
+                                reason: `rule:${winner.id}`,
+                                errorPolicyTriggered: false,
+                            };
+                            return bufferedOutputResolution;
+                        }),
+                    }
+                    : modelRequest;
+                const response = await handler(effectiveRequest);
+                if (bufferedOutputResolution) {
+                    pushAudit({
+                        phase: 'output',
+                        matched: bufferedOutputResolution.matched,
+                        source: bufferedOutputResolution.source,
+                        action: bufferedOutputResolution.action,
+                        reason: bufferedOutputResolution.reason,
+                        errorPolicyTriggered: bufferedOutputResolution.errorPolicyTriggered,
+                    });
+                    if (bufferedOutputResolution.matched && bufferedOutputResolution.action) {
+                        finalAction = bufferedOutputResolution.action === 'block' ? 'block' : 'rewrite';
+                    }
+                    return response;
+                }
                 const outputText = extractModelResponseText(response);
                 const outputMatches = findMatches(outputText, 'output', compiledRules, normalize, caseSensitive);
                 const winner = pickWinningRule(outputMatches);
@@ -883,6 +1114,7 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
             return structuredModelPromises.get(method);
         };
         let pendingInputRewrite = null;
+        let bufferedOutputResolution = null;
         let finalAction = 'pass';
         let auditEntries = [];
         let runtimeConfigurable = null;
@@ -891,6 +1123,7 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
         let methodAttempts = [];
         const resetRunState = () => {
             pendingInputRewrite = null;
+            bufferedOutputResolution = null;
             finalAction = 'pass';
             auditEntries = [];
             resolvedOutputMethod = undefined;
@@ -1082,6 +1315,12 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
         };
         const resolveOnErrorDecision = (llmConfig, error) => {
             const reason = `llm-error:${error instanceof Error ? error.message : String(error)}`;
+            if (shouldFailOpenOnLlmError(error)) {
+                return {
+                    matched: false,
+                    reason: `llm-fail-open:${reason}`,
+                };
+            }
             return {
                 matched: true,
                 action: 'rewrite',
@@ -1145,7 +1384,70 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
                 const llmConfig = getLlmConfig();
                 const modelRequest = pendingInputRewrite ? rewriteModelRequestInput(request, pendingInputRewrite) : request;
                 pendingInputRewrite = null;
-                const response = await handler(modelRequest);
+                bufferedOutputResolution = null;
+                const effectiveRequest = modeIncludesScope(llmConfig.scope, 'output')
+                    ? {
+                        ...modelRequest,
+                        model: new BufferedOutputProxyChatModel(modelRequest.model, async (message, outputText) => {
+                            if (message.tool_calls?.length || message.invalid_tool_calls?.length) {
+                                bufferedOutputResolution = {
+                                    finalMessage: cloneAiMessage(message),
+                                    matched: false,
+                                    source: 'llm',
+                                    reason: 'tool-call-skip',
+                                    errorPolicyTriggered: false,
+                                };
+                                return bufferedOutputResolution;
+                            }
+                            if (!outputText) {
+                                bufferedOutputResolution = {
+                                    finalMessage: cloneAiMessage(message),
+                                    matched: false,
+                                    source: 'llm',
+                                    reason: 'empty-output',
+                                    errorPolicyTriggered: false,
+                                };
+                                return bufferedOutputResolution;
+                            }
+                            let decision;
+                            let fromErrorPolicy = false;
+                            try {
+                                decision = await invokeAndTrack('output', outputText, request?.runtime, llmConfig);
+                            }
+                            catch (error) {
+                                decision = resolveOnErrorDecision(llmConfig, error);
+                                fromErrorPolicy = true;
+                            }
+                            const finalText = decision.matched && decision.action
+                                ? toNonEmptyString(decision.replacementText) ?? llmConfig.rewriteFallbackText
+                                : outputText;
+                            bufferedOutputResolution = {
+                                finalMessage: cloneAiMessageWithText(message, finalText),
+                                matched: decision.matched,
+                                source: fromErrorPolicy ? 'error-policy' : 'llm',
+                                action: decision.action,
+                                reason: decision.reason,
+                                errorPolicyTriggered: fromErrorPolicy,
+                            };
+                            return bufferedOutputResolution;
+                        }),
+                    }
+                    : modelRequest;
+                const response = await handler(effectiveRequest);
+                if (bufferedOutputResolution) {
+                    pushAudit({
+                        phase: 'output',
+                        matched: bufferedOutputResolution.matched,
+                        source: bufferedOutputResolution.source,
+                        action: bufferedOutputResolution.action,
+                        reason: bufferedOutputResolution.reason,
+                        errorPolicyTriggered: bufferedOutputResolution.errorPolicyTriggered,
+                    });
+                    if (bufferedOutputResolution.matched && bufferedOutputResolution.action) {
+                        finalAction = 'rewrite';
+                    }
+                    return response;
+                }
                 if (!modeIncludesScope(llmConfig.scope, 'output')) {
                     pushAudit({
                         phase: 'output',

package/dist/lib/types.d.ts

@@ -9,16 +9,12 @@ export type SensitiveRule = {
     action: 'block' | 'rewrite';
     replacementText?: string;
 };
-export type GeneralPackConfig = {
-    enabled?: boolean;
-    profile?: 'strict' | 'balanced';
-};
 export type RuleModeConfig = {
     mode?: 'rule';
     rules?: Array<Partial<SensitiveRule> | null>;
-    generalPack?: GeneralPackConfig;
     caseSensitive?: boolean;
     normalize?: boolean;
+    generalPack?: unknown;
 };
 export type LlmScope = 'input' | 'output' | 'both';
 export type LlmOutputMethod = 'functionCalling' | 'jsonMode' | 'jsonSchema';
@@ -38,6 +34,7 @@ export type LlmFilterConfig = {
 export type LlmModeConfig = {
     mode: 'llm';
     llm?: LlmFilterConfig | null;
+    generalPack?: unknown;
 };
 export type SensitiveFilterConfig = RuleModeConfig | LlmModeConfig;
 export type LlmDecision = {
@@ -81,21 +78,11 @@ export declare const sensitiveFilterConfigSchema: z.ZodUnion<[z.ZodObject<{
         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>>;
     llm: z.ZodOptional<z.ZodUnknown>;
+    generalPack: z.ZodOptional<z.ZodUnknown>;
 }, "strip", z.ZodTypeAny, {
-    llm?: unknown;
     mode?: "rule";
     rules?: {
         id?: string;
@@ -106,14 +93,11 @@ export declare const sensitiveFilterConfigSchema: z.ZodUnion<[z.ZodObject<{
         action?: "block" | "rewrite";
         replacementText?: string;
     }[];
-    generalPack?: {
-        enabled?: boolean;
-        profile?: "strict" | "balanced";
-    };
     caseSensitive?: boolean;
     normalize?: boolean;
-}, {
     llm?: unknown;
+    generalPack?: unknown;
+}, {
     mode?: "rule";
     rules?: {
         id?: string;
@@ -124,12 +108,10 @@ export declare const sensitiveFilterConfigSchema: z.ZodUnion<[z.ZodObject<{
         action?: "block" | "rewrite";
         replacementText?: string;
     }[];
-    generalPack?: {
-        enabled?: boolean;
-        profile?: "strict" | "balanced";
-    };
     caseSensitive?: boolean;
     normalize?: boolean;
+    llm?: unknown;
+    generalPack?: unknown;
 }>, z.ZodObject<{
     mode: z.ZodLiteral<"llm">;
     llm: z.ZodDefault<z.ZodNullable<z.ZodOptional<z.ZodObject<{
@@ -167,10 +149,14 @@ export declare const sensitiveFilterConfigSchema: z.ZodUnion<[z.ZodObject<{
         timeoutMs?: number;
     }>>>>;
     rules: z.ZodOptional<z.ZodUnknown>;
-    generalPack: z.ZodOptional<z.ZodUnknown>;
     caseSensitive: z.ZodOptional<z.ZodUnknown>;
     normalize: z.ZodOptional<z.ZodUnknown>;
+    generalPack: z.ZodOptional<z.ZodUnknown>;
 }, "strip", z.ZodTypeAny, {
+    mode?: "llm";
+    rules?: unknown;
+    caseSensitive?: unknown;
+    normalize?: unknown;
     llm?: {
         scope?: "input" | "output" | "both";
         model?: ICopilotModel;
@@ -183,12 +169,12 @@ export declare const sensitiveFilterConfigSchema: z.ZodUnion<[z.ZodObject<{
         rewriteFallbackText?: string;
         timeoutMs?: number;
     };
+    generalPack?: unknown;
+}, {
     mode?: "llm";
     rules?: unknown;
-    generalPack?: unknown;
     caseSensitive?: unknown;
     normalize?: unknown;
-}, {
     llm?: {
         scope?: "input" | "output" | "both";
         model?: ICopilotModel;
@@ -201,11 +187,7 @@ export declare const sensitiveFilterConfigSchema: z.ZodUnion<[z.ZodObject<{
         rewriteFallbackText?: string;
         timeoutMs?: number;
     };
-    mode?: "llm";
-    rules?: unknown;
     generalPack?: unknown;
-    caseSensitive?: unknown;
-    normalize?: unknown;
 }>]>;
 export declare const llmDecisionSchema: z.ZodObject<{
     matched: z.ZodBoolean;
@@ -226,5 +208,4 @@ export declare const llmDecisionSchema: z.ZodObject<{
     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,cAAc,GAAG;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,CAAA;IAC5C,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,SAAS,CAAC,EAAE,OAAO,CAAA;IAEnB,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB,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;IAE5B,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB,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;AAgD9T,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAuD,CAAA;AAE/F,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;EAM5B,CAAA"}

package/dist/lib/types.js

@@ -1,20 +1,5 @@
 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(),
@@ -26,10 +11,6 @@ const sensitiveRuleDraftSchema = z
     replacementText: z.string().optional().nullable(),
 })
     .nullable();
-const generalPackSchema = z.object({
-    enabled: z.boolean().default(false),
-    profile: z.enum(['strict', 'balanced']).default('balanced').optional(),
-});
 const llmConfigSchema = z
     .object({
     model: z.custom().optional().nullable(),
@@ -46,73 +27,26 @@ const llmConfigSchema = z
 const ruleModeConfigSchema = z.object({
     mode: z.literal('rule').optional(),
     rules: z.array(sensitiveRuleDraftSchema).optional().default([]),
-    generalPack: generalPackSchema.optional(),
     caseSensitive: z.boolean().optional().default(false),
     normalize: z.boolean().optional().default(true),
     llm: z.unknown().optional(),
+    // Backward compatibility only.
+    generalPack: z.unknown().optional(),
 });
 const llmModeConfigSchema = z.object({
     mode: z.literal('llm'),
     llm: llmConfigSchema.optional().nullable().default({}),
     rules: z.unknown().optional(),
-    generalPack: z.unknown().optional(),
     caseSensitive: z.unknown().optional(),
     normalize: z.unknown().optional(),
+    // Backward compatibility only.
+    generalPack: z.unknown().optional(),
 });
 export const sensitiveFilterConfigSchema = z.union([ruleModeConfigSchema, llmModeConfigSchema]);
-export const llmDecisionSchema = z
-    .object({
+export const llmDecisionSchema = z.object({
     matched: z.boolean(),
     action: z.enum(['block', 'rewrite']).optional().nullable(),
     replacementText: z.string().optional().nullable(),
     reason: z.string().optional().nullable(),
     categories: z.array(z.string()).optional().nullable(),
 });
-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

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