plugin-sensitive-filter-xr 0.0.2 → 0.0.4

package/dist/lib/types.d.ts

@@ -1,3 +1,4 @@
+import type { ICopilotModel } from '@metad/contracts';
 import { z } from 'zod/v3';
 export type SensitiveRule = {
     id: string;
@@ -12,12 +13,39 @@ export type GeneralPackConfig = {
     enabled?: boolean;
     profile?: 'strict' | 'balanced';
 };
-export type SensitiveFilterConfig = {
-    rules: Array<Partial<SensitiveRule> | null>;
+export type RuleModeConfig = {
+    mode?: 'rule';
+    rules?: Array<Partial<SensitiveRule> | null>;
     generalPack?: GeneralPackConfig;
     caseSensitive?: boolean;
     normalize?: boolean;
 };
+export type LlmScope = 'input' | 'output' | 'both';
+export type LlmOutputMethod = 'functionCalling' | 'jsonMode' | 'jsonSchema';
+export type LlmErrorAction = 'block' | 'rewrite';
+export type LlmFilterConfig = {
+    model?: ICopilotModel;
+    scope?: LlmScope;
+    systemPrompt?: string;
+    outputMethod?: LlmOutputMethod;
+    onLlmError?: LlmErrorAction;
+    errorRewriteText?: string;
+    blockMessage?: string;
+    rewriteFallbackText?: string;
+    timeoutMs?: number;
+};
+export type LlmModeConfig = {
+    mode: 'llm';
+    llm?: LlmFilterConfig | null;
+};
+export type SensitiveFilterConfig = RuleModeConfig | LlmModeConfig;
+export type LlmDecision = {
+    matched: boolean;
+    action?: 'block' | 'rewrite';
+    replacementText?: string | null;
+    reason?: string | null;
+    categories?: string[] | null;
+};
 export type CompiledSensitiveRule = SensitiveRule & {
     index: number;
     normalizedPattern: string;
@@ -25,48 +53,33 @@ export type CompiledSensitiveRule = SensitiveRule & {
     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.ZodArray<z.ZodNullable<z.ZodEffects<z.ZodObject<{
+export declare const sensitiveFilterConfigSchema: z.ZodUnion<[z.ZodObject<{
+    mode: z.ZodOptional<z.ZodLiteral<"rule">>;
+    rules: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNullable<z.ZodObject<{
         id: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-        pattern: z.ZodString;
-        type: z.ZodEnum<["keyword", "regex"]>;
+        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.ZodEnum<["block", "rewrite"]>;
+        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;
-    }>, {
-        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";
         replacementText?: string;
-    }>>, "many">;
+    }>>, "many">>>;
     generalPack: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         profile: z.ZodOptional<z.ZodDefault<z.ZodEnum<["strict", "balanced"]>>>;
@@ -79,11 +92,15 @@ export declare const sensitiveFilterConfigSchema: z.ZodObject<{
     }>>;
     caseSensitive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     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";
@@ -94,12 +111,14 @@ export declare const sensitiveFilterConfigSchema: z.ZodObject<{
         profile?: "strict" | "balanced";
     };
     caseSensitive?: boolean;
-    normalize?: 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";
@@ -110,7 +129,108 @@ export declare const sensitiveFilterConfigSchema: z.ZodObject<{
         profile?: "strict" | "balanced";
     };
     caseSensitive?: boolean;
-    normalize?: boolean;
+}>, 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"]>>>;
+        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"]>>>;
+        errorRewriteText: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        blockMessage: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        rewriteFallbackText: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        timeoutMs: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        model?: ICopilotModel;
+        scope?: "input" | "output" | "both";
+        systemPrompt?: string;
+        outputMethod?: "functionCalling" | "jsonMode" | "jsonSchema";
+        onLlmError?: "block" | "rewrite";
+        errorRewriteText?: string;
+        blockMessage?: string;
+        rewriteFallbackText?: string;
+        timeoutMs?: number;
+    }, {
+        model?: ICopilotModel;
+        scope?: "input" | "output" | "both";
+        systemPrompt?: string;
+        outputMethod?: "functionCalling" | "jsonMode" | "jsonSchema";
+        onLlmError?: "block" | "rewrite";
+        errorRewriteText?: string;
+        blockMessage?: string;
+        rewriteFallbackText?: string;
+        timeoutMs?: number;
+    }>>>>;
+    rules: z.ZodOptional<z.ZodUnknown>;
+    generalPack: z.ZodOptional<z.ZodUnknown>;
+    caseSensitive: z.ZodOptional<z.ZodUnknown>;
+    normalize: z.ZodOptional<z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    normalize?: unknown;
+    llm?: {
+        model?: ICopilotModel;
+        scope?: "input" | "output" | "both";
+        systemPrompt?: string;
+        outputMethod?: "functionCalling" | "jsonMode" | "jsonSchema";
+        onLlmError?: "block" | "rewrite";
+        errorRewriteText?: string;
+        blockMessage?: string;
+        rewriteFallbackText?: string;
+        timeoutMs?: number;
+    };
+    mode?: "llm";
+    rules?: unknown;
+    generalPack?: unknown;
+    caseSensitive?: unknown;
+}, {
+    normalize?: unknown;
+    llm?: {
+        model?: ICopilotModel;
+        scope?: "input" | "output" | "both";
+        systemPrompt?: string;
+        outputMethod?: "functionCalling" | "jsonMode" | "jsonSchema";
+        onLlmError?: "block" | "rewrite";
+        errorRewriteText?: string;
+        blockMessage?: string;
+        rewriteFallbackText?: string;
+        timeoutMs?: number;
+    };
+    mode?: "llm";
+    rules?: unknown;
+    generalPack?: unknown;
+    caseSensitive?: unknown;
+}>]>;
+export declare const llmDecisionSchema: z.ZodEffects<z.ZodObject<{
+    matched: z.ZodBoolean;
+    action: 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">>>;
+}, "strip", z.ZodTypeAny, {
+    action?: "block" | "rewrite";
+    replacementText?: string;
+    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[];
+}, {
+    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":"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,EAAE,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,CAAA;IAC3C,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;AAoD9T,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKtC,CAAA;AAYF,wBAAgB,uBAAuB,CAAC,MAAM,CAAC,EAAE,iBAAiB,GAAG,aAAa,EAAE,CA6CnF"}
+{"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,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,YAAY,CAAC,EAAE,eAAe,CAAA;IAC9B,UAAU,CAAC,EAAE,cAAc,CAAA;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,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;AAkE9T,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAuD,CAAA;AAE/F,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgB1B,CAAA;AAYJ,wBAAgB,uBAAuB,CAAC,MAAM,CAAC,EAAE,iBAAiB,GAAG,aAAa,EAAE,CA6CnF"}

package/dist/lib/types.js

@@ -18,39 +18,63 @@ const OPEN_SOURCE_LEXICON = {
 const sensitiveRuleDraftSchema = z
     .object({
     id: z.string().optional().nullable(),
-    pattern: z.string(),
-    type: z.enum(['keyword', 'regex']),
+    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']),
+    action: z.enum(['block', 'rewrite']).optional().nullable(),
     replacementText: z.string().optional().nullable(),
-})
-    .superRefine((value, ctx) => {
-    if (!value.pattern?.trim()) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ['pattern'],
-            message: 'pattern is required',
-        });
-    }
-    if (value.action === 'rewrite' && !value.replacementText?.trim()) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ['replacementText'],
-            message: 'replacementText is required when action is rewrite',
-        });
-    }
 })
     .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).min(1, 'at least one business rule is required'),
+const llmConfigSchema = z
+    .object({
+    model: z.custom().optional().nullable(),
+    scope: z.enum(['input', 'output', 'both']).optional().nullable(),
+    systemPrompt: z.string().optional().nullable(),
+    outputMethod: z.enum(['functionCalling', 'jsonMode', 'jsonSchema']).optional().default('jsonSchema'),
+    onLlmError: z.enum(['block', 'rewrite']).optional().nullable(),
+    errorRewriteText: z.string().optional().nullable(),
+    blockMessage: z.string().optional().nullable(),
+    rewriteFallbackText: z.string().optional().nullable(),
+    timeoutMs: z.number().int().positive().max(120000).optional().nullable(),
+});
+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(),
+});
+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(),
+});
+export const sensitiveFilterConfigSchema = z.union([ruleModeConfigSchema, llmModeConfigSchema]);
+export const llmDecisionSchema = z
+    .object({
+    matched: z.boolean(),
+    action: z.enum(['block', 'rewrite']).optional(),
+    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.2",
+  "version": "0.0.4",
   "author": {
     "name": "XpertAI",
     "url": "https://xpertai.cn"