@intflows/genkit-guard 0.0.14 → 0.1.0

package/dist/middleware/middleware.d.ts

@@ -1,3 +1,4 @@
+import type { GuardDecisionStore } from '../core/decision-storage.js';
 import { type GuardDecision, type ToolGuardConfig } from '../core/decision.js';
 import { type PiiLabelMappings } from '../guard.config.js';
 import { z } from 'genkit';
@@ -17,6 +18,11 @@ export type GuardConfig = {
         reversible?: boolean;
         model?: string;
         mode?: 'ner' | 'classifier';
+        fallback?: {
+            model: string;
+            mode?: 'ner' | 'classifier';
+            labelMappings?: PiiLabelMappings;
+        };
         labelMappings?: PiiLabelMappings;
         vault?: {
             storage?: PiiVaultStorage;
@@ -29,9 +35,12 @@ export type GuardConfig = {
         serviceName?: string;
         /** Awaited audit callback, independent of console logging level/enabled. Failure stops execution. */
         onDecision?: (decision: GuardDecision) => void | Promise<void>;
+        /** Durable audit delivery. Failure stops execution; called before onDecision. */
+        store?: GuardDecisionStore;
     };
     models?: {
         extractor?: string;
+        extractorFallback?: string;
     };
     [key: string]: any;
 };
@@ -83,6 +92,19 @@ export declare const guardMiddleware: import("genkit").GenerateMiddleware<z.ZodO
         reversible: z.ZodOptional<z.ZodBoolean>;
         model: z.ZodOptional<z.ZodString>;
         mode: z.ZodOptional<z.ZodEnum<["ner", "classifier"]>>;
+        fallback: z.ZodOptional<z.ZodObject<{
+            model: z.ZodString;
+            mode: z.ZodOptional<z.ZodEnum<["ner", "classifier"]>>;
+            labelMappings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
+        }, "strip", z.ZodTypeAny, {
+            model: string;
+            mode?: "ner" | "classifier" | undefined;
+            labelMappings?: Record<string, string | null> | undefined;
+        }, {
+            model: string;
+            mode?: "ner" | "classifier" | undefined;
+            labelMappings?: Record<string, string | null> | undefined;
+        }>>;
         labelMappings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
         vault: z.ZodOptional<z.ZodObject<{
             storage: z.ZodOptional<z.ZodAny>;
@@ -96,18 +118,28 @@ export declare const guardMiddleware: import("genkit").GenerateMiddleware<z.ZodO
         }>>;
     }, "strip", z.ZodTypeAny, {
         model?: string | undefined;
-        labelMappings?: Record<string, string | null> | undefined;
+        fallback?: {
+            model: string;
+            mode?: "ner" | "classifier" | undefined;
+            labelMappings?: Record<string, string | null> | undefined;
+        } | undefined;
         mode?: "ner" | "classifier" | undefined;
         reversible?: boolean | undefined;
+        labelMappings?: Record<string, string | null> | undefined;
         vault?: {
             storage?: any;
             scopeId?: any;
         } | undefined;
     }, {
         model?: string | undefined;
-        labelMappings?: Record<string, string | null> | undefined;
+        fallback?: {
+            model: string;
+            mode?: "ner" | "classifier" | undefined;
+            labelMappings?: Record<string, string | null> | undefined;
+        } | undefined;
         mode?: "ner" | "classifier" | undefined;
         reversible?: boolean | undefined;
+        labelMappings?: Record<string, string | null> | undefined;
         vault?: {
             storage?: any;
             scopeId?: any;
@@ -118,23 +150,29 @@ export declare const guardMiddleware: import("genkit").GenerateMiddleware<z.ZodO
         level: z.ZodOptional<z.ZodEnum<["debug", "info", "warn", "error"]>>;
         serviceName: z.ZodOptional<z.ZodString>;
         onDecision: z.ZodOptional<z.ZodAny>;
+        store: z.ZodOptional<z.ZodAny>;
     }, "strip", z.ZodTypeAny, {
         enabled?: boolean | undefined;
         level?: "debug" | "info" | "warn" | "error" | undefined;
         serviceName?: string | undefined;
         onDecision?: any;
+        store?: any;
     }, {
         enabled?: boolean | undefined;
         level?: "debug" | "info" | "warn" | "error" | undefined;
         serviceName?: string | undefined;
         onDecision?: any;
+        store?: any;
     }>>;
     models: z.ZodOptional<z.ZodObject<{
         extractor: z.ZodOptional<z.ZodString>;
+        extractorFallback: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         extractor?: string | undefined;
+        extractorFallback?: string | undefined;
     }, {
         extractor?: string | undefined;
+        extractorFallback?: string | undefined;
     }>>;
 }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
     policyVersion: z.ZodOptional<z.ZodString>;
