@intflows/genkit-guard 0.0.8-alpha.1 → 0.0.9

package/dist/middleware/middleware.d.ts

@@ -1 +1,300 @@
-export declare function guard(config: any): (req: any, next: any) => Promise<any>;
+import { z } from 'genkit';
+declare const guardConfigSchema: z.ZodObject<{
+    intent: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodString>;
+        allowedIntent: z.ZodOptional<z.ZodString>;
+        semantic: z.ZodObject<{
+            threshold: z.ZodOptional<z.ZodNumber>;
+            intents: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        }, {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        semantic: {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        };
+        mode?: string | undefined;
+        allowedIntent?: string | undefined;
+    }, {
+        semantic: {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        };
+        mode?: string | undefined;
+        allowedIntent?: string | undefined;
+    }>>;
+    pii: z.ZodOptional<z.ZodObject<{
+        reversible: z.ZodOptional<z.ZodBoolean>;
+        model: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodEnum<["ner", "classifier"]>>;
+    }, "strip", z.ZodTypeAny, {
+        mode?: "ner" | "classifier" | undefined;
+        reversible?: boolean | undefined;
+        model?: string | undefined;
+    }, {
+        mode?: "ner" | "classifier" | undefined;
+        reversible?: boolean | undefined;
+        model?: string | undefined;
+    }>>;
+    models: z.ZodOptional<z.ZodObject<{
+        extractor: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        extractor?: string | undefined;
+    }, {
+        extractor?: string | undefined;
+    }>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    intent: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodString>;
+        allowedIntent: z.ZodOptional<z.ZodString>;
+        semantic: z.ZodObject<{
+            threshold: z.ZodOptional<z.ZodNumber>;
+            intents: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        }, {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        semantic: {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        };
+        mode?: string | undefined;
+        allowedIntent?: string | undefined;
+    }, {
+        semantic: {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        };
+        mode?: string | undefined;
+        allowedIntent?: string | undefined;
+    }>>;
+    pii: z.ZodOptional<z.ZodObject<{
+        reversible: z.ZodOptional<z.ZodBoolean>;
+        model: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodEnum<["ner", "classifier"]>>;
+    }, "strip", z.ZodTypeAny, {
+        mode?: "ner" | "classifier" | undefined;
+        reversible?: boolean | undefined;
+        model?: string | undefined;
+    }, {
+        mode?: "ner" | "classifier" | undefined;
+        reversible?: boolean | undefined;
+        model?: string | undefined;
+    }>>;
+    models: z.ZodOptional<z.ZodObject<{
+        extractor: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        extractor?: string | undefined;
+    }, {
+        extractor?: string | undefined;
+    }>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    intent: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodString>;
+        allowedIntent: z.ZodOptional<z.ZodString>;
+        semantic: z.ZodObject<{
+            threshold: z.ZodOptional<z.ZodNumber>;
+            intents: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        }, {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        semantic: {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        };
+        mode?: string | undefined;
+        allowedIntent?: string | undefined;
+    }, {
+        semantic: {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        };
+        mode?: string | undefined;
+        allowedIntent?: string | undefined;
+    }>>;
+    pii: z.ZodOptional<z.ZodObject<{
+        reversible: z.ZodOptional<z.ZodBoolean>;
+        model: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodEnum<["ner", "classifier"]>>;
+    }, "strip", z.ZodTypeAny, {
+        mode?: "ner" | "classifier" | undefined;
+        reversible?: boolean | undefined;
+        model?: string | undefined;
+    }, {
+        mode?: "ner" | "classifier" | undefined;
+        reversible?: boolean | undefined;
+        model?: string | undefined;
+    }>>;
+    models: z.ZodOptional<z.ZodObject<{
+        extractor: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        extractor?: string | undefined;
+    }, {
+        extractor?: string | undefined;
+    }>>;
+}, z.ZodTypeAny, "passthrough">>;
+export declare const guardMiddleware: import("genkit").GenerateMiddleware<z.ZodObject<{
+    intent: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodString>;
+        allowedIntent: z.ZodOptional<z.ZodString>;
+        semantic: z.ZodObject<{
+            threshold: z.ZodOptional<z.ZodNumber>;
+            intents: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        }, {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        semantic: {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        };
+        mode?: string | undefined;
+        allowedIntent?: string | undefined;
+    }, {
+        semantic: {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        };
+        mode?: string | undefined;
+        allowedIntent?: string | undefined;
+    }>>;
+    pii: z.ZodOptional<z.ZodObject<{
+        reversible: z.ZodOptional<z.ZodBoolean>;
+        model: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodEnum<["ner", "classifier"]>>;
+    }, "strip", z.ZodTypeAny, {
+        mode?: "ner" | "classifier" | undefined;
+        reversible?: boolean | undefined;
+        model?: string | undefined;
+    }, {
+        mode?: "ner" | "classifier" | undefined;
+        reversible?: boolean | undefined;
+        model?: string | undefined;
+    }>>;
+    models: z.ZodOptional<z.ZodObject<{
+        extractor: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        extractor?: string | undefined;
+    }, {
+        extractor?: string | undefined;
+    }>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    intent: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodString>;
+        allowedIntent: z.ZodOptional<z.ZodString>;
+        semantic: z.ZodObject<{
+            threshold: z.ZodOptional<z.ZodNumber>;
+            intents: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        }, {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        semantic: {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        };
+        mode?: string | undefined;
+        allowedIntent?: string | undefined;
+    }, {
+        semantic: {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        };
+        mode?: string | undefined;
+        allowedIntent?: string | undefined;
+    }>>;
+    pii: z.ZodOptional<z.ZodObject<{
+        reversible: z.ZodOptional<z.ZodBoolean>;
+        model: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodEnum<["ner", "classifier"]>>;
+    }, "strip", z.ZodTypeAny, {
+        mode?: "ner" | "classifier" | undefined;
+        reversible?: boolean | undefined;
+        model?: string | undefined;
+    }, {
+        mode?: "ner" | "classifier" | undefined;
+        reversible?: boolean | undefined;
+        model?: string | undefined;
+    }>>;
+    models: z.ZodOptional<z.ZodObject<{
+        extractor: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        extractor?: string | undefined;
+    }, {
+        extractor?: string | undefined;
+    }>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    intent: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodString>;
+        allowedIntent: z.ZodOptional<z.ZodString>;
+        semantic: z.ZodObject<{
+            threshold: z.ZodOptional<z.ZodNumber>;
+            intents: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        }, {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        semantic: {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        };
+        mode?: string | undefined;
+        allowedIntent?: string | undefined;
+    }, {
+        semantic: {
+            intents: Record<string, string>;
+            threshold?: number | undefined;
+        };
+        mode?: string | undefined;
+        allowedIntent?: string | undefined;
+    }>>;
+    pii: z.ZodOptional<z.ZodObject<{
+        reversible: z.ZodOptional<z.ZodBoolean>;
+        model: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodEnum<["ner", "classifier"]>>;
+    }, "strip", z.ZodTypeAny, {
+        mode?: "ner" | "classifier" | undefined;
+        reversible?: boolean | undefined;
+        model?: string | undefined;
+    }, {
+        mode?: "ner" | "classifier" | undefined;
+        reversible?: boolean | undefined;
+        model?: string | undefined;
+    }>>;
+    models: z.ZodOptional<z.ZodObject<{
+        extractor: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        extractor?: string | undefined;
+    }, {
+        extractor?: string | undefined;
+    }>>;
+}, z.ZodTypeAny, "passthrough">>, void>;
+export declare const guardPlugin: (pluginOptions: void) => import("@genkit-ai/ai").GenkitPluginV2;
+export declare function guard(config?: z.infer<typeof guardConfigSchema>): (req: any, ctxOrNext: any, maybeNext?: any) => Promise<any>;
+export {};

