glirastes 0.3.2 → 0.5.0

package/dist/cjs/server/core/zod-compact.js

@@ -11,7 +11,7 @@ exports.zodToCompactDescription = zodToCompactDescription;
  * zodToCompactDescription(z.object({
  *   tasks: z.array(z.object({ id: z.string(), title: z.string() })),
  *   total: z.number(),
- * }))
+ * }), 5)
  * // → '{ tasks: Array<{ id: string, title: string }>, total: number }'
  *
  * @param schema - Any Zod schema
@@ -20,45 +20,92 @@ exports.zodToCompactDescription = zodToCompactDescription;
 function zodToCompactDescription(schema, maxDepth = 3) {
     return describeSchema(schema, 0, maxDepth);
 }
+const ZOD_3_TYPES = {
+    ZodAny: 'any',
+    ZodArray: 'array',
+    ZodBigInt: 'bigint',
+    ZodBoolean: 'boolean',
+    ZodCatch: 'catch',
+    ZodDate: 'date',
+    ZodDefault: 'default',
+    ZodDiscriminatedUnion: 'union',
+    ZodEffects: 'effects',
+    ZodEnum: 'enum',
+    ZodLazy: 'lazy',
+    ZodLiteral: 'literal',
+    ZodNativeEnum: 'enum',
+    ZodNullable: 'nullable',
+    ZodNull: 'null',
+    ZodNumber: 'number',
+    ZodObject: 'object',
+    ZodOptional: 'optional',
+    ZodPipeline: 'pipe',
+    ZodReadonly: 'readonly',
+    ZodRecord: 'record',
+    ZodString: 'string',
+    ZodTuple: 'tuple',
+    ZodUndefined: 'undefined',
+    ZodUnion: 'union',
+    ZodUnknown: 'unknown',
+    ZodVoid: 'void',
+};
+/** Read and normalize Zod v3/v4 internal schema definitions. */
+function getDef(schema) {
+    const v4 = schema?._zod?.def;
+    if (v4)
+        return v4;
+    const v3 = schema?._def;
+    if (!v3)
+        return undefined;
+    return {
+        ...v3,
+        type: ZOD_3_TYPES[v3.typeName] ?? v3.typeName,
+        element: v3.type,
+        entries: v3.values
+            ? Object.fromEntries(v3.values.map((value) => [value, value]))
+            : v3.values,
+        in: v3.in ?? v3.schema,
+        valueType: v3.valueType,
+    };
+}
 function describeSchema(schema, depth, maxDepth) {
     if (depth >= maxDepth)
         return '...';
-    const def = schema._def;
-    const typeName = def?.typeName;
-    switch (typeName) {
-        case 'ZodString':
+    const def = getDef(schema);
+    const type = def?.type;
+    switch (type) {
+        case 'string':
             return 'string';
-        case 'ZodNumber':
+        case 'number':
+        case 'bigint':
             return 'number';
-        case 'ZodBoolean':
+        case 'boolean':
             return 'boolean';
-        case 'ZodDate':
+        case 'date':
             return 'string'; // Dates serialize as strings in JSON
-        case 'ZodLiteral':
-            return JSON.stringify(def.value);
-        case 'ZodNull':
+        case 'literal':
+            return (def.values ?? [def.value])
+                .map((v) => JSON.stringify(v))
+                .join(' | ');
+        case 'null':
             return 'null';
-        case 'ZodUndefined':
-            return 'undefined';
-        case 'ZodAny':
+        case 'undefined':
+        case 'void':
+            return type;
+        case 'any':
             return 'any';
-        case 'ZodUnknown':
+        case 'unknown':
             return 'unknown';
-        case 'ZodVoid':
-            return 'void';
-        case 'ZodEnum':
-            return def.values
-                .map((v) => `"${v}"`)
-                .join(' | ');
-        case 'ZodNativeEnum':
-            return Object.values(def.values)
-                .filter((v) => typeof v === 'string')
-                .map((v) => `"${v}"`)
-                .join(' | ');
-        case 'ZodArray':
-            return `Array<${describeSchema(def.type, depth + 1, maxDepth)}>`;
-        case 'ZodObject': {
-            const shape = def.shape();
+        case 'enum': {
+            // Zod v4 stores enum members in an `entries` record (covers both string
+            // enums and native enums). Emit the string values only.
+            const values = Object.values(def.entries).filter((v) => typeof v === 'string');
+            return values.map((v) => `"${v}"`).join(' | ');
+        }
+        case 'array':
+            return `Array<${describeSchema(def.element, depth + 1, maxDepth)}>`;
+        case 'object': {
+            const shape = (typeof def.shape === 'function' ? def.shape() : def.shape);
             const entries = Object.entries(shape);
             if (entries.length === 0)
                 return '{}';
@@ -71,59 +118,84 @@ function describeSchema(schema, depth, maxDepth) {
             });
             return `{ ${fields.join(', ')} }`;
         }
-        case 'ZodRecord':
+        case 'record':
             return `Record<string, ${describeSchema(def.valueType, depth + 1, maxDepth)}>`;
-        case 'ZodUnion':
-        case 'ZodDiscriminatedUnion': {
-            const options = def.options;
+        case 'union': {
+            const options = (def.options instanceof Map
+                ? [...def.options.values()]
+                : def.options);
             return options
                 .map((o) => describeSchema(o, depth + 1, maxDepth))
                 .join(' | ');
         }
-        case 'ZodTuple': {
+        case 'tuple': {
             const items = def.items;
             return `[${items.map((i) => describeSchema(i, depth + 1, maxDepth)).join(', ')}]`;
         }
-        case 'ZodNullable':
+        case 'nullable':
             return `${describeSchema(def.innerType, depth, maxDepth)} | null`;
-        case 'ZodOptional':
-        case 'ZodDefault':
+        case 'optional':
+        case 'default':
+        case 'prefault':
+        case 'catch':
+        case 'readonly':
+        case 'nonoptional':
             return describeSchema(def.innerType, depth, maxDepth);
-        case 'ZodEffects':
+        case 'pipe':
+            // Transforms / refinements become pipes in Zod v4; describe the input
+            // side, matching the pre-v4 behaviour of describing the base schema.
+            return describeSchema(def.in, depth, maxDepth);
+        case 'effects':
             return describeSchema(def.schema, depth, maxDepth);
+        case 'lazy':
+            return describeSchema(def.getter(), depth, maxDepth);
         default:
             return 'unknown';
     }
 }
-/** Unwrap ZodOptional / ZodNullable / ZodDefault / ZodEffects to the inner schema. */
+/** Unwrap optional / nullable / default / pipe wrappers to the inner schema. */
 function unwrap(schema) {
-    const def = schema._def;
-    const typeName = def?.typeName;
-    if (typeName === 'ZodOptional' ||
-        typeName === 'ZodNullable' ||
-        typeName === 'ZodDefault') {
+    const def = getDef(schema);
+    const type = def?.type;
+    if (type === 'optional' ||
+        type === 'nullable' ||
+        type === 'default' ||
+        type === 'prefault' ||
+        type === 'catch' ||
+        type === 'readonly' ||
+        type === 'nonoptional') {
         return unwrap(def.innerType);
     }
-    if (typeName === 'ZodEffects') {
+    if (type === 'pipe') {
+        return unwrap(def.in);
+    }
+    if (type === 'effects') {
         return unwrap(def.schema);
     }
     return schema;
 }
 function isOptional(schema) {
-    const def = schema._def;
-    const typeName = def?.typeName;
-    if (typeName === 'ZodOptional' || typeName === 'ZodDefault')
+    const def = getDef(schema);
+    const type = def?.type;
+    if (type === 'optional' || type === 'default' || type === 'prefault') {
         return true;
-    if (typeName === 'ZodNullable')
+    }
+    if (type === 'nullable' || type === 'readonly' || type === 'catch') {
         return isOptional(def.innerType);
+    }
     return false;
 }
 function isNullable(schema) {
-    const def = schema._def;
-    const typeName = def?.typeName;
-    if (typeName === 'ZodNullable')
+    const def = getDef(schema);
+    const type = def?.type;
+    if (type === 'nullable')
         return true;
-    if (typeName === 'ZodOptional' || typeName === 'ZodDefault')
+    if (type === 'optional' ||
+        type === 'default' ||
+        type === 'prefault' ||
+        type === 'readonly' ||
+        type === 'catch') {
         return isNullable(def.innerType);
+    }
     return false;
 }

package/dist/cjs/server/index.d.ts

@@ -1,6 +1,4 @@
 export * from './core/index.js';
 export * from './pipeline.js';
-export * from './lancer/index.js';
-export { createPiiShield } from './pii-shield/index.js';
-export { createAegisDetector } from './pii-shield/index.js';
-export type { AegisLike } from './pii-shield/index.js';
+export { createLocalAiPipeline, type LocalAiPipelineConfig, } from './local-pipeline.js';
+export { createPiiShield, createRegexPiiDetector, } from './pii-shield/index.js';

package/dist/cjs/server/index.js

@@ -14,15 +14,14 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAegisDetector = exports.createPiiShield = void 0;
+exports.createRegexPiiDetector = exports.createPiiShield = exports.createLocalAiPipeline = void 0;
 // Server core (includes native telemetry forwarding via TelemetrySink interface)
 __exportStar(require("./core/index.js"), exports);
 // AI pipeline (multi-stage: guardrails → classify → route → model select)
 __exportStar(require("./pipeline.js"), exports);
-// Lancer (platform client) — createLancer, ServiceBlockedError, types
-__exportStar(require("./lancer/index.js"), exports);
+var local_pipeline_js_1 = require("./local-pipeline.js");
+Object.defineProperty(exports, "createLocalAiPipeline", { enumerable: true, get: function () { return local_pipeline_js_1.createLocalAiPipeline; } });
 // PII shield
 var index_js_1 = require("./pii-shield/index.js");
 Object.defineProperty(exports, "createPiiShield", { enumerable: true, get: function () { return index_js_1.createPiiShield; } });
-var index_js_2 = require("./pii-shield/index.js");
-Object.defineProperty(exports, "createAegisDetector", { enumerable: true, get: function () { return index_js_2.createAegisDetector; } });
+Object.defineProperty(exports, "createRegexPiiDetector", { enumerable: true, get: function () { return index_js_1.createRegexPiiDetector; } });

package/dist/cjs/server/local-pipeline.d.ts

@@ -0,0 +1,14 @@
+import type { AiPipeline, AiPipelineConfig, AiRouterConfig } from '../types.js';
+import { type LocalClassifierConfig } from './core/index.js';
+export interface LocalAiPipelineConfig extends AiPipelineConfig {
+    /** Focused by default; legacy keeps the historical full-catalogue fallback. */
+    routingMode?: AiRouterConfig['routingMode'];
+    /** AI SDK generateText or a compatible local model callback. */
+    generateText?: LocalClassifierConfig['generateText'];
+}
+/**
+ * Target-app pipeline for content-bearing guardrails, intent classification,
+ * routing, and model selection. No request or user content leaves the local
+ * runtime unless the configured local model provider itself receives it.
+ */
+export declare function createLocalAiPipeline(config: LocalAiPipelineConfig): AiPipeline;

package/dist/cjs/server/local-pipeline.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalAiPipeline = createLocalAiPipeline;
+const index_js_1 = require("./core/index.js");
+const local_guardrails_js_1 = require("./core/local-guardrails.js");
+const CONTINUATION_TTL_MS = 10 * 60 * 1000;
+const CONTINUATION_MAX_ENTRIES = 200;
+/** The request and the user messages before it; assistant text added by a continuation does not count. */
+function continuationKeyOf(input, conversationHistory) {
+    return JSON.stringify([
+        input,
+        (conversationHistory ?? []).filter((message) => message.role === 'user').map((message) => message.content),
+    ]);
+}
+/**
+ * Target-app pipeline for content-bearing guardrails, intent classification,
+ * routing, and model selection. No request or user content leaves the local
+ * runtime unless the configured local model provider itself receives it.
+ */
+function createLocalAiPipeline(config) {
+    const guardrails = (0, local_guardrails_js_1.createLocalGuardrails)(config.guardrails);
+    const fastPath = (0, index_js_1.createAdaptiveFastPath)(config.fastPath, config.fastPathStorage);
+    let fastPathReady;
+    const ensureFastPathReady = () => {
+        fastPathReady ??= fastPath.loadFromStorage();
+        return fastPathReady;
+    };
+    const router = (0, index_js_1.createAiRouter)({
+        modules: config.modules,
+        relatedModules: config.relatedModules,
+        confidenceThresholds: config.confidenceThresholds,
+        routingMode: config.routingMode ?? 'focused',
+    });
+    const modelSelector = config.models && config.modelInstanceFactory
+        ? (0, index_js_1.createModelSelectorFromMap)(config.models, config.modelInstanceFactory, config.modules)
+        : config.modelSelector
+            ? (0, index_js_1.createModelSelector)(config.modelSelector, config.modules)
+            : undefined;
+    const classifierModel = config.classifier?.model
+        ?? config.modelSelector?.fast.instance
+        ?? (config.models && config.modelInstanceFactory
+            ? config.modelInstanceFactory(config.models.fast
+                ?? config.models.standard
+                ?? 'default')
+            : undefined);
+    const classifier = (0, index_js_1.createIntentClassifier)({
+        ...config.classifier,
+        modules: config.modules,
+        model: classifierModel,
+        generateText: config.generateText,
+    });
+    const followupsEnabled = config.followups?.enabled ?? false;
+    const defaultModel = { modelId: 'default' };
+    // A request reaches the pipeline again when it continues after an approval:
+    // same words, same earlier user messages. It keeps its classification, so
+    // the continuation saves the classifier call and stays in its module.
+    const recentIntents = new Map();
+    const selectModel = (intent, context) => modelSelector?.select(intent, context) ?? defaultModel;
+    return {
+        async process(input, context, conversationHistory) {
+            const validation = guardrails.validate(input);
+            config.onAudit?.({
+                type: validation.blocked ? 'guardrail.blocked' : 'guardrail.passed',
+                timestamp: new Date().toISOString(),
+                sessionId: '',
+                source: 'server-core',
+                details: {
+                    inputLength: input.length,
+                    blocked: validation.blocked,
+                    reason: validation.reason,
+                },
+            });
+            if (validation.blocked) {
+                const intent = { intent: 'ambiguous', confidence: 0 };
+                return {
+                    model: selectModel(intent, context),
+                    tools: [],
+                    toolSelection: 'explicit',
+                    sanitizedInput: validation.sanitized,
+                    intent,
+                    module: null,
+                    followupsEnabled,
+                    blocked: true,
+                };
+            }
+            const startedAt = Date.now();
+            await ensureFastPathReady();
+            const hasConversationHistory = Boolean(conversationHistory?.length);
+            let intent = hasConversationHistory
+                ? null
+                : fastPath.match(validation.sanitized);
+            const fastPathHit = intent !== null;
+            const continuationKey = continuationKeyOf(validation.sanitized, conversationHistory);
+            const continued = intent ? undefined : recentIntents.get(continuationKey);
+            const continuationHit = !!continued && Date.now() - continued.at < CONTINUATION_TTL_MS;
+            if (continuationHit)
+                intent = continued.intent;
+            if (!intent) {
+                intent = await classifier.classify(validation.sanitized, context, conversationHistory);
+                if (!hasConversationHistory) {
+                    fastPath.learn(validation.sanitized, intent);
+                }
+                if (intent.intent !== 'ambiguous') {
+                    recentIntents.delete(continuationKey);
+                    recentIntents.set(continuationKey, { intent, at: Date.now() });
+                    if (recentIntents.size > CONTINUATION_MAX_ENTRIES) {
+                        recentIntents.delete(recentIntents.keys().next().value);
+                    }
+                }
+            }
+            void fastPath.saveToStorage();
+            config.onAudit?.({
+                type: 'intent.classified',
+                timestamp: new Date().toISOString(),
+                sessionId: '',
+                source: 'server-core',
+                details: {
+                    intent: intent.intent,
+                    confidence: intent.confidence,
+                    latencyMs: Date.now() - startedAt,
+                    fastPathHit,
+                },
+            });
+            const selected = router.route(intent, config.modules.flatMap((module) => [
+                ...module.tools,
+                ...(module.sharedTools ?? []),
+            ]));
+            config.onAudit?.({
+                type: 'routing.resolved',
+                timestamp: new Date().toISOString(),
+                sessionId: '',
+                source: 'server-core',
+                details: {
+                    module: selected.module?.id ?? null,
+                    strategy: selected.strategy,
+                    toolCount: selected.tools.length,
+                },
+            });
+            const tools = [...selected.tools];
+            if (followupsEnabled)
+                tools.push('suggest_followups');
+            return {
+                model: selectModel(intent, context),
+                tools: [...new Set(tools)],
+                ...(config.routingMode === 'legacy' ? {} : { toolSelection: 'explicit' }),
+                sanitizedInput: validation.sanitized,
+                intent,
+                module: selected.module,
+                followupsEnabled,
+                blocked: false,
+            };
+        },
+    };
+}

package/dist/cjs/server/pii-shield/index.d.ts

@@ -1,4 +1,5 @@
 export { createPiiShield } from './create-pii-shield.js';
+export { createRegexPiiDetector, type RegexPiiDetectorConfig, } from './regex-detector.js';
 export { createAegisDetector } from './aegis-detector.js';
 export type { AegisLike } from './aegis-detector.js';
 export type { PiiCategory, PiiEntity, PiiDetector, PiiShield, PiiShieldConfig, PiiAuditEntry, ComplianceSummary, MappingEntry, } from '../../types.js';

package/dist/cjs/server/pii-shield/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAegisDetector = exports.createPiiShield = void 0;
+exports.createAegisDetector = exports.createRegexPiiDetector = exports.createPiiShield = void 0;
 // Factory
 var create_pii_shield_js_1 = require("./create-pii-shield.js");
 Object.defineProperty(exports, "createPiiShield", { enumerable: true, get: function () { return create_pii_shield_js_1.createPiiShield; } });
+var regex_detector_js_1 = require("./regex-detector.js");
+Object.defineProperty(exports, "createRegexPiiDetector", { enumerable: true, get: function () { return regex_detector_js_1.createRegexPiiDetector; } });
 // Aegis (Pro) detector adapter
 var aegis_detector_js_1 = require("./aegis-detector.js");
 Object.defineProperty(exports, "createAegisDetector", { enumerable: true, get: function () { return aegis_detector_js_1.createAegisDetector; } });

package/dist/cjs/server/pii-shield/regex-detector.d.ts

@@ -0,0 +1,13 @@
+import type { PiiCategory, PiiDetector } from '../../types.js';
+interface RegexPattern {
+    type: PiiCategory;
+    pattern: RegExp;
+    score: number;
+    validate?: (match: string) => boolean;
+}
+export interface RegexPiiDetectorConfig {
+    categories?: PiiCategory[];
+    customPatterns?: RegexPattern[];
+}
+export declare function createRegexPiiDetector(config?: RegexPiiDetectorConfig): PiiDetector;
+export {};

package/dist/cjs/server/pii-shield/regex-detector.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRegexPiiDetector = createRegexPiiDetector;
+const COMMON_PATTERNS = [
+    {
+        type: 'email',
+        pattern: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
+        score: 0.95,
+    },
+    {
+        type: 'iban',
+        pattern: /\b[A-Z]{2}\d{2}(?:\s?[A-Z0-9]{4}){3,7}\s?[A-Z0-9]{0,2}\b/g,
+        score: 0.9,
+        validate: (match) => {
+            const length = match.replace(/\s/g, '').length;
+            return length >= 15 && length <= 34;
+        },
+    },
+    {
+        type: 'ip_address',
+        pattern: /\b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b/g,
+        score: 0.7,
+    },
+    {
+        type: 'url',
+        pattern: /https?:\/\/[^\s<>"{}|\\^`[\]]+/g,
+        score: 0.8,
+    },
+];
+const GERMAN_PATTERNS = [
+    {
+        type: 'phone',
+        pattern: /(?:\+49|0049)[\s.-]?\(?\d{2,5}\)?[\s.-]?\d{3,10}(?:[\s.-]?\d{1,8})?/g,
+        score: 0.8,
+        validate: (match) => {
+            const length = match.replace(/\D/g, '').length;
+            return length >= 7 && length <= 15;
+        },
+    },
+    {
+        type: 'phone',
+        pattern: /\b0\d{2,4}[\s/.-]\d{3,8}(?:[\s/.-]?\d{1,6})?\b/g,
+        score: 0.7,
+    },
+    {
+        type: 'date_of_birth',
+        pattern: /\b(?:0[1-9]|[12]\d|3[01])\.(?:0[1-9]|1[0-2])\.(?:19|20)\d{2}\b/g,
+        score: 0.6,
+    },
+    {
+        type: 'tax_id',
+        pattern: /\b\d{2,3}\/\d{3,4}\/\d{4,5}\b/g,
+        score: 0.6,
+    },
+    {
+        type: 'address',
+        pattern: /\b\d{5}\s+[A-ZÄÖÜ][a-zäöüß]+/g,
+        score: 0.6,
+    },
+];
+function deduplicate(entities) {
+    const sorted = [...entities].sort((left, right) => (left.start - right.start
+        || right.score - left.score
+        || (right.end - right.start) - (left.end - left.start)));
+    const result = [];
+    for (const entity of sorted) {
+        const previous = result.at(-1);
+        if (!previous || entity.start >= previous.end) {
+            result.push(entity);
+        }
+    }
+    return result;
+}
+function createRegexPiiDetector(config = {}) {
+    return {
+        detect(text, locales = []) {
+            const locale = locales[0]?.split('-')[0]?.toLowerCase();
+            let patterns = [
+                ...COMMON_PATTERNS,
+                ...(locale === 'de' ? GERMAN_PATTERNS : []),
+                ...(config.customPatterns ?? []),
+            ];
+            if (config.categories?.length) {
+                const allowed = new Set(config.categories);
+                patterns = patterns.filter((pattern) => allowed.has(pattern.type));
+            }
+            const entities = [];
+            for (const definition of patterns) {
+                const pattern = new RegExp(definition.pattern.source, definition.pattern.flags.includes('g')
+                    ? definition.pattern.flags
+                    : `${definition.pattern.flags}g`);
+                for (const match of text.matchAll(pattern)) {
+                    const value = match[0];
+                    const start = match.index;
+                    if (start === undefined || !value)
+                        continue;
+                    if (definition.validate && !definition.validate(value))
+                        continue;
+                    entities.push({
+                        type: definition.type,
+                        start,
+                        end: start + value.length,
+                        score: definition.score,
+                        text: value,
+                    });
+                }
+            }
+            return deduplicate(entities);
+        },
+    };
+}