@@ -183,6 +221,19 @@ export declare const guardMiddleware: import("genkit").GenerateMiddleware<z.ZodO
         reversible: z.ZodOptional<z.ZodBoolean>;
         model: z.ZodOptional<z.ZodString>;
         mode: z.ZodOptional<z.ZodEnum<["ner", "classifier"]>>;
+        fallback: z.ZodOptional<z.ZodObject<{
+            model: z.ZodString;
+            mode: z.ZodOptional<z.ZodEnum<["ner", "classifier"]>>;
+            labelMappings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
+        }, "strip", z.ZodTypeAny, {
+            model: string;
+            mode?: "ner" | "classifier" | undefined;
+            labelMappings?: Record<string, string | null> | undefined;
+        }, {
+            model: string;
+            mode?: "ner" | "classifier" | undefined;
+            labelMappings?: Record<string, string | null> | undefined;
+        }>>;
         labelMappings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
         vault: z.ZodOptional<z.ZodObject<{
             storage: z.ZodOptional<z.ZodAny>;
@@ -196,18 +247,28 @@ export declare const guardMiddleware: import("genkit").GenerateMiddleware<z.ZodO
         }>>;
     }, "strip", z.ZodTypeAny, {
         model?: string | undefined;
-        labelMappings?: Record<string, string | null> | undefined;
+        fallback?: {
+            model: string;
+            mode?: "ner" | "classifier" | undefined;
+            labelMappings?: Record<string, string | null> | undefined;
+        } | undefined;
         mode?: "ner" | "classifier" | undefined;
         reversible?: boolean | undefined;
+        labelMappings?: Record<string, string | null> | undefined;
         vault?: {
             storage?: any;
             scopeId?: any;
         } | undefined;
     }, {
         model?: string | undefined;
-        labelMappings?: Record<string, string | null> | undefined;
+        fallback?: {
+            model: string;
+            mode?: "ner" | "classifier" | undefined;
+            labelMappings?: Record<string, string | null> | undefined;
+        } | undefined;
         mode?: "ner" | "classifier" | undefined;
         reversible?: boolean | undefined;
+        labelMappings?: Record<string, string | null> | undefined;
         vault?: {
             storage?: any;
             scopeId?: any;
@@ -218,23 +279,29 @@ export declare const guardMiddleware: import("genkit").GenerateMiddleware<z.ZodO
         level: z.ZodOptional<z.ZodEnum<["debug", "info", "warn", "error"]>>;
         serviceName: z.ZodOptional<z.ZodString>;
         onDecision: z.ZodOptional<z.ZodAny>;
+        store: z.ZodOptional<z.ZodAny>;
     }, "strip", z.ZodTypeAny, {
         enabled?: boolean | undefined;
         level?: "debug" | "info" | "warn" | "error" | undefined;
         serviceName?: string | undefined;
         onDecision?: any;
+        store?: any;
     }, {
         enabled?: boolean | undefined;
         level?: "debug" | "info" | "warn" | "error" | undefined;
         serviceName?: string | undefined;
         onDecision?: any;
+        store?: any;
     }>>;
     models: z.ZodOptional<z.ZodObject<{
         extractor: z.ZodOptional<z.ZodString>;
+        extractorFallback: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         extractor?: string | undefined;
+        extractorFallback?: string | undefined;
     }, {
         extractor?: string | undefined;
+        extractorFallback?: string | undefined;
     }>>;
 }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
     policyVersion: z.ZodOptional<z.ZodString>;
@@ -283,6 +350,19 @@ export declare const guardMiddleware: import("genkit").GenerateMiddleware<z.ZodO
         reversible: z.ZodOptional<z.ZodBoolean>;
         model: z.ZodOptional<z.ZodString>;
         mode: z.ZodOptional<z.ZodEnum<["ner", "classifier"]>>;