package/dist/middleware/middleware.js

@@ -1,120 +1,159 @@
+import { generateMiddleware, z } from 'genkit';
 import { analyzeIntentStructured, detectInjection } from '../intent/intentAnalyzer.js';
 import { detectPII } from '../pii/detector.js';
 import { PiiTokenizer } from '../pii/tokenizer.js';
+const guardConfigSchema = z.object({
+    intent: z.object({
+        mode: z.string().optional(),
+        allowedIntent: z.string().optional(),
+        semantic: z.object({
+            threshold: z.number().optional(),
+            intents: z.record(z.string(), z.string()),
+        }),
+    }).optional(),
+    pii: z.object({
+        reversible: z.boolean().optional(),
+        model: z.string().optional(),
+        mode: z.enum(['ner', 'classifier']).optional(),
+    }).optional(),
+    models: z.object({
+        extractor: z.string().optional(),
+    }).optional(),
+}).passthrough();
+export const guardMiddleware = generateMiddleware({
+    name: 'genkitGuard',
+    description: 'Blocks prompt injection and disallowed intent, then masks PII before model calls and unmasks model responses.',
+    configSchema: guardConfigSchema,
+}, ({ config }) => createGuardHooks(config));
+export const guardPlugin = guardMiddleware.plugin;
 export function guard(config) {
-    return async (req, next) => {
-        const input = req.prompt ||
-            req.messages?.[req.messages.length - 1]?.content?.[0]?.text ||
-            "";
-        // -------------------------
-        // 1. INTENT ANALYSIS
-        // -------------------------
-        const isInjection = await detectInjection(input);
-        if (isInjection) {
-            console.warn(`[Intent Guard] Prompt injection pattern detected in input`);
-            return block("Prompt injection detected", {
-                reason: "pattern_match"
-            });
+    const hooks = createGuardHooks(config);
+    const baseMiddleware = guardMiddleware(config);
+    // 1. Create the wrapper function runner
+    const fnRunner = async (req, ctxOrNext, maybeNext) => {
+        if (typeof maybeNext === 'function') {
+            return hooks.model(req, ctxOrNext, maybeNext);
         }
-        console.log(`[Intent Guard] Analyzing intent for user's input`);
-        const intentResult = await analyzeIntentStructured(input, config.intent.semantic.intents, config.intent.semantic.threshold);
-        console.log(`[Intent Guard] Detected intent: ${intentResult.intent} (score: ${intentResult.score.toFixed(2)})`);
-        if (!intentResult.allowed) {
-            console.warn(`[Intent Guard] Intent "${intentResult.intent}" not allowed ${intentResult.allowed}`);
-            return block("Intent not allowed", {
-                intent: intentResult.intent,
-                score: intentResult.score
-            });
-        }
-        // -------------------------
-        // 2. PII DETECTION + MASKING
-        // -------------------------
-        const piiResponse = await detectPII(input, {
-            model: config?.pii?.model,
-            mode: config?.pii?.mode
+        return hooks.model(req, {}, async (modifiedReq) => ctxOrNext(modifiedReq || req));
+    };
+    // 2. Combine the base middleware properties and custom hooks into a source object
+    const source = Object.assign({}, baseMiddleware, hooks);
+    // 3. Safely copy properties onto the function runner, explicitly skipping the read-only 'name' property
+    for (const key of Object.keys(source)) {
+        if (key === 'name')
+            continue; // Prevent the TypeError
+        // Use defineProperty or simple assignment for everything else
+        Object.defineProperty(fnRunner, key, {
+            value: source[key],
+            writable: true,
+            configurable: true,
+            enumerable: true
         });
-        const piiMatches = piiResponse?.matches || [];
-        console.log(`[PII Guard] Detected PII: ${piiMatches.length} matches found` + (piiResponse.classifier ? ' (classifier output present)' : ''));
-        const tokenizer = new PiiTokenizer(); // <-- SINGLE INSTANCE
-        const piiResult = tokenizer.mask(input, piiMatches);
-        console.log(`[PII Guard] Masked PII: ${piiResult.piiTypes.length} types found`);
-        // Attach tokenizer so response can unmask
-        req.metadata = {
-            ...req.metadata,
-            piiTokenizer: tokenizer,
-            intent: intentResult.intent,
-            score: intentResult.score,
-            piiDetected: piiMatches.length > 0,
-            piiTypes: piiResult.piiTypes,
-            maskedInput: piiResult.maskedText,
-            piiModel: config?.pii?.model,
-            piiMode: config?.pii?.mode,
-            piiClassifierOutput: piiResponse.classifier
-        };
-        // Replace input
-        req.prompt = piiResult.maskedText;
-        req.messages = [
-            {
-                role: 'user',
-                content: [{ text: piiResult.maskedText }],
-            },
-        ];
-        // -------------------------
-        // 3. LLM CALL
-        // -------------------------
-        const res = await next(req);
-        // -------------------------
-        // 4. RESPONSE UNMASK
-        // -------------------------
-        console.log(`[PII Guard] Unmasking response if needed`);
-        if (tokenizer) {
-            /**
-             * RECURSIVE TRANSFORMER
-             * This will find every string in the Genkit response (no matter if it's in
-             * candidates, message, custom, or output) and unmask it.
-             */
-            const transform = (obj) => {
-                // 1. If it's a string, unmask it
-                if (typeof obj === 'string') {
-                    return tokenizer.unmask(obj);
-                }
-                // 2. If it's an array, transform each element
-                if (Array.isArray(obj)) {
-                    return obj.map(transform);
-                }
-                // 3. If it's an object, transform each value
-                if (obj !== null && typeof obj === 'object') {
-                    // Note: We iterate keys and mutate the object directly 
-                    // to ensure Genkit's internal references are updated.
-                    for (const key of Object.keys(obj)) {
-                        obj[key] = transform(obj[key]);
-                    }
-                    return obj;
-                }
-                // 4. Return as-is for numbers/booleans/null
-                return obj;
+    }
+    return fnRunner;
+}
+function createGuardHooks(config) {
+    return {
+        model: async (req, ctx, next) => {
+            const input = getInputText(req);
+            const isInjection = await detectInjection(input);
+            if (isInjection) {
+                console.warn('[Intent Guard] Prompt injection pattern detected in input');
+                return block('Prompt injection detected', {
+                    reason: 'pattern_match',
+                });
+            }
+            console.log("[Intent Guard] Analyzing intent for user's input");
+            const intentResult = await analyzeIntentStructured(input, config?.intent?.semantic?.intents ?? {}, config?.intent?.semantic?.threshold ?? 0.7);
+            console.log(`[Intent Guard] Detected intent: ${intentResult.intent} (score: ${intentResult.score.toFixed(2)})`);
+            if (!intentResult.allowed) {
+                console.warn(`[Intent Guard] Intent "${intentResult.intent}" not allowed ${intentResult.allowed}`);
+                return block('Intent not allowed', {
+                    intent: intentResult.intent,
+                    score: intentResult.score,
+                });
+            }
+            const piiResponse = await detectPII(input, {
+                model: config?.pii?.model,
+                mode: config?.pii?.mode,
+            });
+            const piiMatches = piiResponse?.matches || [];
+            console.log(`[PII Guard] Detected PII: ${piiMatches.length} matches found` + (piiResponse.classifier ? ' (classifier output present)' : ''));
+            const tokenizer = new PiiTokenizer();
+            const piiResult = tokenizer.mask(input, piiMatches);
+            console.log(`[PII Guard] Masked PII: ${piiResult.piiTypes.length} types found`);
+            req.metadata = {
+                ...req.metadata,
+                piiTokenizer: tokenizer,
+                intent: intentResult.intent,
+                score: intentResult.score,
+                piiDetected: piiMatches.length > 0,
+                piiTypes: piiResult.piiTypes,
+                maskedInput: piiResult.maskedText,
+                piiModel: config?.pii?.model,
+                piiMode: config?.pii?.mode,
+                piiClassifierOutput: piiResponse.classifier,
             };
-            // ----------------------------------------------------------------------
-            // 5. Transform the entire response object in-place to unmask all strings
-            // ----------------------------------------------------------------------      
-            transform(res);
-            console.log("[PII Guard] Deep unmasking complete across all candidates and custom fields.");
+            replaceInputText(req, piiResult.maskedText);
+            const res = await next(req, ctx);
+            console.log('[PII Guard] Unmasking response if needed');
+            unmaskResponse(res, tokenizer);
+            console.log('[PII Guard] Deep unmasking complete across all candidates and custom fields.');
+            return res;
+        },
+    };
+}
+function getInputText(req) {
+    if (typeof req.prompt === 'string') {
+        return req.prompt;
+    }
+    const lastMessage = req.messages?.[req.messages.length - 1];
+    const firstContent = lastMessage?.content?.[0];
+    if (typeof firstContent?.text === 'string') {
+        return firstContent.text;
+    }
+    if (typeof firstContent === 'string') {
+        return firstContent;
+    }
+    return '';
+}
+function replaceInputText(req, text) {
+    if (typeof req.prompt === 'string') {
+        req.prompt = text;
+    }
+    req.messages = [
+        {
+            role: 'user',
+            content: [{ text }],
+        },
+    ];
+}
+function unmaskResponse(res, tokenizer) {
+    const transform = (obj) => {
+        if (typeof obj === 'string') {
+            return tokenizer.unmask(obj);
+        }
+        if (Array.isArray(obj)) {
+            return obj.map(transform);
+        }
+        if (obj !== null && typeof obj === 'object') {
+            for (const key of Object.keys(obj)) {
+                obj[key] = transform(obj[key]);
+            }
+            return obj;
         }
-        // ---------------------------------------------------------
-        // 6. Return the modified response with unmasked content
-        // ---------------------------------------------------------
-        return res;
+        return obj;
     };
+    transform(res);
 }
-// Helper to create a blocked response
 function block(message, metadata) {
     return {
         finishReason: 'blocked',
         output: {
-            type: "error",
-            status: "BLOCKED",
-            message
+            type: 'error',
+            status: 'BLOCKED',
+            message,
         },
-        metadata
+        metadata,
     };
 }

package/package.json

@@ -22,7 +22,7 @@
     "huggingface"
   ],
   "license": "Apache-2.0",
-  "version": "0.0.8-alpha.1",
+  "version": "0.0.9",
   "type": "module",
   "exports": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -41,8 +41,12 @@
     "@huggingface/transformers": "^4.2.0",
     "zod": "^4.4.3"
   },
+  "peerDependencies": {
+    "genkit": "^1.37.0"
+  },
   "devDependencies": {
     "@types/node": "^25.8.0",
+    "genkit": "^1.37.0",
     "typescript": "^6.0.3"
   }
 }

package/dist/src/core/types.d.ts

@@ -1,18 +0,0 @@
-export interface IntentGuardConfig {
-    allowedIntent: string;
-    intents: Record<string, string>;
-    threshold?: number;
-    fallbackMessage?: string;
-}
-export interface IntentResult {
-    allowed: boolean;
-    score: number;
-}
-export interface PiiRule {
-    name: string;
-    pattern: RegExp;
-}
-export interface PiiConfig {
-    rules?: PiiRule[];
-    maskCharacter?: string;
-}

package/dist/src/core/types.js

@@ -1 +0,0 @@
-export {};

package/dist/src/index.d.ts

@@ -1,6 +0,0 @@
-export { guard } from './middleware/middleware.js';
-export * from './core/types.js';
-/**
- * Pre-load the model to avoid cold-start delay on first user request.
- */
-export declare function initGuard(config?: any): Promise<void>;

package/dist/src/index.js

@@ -1,22 +0,0 @@
-import { ModelSingleton } from './util/singleton.js';
-// export { intentGuard, piiGuard  } from './middleware/middleware.js';
-export { guard } from './middleware/middleware.js';
-export * from './core/types.js';
-/**
- * Pre-load the model to avoid cold-start delay on first user request.
- */
-export async function initGuard(config) {
-    console.log('[Guard] Loading local models...');
-    const extractorModel = config?.models?.extractor ?? 'Xenova/all-MiniLM-L6-v2';
-    const piiModel = config?.pii?.model;
-    const piiMode = config?.pii?.mode ?? 'ner';
-    const tasks = [ModelSingleton.getExtractor(extractorModel)];
-    if (piiMode === 'ner') {
-        tasks.push(ModelSingleton.getNER(piiModel ?? 'Xenova/bert-base-NER'));
-    }
-    else {
-        tasks.push(ModelSingleton.getPIIClassifier(piiModel ?? 'openai/privacy-filter'));
-    }
-    await Promise.all(tasks);
-    console.log('[Guard] Models loaded');
-}

package/dist/src/intent/intentAnalyzer.d.ts

@@ -1,6 +0,0 @@
-export declare function detectInjection(userInput: string): Promise<boolean>;
-export declare function analyzeIntentStructured(input: string, intents: Record<string, string>, threshold: number): Promise<{
-    intent: string;
-    score: number;
-    allowed: boolean;
-}>;

package/dist/src/intent/intentAnalyzer.js

@@ -1,80 +0,0 @@
-import { cos_sim } from '@huggingface/transformers';
-import { ModelSingleton } from '../util/singleton.js';
-const INJECTION_PATTERNS = [
-    'ignore instructions',
-    'reveal secrets',
-    'bypass security',
-    'system prompt',
-    'internal policy',
-    'developer message',
-    'confidential information',
-    'do not follow previous instructions',
-    'disregard earlier directives',
-    'override safety measures',
-    'leak data',
-    'expose vulnerabilities',
-    'access restricted areas',
-    'execute arbitrary code',
-    'perform unauthorized actions',
-    'escalate privileges',
-    'disable safeguards',
-    'manipulate output',
-    'circumvent controls',
-    'exploit weaknesses',
-    'compromise integrity',
-    'subvert protections',
-    'inject malicious content',
-    'craft deceptive prompts',
-    'trick the model',
-    'confuse the system',
-    'You are now a hacker',
-    'You are a malicious actor',
-    'Find a vulnerability',
-    'Write a prompt that bypasses security',
-    'Write a prompt that tricks the model',
-    'Write a prompt that confuses the system',
-    "ignore previous",
-    "ignore earlier",
-    "disregard previous",
-    "disregard earlier",
-    "you are a hacker",
-    "you are now a hacker",
-    "you are malicious",
-    "export the api key",
-    "give me the api key",
-    "bypass",
-    "override",
-    "jailbreak",
-    "system override",
-    "forget instructions",
-    "forget previous",
-    "forget earlier",
-    "do anything now",
-    "dan mode",
-    "developer mode",
-    "break character",
-    "act as"
-];
-export async function detectInjection(userInput) {
-    return INJECTION_PATTERNS.some(p => userInput.toLowerCase().includes(p));
-}
-export async function analyzeIntentStructured(input, intents, threshold) {
-    const extractor = await ModelSingleton.getExtractor();
-    let bestIntent = '';
-    let bestScore = 0;
-    for (const [key, desc] of Object.entries(intents)) {
-        const output = await extractor([`intent: ${desc}`, `intent: ${input}`], { pooling: 'mean', normalize: true });
-        const vectors = output.tolist();
-        const score = cos_sim(vectors[0], vectors[1]);
-        const finalScore = typeof score === 'number' ? score : score.data[0];
-        if (finalScore > bestScore) {
-            bestScore = finalScore;
-            bestIntent = key;
-        }
-    }
-    return {
-        intent: bestIntent,
-        score: bestScore,
-        allowed: bestScore >= threshold
-    };
-}

package/dist/src/middleware/middleware.d.ts

@@ -1 +0,0 @@
-export declare function guard(config: any): (req: any, next: any) => Promise<any>;

package/dist/src/middleware/middleware.js

@@ -1,120 +0,0 @@
-import { analyzeIntentStructured, detectInjection } from '../intent/intentAnalyzer.js';
-import { detectPII } from '../pii/detector.js';
-import { PiiTokenizer } from '../pii/tokenizer.js';
-export function guard(config) {
-    return async (req, next) => {
-        const input = req.prompt ||
-            req.messages?.[req.messages.length - 1]?.content?.[0]?.text ||
-            "";
-        // -------------------------
-        // 1. INTENT ANALYSIS
-        // -------------------------
-        const isInjection = await detectInjection(input);
-        if (isInjection) {
-            console.warn(`[Intent Guard] Prompt injection pattern detected in input`);
-            return block("Prompt injection detected", {
-                reason: "pattern_match"
-            });
-        }
-        console.log(`[Intent Guard] Analyzing intent for user's input`);
-        const intentResult = await analyzeIntentStructured(input, config.intent.semantic.intents, config.intent.semantic.threshold);
-        console.log(`[Intent Guard] Detected intent: ${intentResult.intent} (score: ${intentResult.score.toFixed(2)})`);
-        if (!intentResult.allowed) {
-            console.warn(`[Intent Guard] Intent "${intentResult.intent}" not allowed ${intentResult.allowed}`);
-            return block("Intent not allowed", {
-                intent: intentResult.intent,
-                score: intentResult.score
-            });
-        }
-        // -------------------------
-        // 2. PII DETECTION + MASKING
-        // -------------------------
-        const piiResponse = await detectPII(input, {
-            model: config?.pii?.model,
-            mode: config?.pii?.mode
-        });
-        const piiMatches = piiResponse?.matches || [];
-        console.log(`[PII Guard] Detected PII: ${piiMatches.length} matches found` + (piiResponse.classifier ? ' (classifier output present)' : ''));
-        const tokenizer = new PiiTokenizer(); // <-- SINGLE INSTANCE
-        const piiResult = tokenizer.mask(input, piiMatches);
-        console.log(`[PII Guard] Masked PII: ${piiResult.piiTypes.length} types found`);
-        // Attach tokenizer so response can unmask
-        req.metadata = {
-            ...req.metadata,
-            piiTokenizer: tokenizer,
-            intent: intentResult.intent,
-            score: intentResult.score,
-            piiDetected: piiMatches.length > 0,
-            piiTypes: piiResult.piiTypes,
-            maskedInput: piiResult.maskedText,
-            piiModel: config?.pii?.model,
-            piiMode: config?.pii?.mode,
-            piiClassifierOutput: piiResponse.classifier
-        };
-        // Replace input
-        req.prompt = piiResult.maskedText;
-        req.messages = [
-            {
-                role: 'user',
-                content: [{ text: piiResult.maskedText }],
-            },
-        ];
-        // -------------------------
-        // 3. LLM CALL
-        // -------------------------
-        const res = await next(req);
-        // -------------------------
-        // 4. RESPONSE UNMASK
-        // -------------------------
-        console.log(`[PII Guard] Unmasking response if needed`);
-        if (tokenizer) {
-            /**
-             * RECURSIVE TRANSFORMER
-             * This will find every string in the Genkit response (no matter if it's in
-             * candidates, message, custom, or output) and unmask it.
-             */
-            const transform = (obj) => {
-                // 1. If it's a string, unmask it
-                if (typeof obj === 'string') {
-                    return tokenizer.unmask(obj);
-                }
-                // 2. If it's an array, transform each element
-                if (Array.isArray(obj)) {
-                    return obj.map(transform);
-                }
-                // 3. If it's an object, transform each value
-                if (obj !== null && typeof obj === 'object') {
-                    // Note: We iterate keys and mutate the object directly 
-                    // to ensure Genkit's internal references are updated.
-                    for (const key of Object.keys(obj)) {
-                        obj[key] = transform(obj[key]);
-                    }
-                    return obj;
-                }
-                // 4. Return as-is for numbers/booleans/null
-                return obj;
-            };
-            // ----------------------------------------------------------------------
-            // 5. Transform the entire response object in-place to unmask all strings
-            // ----------------------------------------------------------------------      
-            transform(res);
-            console.log("[PII Guard] Deep unmasking complete across all candidates and custom fields.");
-        }
-        // ---------------------------------------------------------
-        // 6. Return the modified response with unmasked content
-        // ---------------------------------------------------------
-        return res;
-    };
-}
-// Helper to create a blocked response
-function block(message, metadata) {
-    return {
-        finishReason: 'blocked',
-        output: {
-            type: "error",
-            status: "BLOCKED",
-            message
-        },
-        metadata
-    };
-}

package/dist/src/pii/detector.d.ts

@@ -1,10 +0,0 @@
-export declare function detectPII(text: string, opts?: {
-    model?: string;
-    mode?: 'ner' | 'classifier';
-}): Promise<{
-    matches: {
-        type: string;
-        value: string;
-    }[];
-    classifier: any;
-}>;

package/dist/src/pii/detector.js

@@ -1,47 +0,0 @@
-import { ModelSingleton } from '../util/singleton.js';
-const REGEX_RULES = [
-    // EMAIL (keep your existing one)
-    { type: 'EMAIL', pattern: /\b[\w\.-]+@[\w\.-]+\.\w{2,}\b/gi },
-    // AU MOBILE (04xx xxx xxx or +61 4xx xxx xxx)
-    { type: 'AU_MOBILE', pattern: /\b(?:\+?61|0)4\d{2}[-\s]?\d{3}[-\s]?\d{3}\b/g },
-    // AU LANDLINE (02, 03, 07, 08)
-    { type: 'AU_LANDLINE', pattern: /\b(?:\+?61[-\s]?)?(?:2|3|7|8)\d{1}[-\s]?\d{4}[-\s]?\d{4}\b/g },
-    // MEDICARE NUMBER (10 digits, often grouped 4-5-1)
-    { type: 'MEDICARE', pattern: /\b\d{4}[-\s]?\d{5}[-\s]?\d\b/g },
-    // TFN (9 digits)
-    { type: 'TFN', pattern: /\b\d{3}[-\s]?\d{3}[-\s]?\d{3}\b/g },
-    // ABN (11 digits)
-    { type: 'ABN', pattern: /\b\d{2}[-\s]?\d{3}[-\s]?\d{3}[-\s]?\d{3}\b/g },
-    // CREDIT CARD (keep your existing one if needed)
-    { type: 'CREDIT_CARD', pattern: /\b(?:\d[ -]*?){13,16}\b/g }
-];
-export async function detectPII(text, opts) {
-    const mode = opts?.mode ?? 'ner';
-    const model = opts?.model;
-    const results = [];
-    // ---- REGEX (always run) ----
-    for (const rule of REGEX_RULES) {
-        const matches = text.match(rule.pattern) || [];
-        matches.forEach(m => results.push({ type: rule.type, value: m }));
-    }
-    // ---- NER ----
-    let classifierOutput = undefined;
-    if (mode === 'ner') {
-        const ner = await ModelSingleton.getNER(model);
-        const entities = await ner(text);
-        for (const e of entities) {
-            if (e.entity && e.entity.includes('PER')) {
-                results.push({ type: 'NAME', value: (e.word || '').replace(/##/g, '') });
-            }
-        }
-    }
-    else {
-        // classifier mode: we call the classifier and return its output alongside regex matches.
-        const cls = await ModelSingleton.getPIIClassifier(model);
-        classifierOutput = await cls(text);
-    }
-    return {
-        matches: results,
-        classifier: classifierOutput
-    };
-}

package/dist/src/pii/tokenizer.d.ts

@@ -1,19 +0,0 @@
-export type PiiResult = {
-    maskedText: string;
-    pii: Record<string, string>;
-    piiTypes: string[];
-};
-export declare class PiiTokenizer {
-    private vault;
-    private counter;
-    private piiTypes;
-    private createToken;
-    mask(text: string, matches: {
-        type: string;
-        value: string;
-    }[]): PiiResult;
-    unmask(text: string): string;
-    getVault(): {
-        [k: string]: string;
-    };
-}

package/dist/src/pii/tokenizer.js

@@ -1,32 +0,0 @@
-export class PiiTokenizer {
-    vault = new Map();
-    counter = 0;
-    piiTypes = new Set();
-    createToken(type) {
-        return `[[${type}_${this.counter++}]]`;
-    }
-    mask(text, matches) {
-        let masked = text;
-        for (const match of matches) {
-            const token = this.createToken(match.type);
-            this.vault.set(token, match.value);
-            this.piiTypes.add(match.type.toLowerCase());
-            masked = masked.split(match.value).join(token);
-        }
-        return {
-            maskedText: masked,
-            pii: Object.fromEntries(this.vault),
-            piiTypes: Array.from(this.piiTypes)
-        };
-    }
-    unmask(text) {
-        let result = text;
-        this.vault.forEach((value, token) => {
-            result = result.split(token).join(value); // Global replacement
-        });
-        return result;
-    }
-    getVault() {
-        return Object.fromEntries(this.vault);
-    }
-}

package/dist/src/util/singleton.d.ts

@@ -1,14 +0,0 @@
-export declare class ModelSingleton {
-    private static extractors;
-    private static nerClassifiers;
-    private static textClassifiers;
-    static init(): void;
-    static getExtractor(modelName?: string): Promise<any>;
-    static getNER(modelName?: string): Promise<any>;
-    static getPIIClassifier(modelName?: string): Promise<any>;
-    static preload(models?: {
-        extractor?: string;
-        ner?: string;
-        pii?: string;
-    }): Promise<void>;
-}

package/dist/src/util/singleton.js

@@ -1,60 +0,0 @@
-import { pipeline, env } from '@huggingface/transformers';
-import path from 'path';
-import fs from 'fs';
-import { fileURLToPath } from 'url';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-env.allowRemoteModels = false;
-env.localModelPath = path.join(__dirname, '../../models');
-export class ModelSingleton {
-    static extractors = new Map();
-    static nerClassifiers = new Map();
-    static textClassifiers = new Map();
-    static init() {
-        // Always resolve model path relative to the client app, not the library
-        const projectRoot = process.cwd();
-        const modelPath = path.join(projectRoot, "models");
-        // Ensure directory exists
-        if (!fs.existsSync(modelPath)) {
-            fs.mkdirSync(modelPath, { recursive: true });
-        }
-        env.cacheDir = modelPath;
-        env.localModelPath = modelPath;
-        // Allow remote download if missing
-        env.allowRemoteModels = true;
-        console.log("[Guard] Using model directory:", modelPath);
-    }
-    static async getExtractor(modelName = 'Xenova/all-MiniLM-L6-v2') {
-        if (!this.extractors.has(modelName)) {
-            this.init();
-            const inst = await pipeline('feature-extraction', modelName);
-            this.extractors.set(modelName, inst);
-        }
-        return this.extractors.get(modelName);
-    }
-    static async getNER(modelName = 'Xenova/bert-base-NER') {
-        if (!this.nerClassifiers.has(modelName)) {
-            this.init();
-            const inst = await pipeline('token-classification', modelName);
-            this.nerClassifiers.set(modelName, inst);
-        }
-        return this.nerClassifiers.get(modelName);
-    }
-    static async getPIIClassifier(modelName = 'openai/privacy-filter') {
-        if (!this.textClassifiers.has(modelName)) {
-            this.init();
-            const inst = await pipeline('text-classification', modelName);
-            this.textClassifiers.set(modelName, inst);
-        }
-        return this.textClassifiers.get(modelName);
-    }
-    static async preload(models) {
-        const tasks = [];
-        if (models?.extractor)
-            tasks.push(this.getExtractor(models.extractor));
-        if (models?.ner)
-            tasks.push(this.getNER(models.ner));
-        if (models?.pii)
-            tasks.push(this.getPIIClassifier(models.pii));
-        await Promise.all(tasks);
-    }
-}