+        fallback: z.ZodOptional<z.ZodObject<{
+            model: z.ZodString;
+            mode: z.ZodOptional<z.ZodEnum<["ner", "classifier"]>>;
+            labelMappings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
+        }, "strip", z.ZodTypeAny, {
+            model: string;
+            mode?: "ner" | "classifier" | undefined;
+            labelMappings?: Record<string, string | null> | undefined;
+        }, {
+            model: string;
+            mode?: "ner" | "classifier" | undefined;
+            labelMappings?: Record<string, string | null> | undefined;
+        }>>;
         labelMappings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
         vault: z.ZodOptional<z.ZodObject<{
             storage: z.ZodOptional<z.ZodAny>;
@@ -296,18 +376,28 @@ export declare const guardMiddleware: import("genkit").GenerateMiddleware<z.ZodO
         }>>;
     }, "strip", z.ZodTypeAny, {
         model?: string | undefined;
-        labelMappings?: Record<string, string | null> | undefined;
+        fallback?: {
+            model: string;
+            mode?: "ner" | "classifier" | undefined;
+            labelMappings?: Record<string, string | null> | undefined;
+        } | undefined;
         mode?: "ner" | "classifier" | undefined;
         reversible?: boolean | undefined;
+        labelMappings?: Record<string, string | null> | undefined;
         vault?: {
             storage?: any;
             scopeId?: any;
         } | undefined;
     }, {
         model?: string | undefined;
-        labelMappings?: Record<string, string | null> | undefined;
+        fallback?: {
+            model: string;
+            mode?: "ner" | "classifier" | undefined;
+            labelMappings?: Record<string, string | null> | undefined;
+        } | undefined;
         mode?: "ner" | "classifier" | undefined;
         reversible?: boolean | undefined;
+        labelMappings?: Record<string, string | null> | undefined;
         vault?: {
             storage?: any;
             scopeId?: any;
@@ -318,23 +408,29 @@ export declare const guardMiddleware: import("genkit").GenerateMiddleware<z.ZodO
         level: z.ZodOptional<z.ZodEnum<["debug", "info", "warn", "error"]>>;
         serviceName: z.ZodOptional<z.ZodString>;
         onDecision: z.ZodOptional<z.ZodAny>;
+        store: z.ZodOptional<z.ZodAny>;
     }, "strip", z.ZodTypeAny, {
         enabled?: boolean | undefined;
         level?: "debug" | "info" | "warn" | "error" | undefined;
         serviceName?: string | undefined;
         onDecision?: any;
+        store?: any;
     }, {
         enabled?: boolean | undefined;
         level?: "debug" | "info" | "warn" | "error" | undefined;
         serviceName?: string | undefined;
         onDecision?: any;
+        store?: any;
     }>>;
     models: z.ZodOptional<z.ZodObject<{
         extractor: z.ZodOptional<z.ZodString>;
+        extractorFallback: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         extractor?: string | undefined;
+        extractorFallback?: string | undefined;
     }, {
         extractor?: string | undefined;
+        extractorFallback?: string | undefined;
     }>>;
 }, z.ZodTypeAny, "passthrough">>, void>;
 export declare const guardPlugin: (pluginOptions: void) => import("@genkit-ai/ai").GenkitPluginV2;

package/dist/middleware/middleware.js

@@ -1,4 +1,5 @@
-import { randomUUID } from 'node:crypto';
+import { publishDecision } from '../core/audit.js';
+import { runGuardModel } from '../util/fallback.js';
 import { GuardToolError } from '../core/decision.js';
 import { resolveGuardModels } from '../guard.config.js';
 import { generateMiddleware, z } from 'genkit';
@@ -27,6 +28,10 @@ const guardConfigSchema = z.object({
         reversible: z.boolean().optional(),
         model: z.string().optional(),
         mode: z.enum(['ner', 'classifier']).optional(),
+        fallback: z.object({
+            model: z.string(), mode: z.enum(['ner', 'classifier']).optional(),
+            labelMappings: z.record(z.string(), z.string().regex(/^[A-Z_]+$/).nullable()).optional(),
+        }).optional(),
         labelMappings: z.record(z.string(), z.string().regex(/^[A-Z_]+$/).nullable()).optional(),
         vault: z.object({
             storage: z.any().optional(),
@@ -38,9 +43,11 @@ const guardConfigSchema = z.object({
         level: z.enum(['debug', 'info', 'warn', 'error']).optional(),
         serviceName: z.string().optional(),
         onDecision: z.any().optional(),
+        store: z.any().optional(),
     }).optional(),
     models: z.object({
         extractor: z.string().optional(),
+        extractorFallback: z.string().optional(),
     }).optional(),
 }).passthrough();
 export const guardMiddleware = generateMiddleware({
@@ -79,16 +86,7 @@ export const guardAction = guard;
 function createGuardHooks(config) {
     const logger = createLogger(config);
     const models = resolveGuardModels(config);
-    const decide = async (start, fields) => {
-        const decision = Object.freeze({
-            schemaVersion: '1', decisionId: randomUUID(), timestamp: new Date().toISOString(),
-            policyVersion: config?.policyVersion ?? 'unversioned',
-            latencyMs: Math.max(0, performance.now() - start), ...fields,
-        });
-        logger(decision.action === 'block' || decision.action === 'approval-required' ? 'warn' : 'info', 'guard.decision', 'Guard policy decision', { decision });
-        await config?.logging?.onDecision?.(decision);
-        return decision;
-    };
+    const decide = (start, fields) => publishDecision(config, start, fields);
     return {
         model: async (req, ctx, next) => {
             const started = performance.now();
@@ -107,7 +105,8 @@ function createGuardHooks(config) {
             await decide(started, { guard: 'injection', action: 'allow', reasonCode: 'INJECTION_CLEAR' });
             const intentStarted = performance.now();
             logger('info', 'guard.intent.analysis.start', 'Analyzing request intent');
-            const intentResult = await analyzeIntentStructured(input, config?.intent?.semantic?.intents ?? {}, config?.intent?.semantic?.threshold ?? 0.7, models.extractor);
+            const analyze = (model) => analyzeIntentStructured(input, config?.intent?.semantic?.intents ?? {}, config?.intent?.semantic?.threshold ?? 0.7, model);
+            const intentResult = await runGuardModel(config, 'intent', () => analyze(models.extractor), config?.models?.extractorFallback ? () => analyze(config.models.extractorFallback) : undefined);
             logger('info', 'guard.intent.analysis.complete', 'Intent analysis completed', {
                 intent: intentResult.intent,
                 score: roundScore(intentResult.score),
@@ -143,7 +142,7 @@ function createGuardHooks(config) {
                 piiDetected: piiMatches.length > 0,
                 piiMatchCount: piiMatches.length,
                 piiTypes,
-                piiMode: config?.pii?.mode ?? 'ner',
+                piiMode: piiResponse.effectiveMode ?? models.mode,
                 classifierOutputPresent: Boolean(piiResponse.classifier),
             });
             req.metadata = {
@@ -156,6 +155,9 @@ function createGuardHooks(config) {
                 piiModel: config?.pii?.model,
                 piiMode: config?.pii?.mode,
                 piiClassifierOutput: piiResponse.classifier,
+                piiEffectiveModel: piiResponse.effectiveModel,
+                piiEffectiveMode: piiResponse.effectiveMode,
+                piiUsedFallback: piiResponse.usedFallback,
             };
             const res = await next(req, ctx);
             const unmaskedResponse = await unmaskObject(res, getGuardState(ctx).tokenizers);
@@ -212,6 +214,9 @@ function createGuardHooks(config) {
                 piiDetected: piiMatches.length > 0,
                 piiTypes,
                 piiMatchCount: piiMatches.length,
+                piiEffectiveModel: piiResponse.effectiveModel,
+                piiEffectiveMode: piiResponse.effectiveMode,
+                piiUsedFallback: piiResponse.usedFallback,
             };
             logger(piiMatches.length > 0 ? 'warn' : 'info', 'guard.tool.pii.checked', 'Tool request PII scan completed', {
                 toolName,
@@ -326,6 +331,9 @@ async function scanPII(text, config) {
         return {
             matches: [],
             classifier: undefined,
+            effectiveModel: undefined,
+            effectiveMode: undefined,
+            usedFallback: false,
         };
     }
     const models = resolveGuardModels(config);
@@ -333,7 +341,8 @@ async function scanPII(text, config) {
         model: models.pii,
         mode: models.mode,
         labelMappings: config?.pii?.labelMappings,
-    });
+        fallback: config?.pii?.fallback,
+    }, config);
 }
 function getGuardState(ctx = {}) {
     ctx.context = ctx.context || {};

package/dist/pii/detector.d.ts

@@ -1,3 +1,4 @@
+import type { GuardConfig } from '../middleware/middleware.js';
 import type { PiiLabelMappings } from '../guard.config.js';
 export type PiiMatch = {
     type: string;
@@ -11,12 +12,11 @@ export type PrivacyFilterSpan = {
     end?: number;
     score?: number;
 };
-export declare function detectPII(text: string, opts?: {
-    model?: string;
-    mode?: 'ner' | 'classifier';
-    labelMappings?: PiiLabelMappings;
-}): Promise<{
+export declare function detectPII(text: string, opts?: GuardConfig['pii'], config?: GuardConfig): Promise<{
     matches: PiiMatch[];
     classifier: any;
+    effectiveModel: string;
+    effectiveMode: "ner" | "classifier";
+    usedFallback: boolean;
 }>;
 export declare function privacyFilterOutputToMatches(text: string, output: unknown, labelMappings?: PiiLabelMappings): PiiMatch[];

package/dist/pii/detector.js

@@ -1,3 +1,4 @@
+import { runGuardModel } from '../util/fallback.js';
 import { ModelSingleton } from '../util/singleton.js';
 const PRIVACY_FILTER_TYPE_MAP = {
     account_number: 'ACCOUNT_NUMBER',
@@ -25,7 +26,7 @@ const REGEX_RULES = [
     // CREDIT CARD (keep your existing one if needed)
     { type: 'CREDIT_CARD', pattern: /\b(?:\d[ -]*?){13,16}\b/g }
 ];
-export async function detectPII(text, opts) {
+export async function detectPII(text, opts, config) {
     const mode = opts?.mode ?? 'ner';
     const model = opts?.model;
     const results = [];
@@ -34,16 +35,27 @@ export async function detectPII(text, opts) {
         const matches = text.match(rule.pattern) || [];
         matches.forEach(m => results.push({ type: rule.type, value: m }));
     }
-    // ---- NER ----
+    // Only model loading/inference is retried. Label mapping errors are not model failures.
+    const infer = async (selected, usedFallback = false) => {
+        const selectedMode = selected.mode ?? mode;
+        const pipeline = selectedMode === 'ner'
+            ? await ModelSingleton.getNER(selected.model)
+            : await ModelSingleton.getPIIClassifier(selected.model);
+        const output = selectedMode === 'ner' ? await pipeline(text)
+            : await pipeline(text, { aggregation_strategy: 'simple' });
+        if (!Array.isArray(output))
+            throw new Error('Invalid PII model output');
+        return { output, mode: selectedMode, labelMappings: selected.labelMappings, usedFallback,
+            model: selected.model ?? (selectedMode === 'ner' ? 'Xenova/bert-base-NER' : 'openai/privacy-filter') };
+    };
+    const selected = await runGuardModel(config, 'pii', () => infer({ model, mode, labelMappings: opts?.labelMappings }), opts?.fallback ? () => infer(opts.fallback, true) : undefined);
     let classifierOutput = undefined;
-    if (mode === 'ner') {
-        const ner = await ModelSingleton.getNER(model);
-        const entities = await ner(text);
-        for (const e of entities) {
-            const mappedType = mappedLabel(e.entity_group ?? e.entity, opts?.labelMappings);
+    if (selected.mode === 'ner') {
+        for (const e of selected.output) {
+            const mappedType = mappedLabel(e.entity_group ?? e.entity, selected.labelMappings);
             if (mappedType !== undefined) {
                 if (mappedType)
-                    results.push(...privacyFilterOutputToMatches(text, [e], opts?.labelMappings));
+                    results.push(...privacyFilterOutputToMatches(text, [e], selected.labelMappings));
             }
             else if (e.entity && e.entity.includes('PER')) {
                 results.push({ type: 'NAME', value: (e.word || '').replace(/##/g, '') });
@@ -51,19 +63,18 @@ export async function detectPII(text, opts) {
         }
     }
     else {
-        // Privacy Filter is a token-classification model. Aggregation produces complete spans
-        // rather than individual BIOES-labelled tokens.
-        const cls = await ModelSingleton.getPIIClassifier(model);
-        classifierOutput = await cls(text, { aggregation_strategy: 'simple' });
-        for (const match of privacyFilterOutputToMatches(text, classifierOutput, opts?.labelMappings)) {
-            if (!results.some((existing) => existing.value === match.value)) {
+        classifierOutput = selected.output;
+        for (const match of privacyFilterOutputToMatches(text, classifierOutput, selected.labelMappings)) {
+            if (!results.some((existing) => existing.value === match.value))
                 results.push(match);
-            }
         }
     }
     return {
         matches: results,
-        classifier: classifierOutput
+        classifier: classifierOutput,
+        effectiveModel: selected.model,
+        effectiveMode: selected.mode,
+        usedFallback: selected.usedFallback,
     };
 }
 export function privacyFilterOutputToMatches(text, output, labelMappings) {

package/dist/util/fallback.d.ts

@@ -0,0 +1,8 @@
+import type { GuardConfig } from '../middleware/middleware.js';
+export declare class GuardModelError extends Error {
+    readonly guard: 'intent' | 'pii';
+    readonly code = "MODEL_UNAVAILABLE";
+    constructor(guard: 'intent' | 'pii');
+}
+/** One fallback attempt per operation, only after a model operation throws. */
+export declare function runGuardModel<T>(config: GuardConfig | undefined, guard: 'intent' | 'pii', primary: () => Promise<T>, fallback?: () => Promise<T>): Promise<T>;

package/dist/util/fallback.js

@@ -0,0 +1,32 @@
+import { publishDecision } from '../core/audit.js';
+export class GuardModelError extends Error {
+    guard;
+    code = 'MODEL_UNAVAILABLE';
+    constructor(guard) {
+        // Do not attach underlying errors: inference errors can contain request content.
+        super(`Primary and fallback ${guard} models failed`);
+        this.guard = guard;
+        this.name = 'GuardModelError';
+    }
+}
+/** One fallback attempt per operation, only after a model operation throws. */
+export async function runGuardModel(config, guard, primary, fallback) {
+    const start = performance.now();
+    try {
+        return await primary();
+    }
+    catch (error) {
+        if (!fallback)
+            throw error; // Preserve existing failure behavior without opt-in.
+    }
+    let result;
+    try {
+        result = await fallback();
+    }
+    catch {
+        await publishDecision(config, start, { guard, action: 'block', reasonCode: 'MODEL_UNAVAILABLE' });
+        throw new GuardModelError(guard);
+    }
+    await publishDecision(config, start, { guard, action: 'allow', reasonCode: 'MODEL_FALLBACK_USED' });
+    return result;
+}

package/package.json

@@ -22,7 +22,7 @@
     "huggingface"
   ],
   "license": "Apache-2.0",
-  "version": "0.0.14",
+  "version": "0.1.0",
   "type": "module",
   "exports": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -36,7 +36,7 @@
     "prepare-models": "node scripts/download-model.js",
     "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
     "build": "npm run clean && tsc",
-    "test": "npm run test:types && npm run test:privacy-filter && npm run test:storage && npm run test:concurrency && npm run test:config && npm run test:release1",
+    "test": "npm run test:types && npm run test:privacy-filter && npm run test:storage && npm run test:concurrency && npm run test:config && npm run test:release1 && npm run test:release2",
     "test:types": "tsc --noEmit --ignoreConfig --module NodeNext --moduleResolution NodeNext --target ESNext --strict --skipLibCheck scripts/test-types.ts",
     "test:privacy-filter": "npm run build && node scripts/test-privacy-filter.js",
     "test:storage": "npm run build && node scripts/test-storage.js",
@@ -45,7 +45,8 @@
     "prepublishOnly": "npm run build",
     "test:config": "npm run build && node scripts/test-config.js",
     "wiki:publish": "node scripts/publish-wiki.js",
-    "test:release1": "npm run build && node --test scripts/test-release1.js scripts/test-publish-wiki.js"
+    "test:release1": "npm run build && node --test scripts/test-release1.js scripts/test-publish-wiki.js",
+    "test:release2": "npm run build && node --test scripts/test-release2.js"
   },
   "dependencies": {
     "@huggingface/transformers": "^4.2.0",

package/scripts/publish-wiki.js

@@ -7,7 +7,7 @@ import { fileURLToPath } from 'node:url';
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const args = process.argv.slice(2);
-let source = join(root, 'docs/wiki-v0.0.14');
+let source = join(root, 'docs/wiki-v0.1.0');
 let repository = 'https://github.com/IntFlows/genkit-guard.wiki.git';
 let publish = false;
 for (let i = 0; i < args.length; i++) {