@salimassili/ai-costguard 1.1.3

package/dist/aerl/ExecutionInterceptor.js

@@ -0,0 +1,246 @@
+"use strict";
+/**
+ * AERL - AI Execution Reliability Layer
+ * Execution Interceptor Module
+ *
+ * PURPOSE:
+ * - Synchronous pre-call decision engine
+ * - Allow / block / modify decisions
+ * - Deterministic + cached
+ * - <5ms p95 latency
+ *
+ * DESIGN:
+ * - In-process only
+ * - No external I/O in hot path
+ * - LRU cache for sub-millisecond repeat decisions
+ * - Fail-open with logging
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interceptor = exports.ExecutionInterceptor = void 0;
+const perf_hooks_1 = require("perf_hooks");
+const crypto_1 = require("crypto");
+// LRU Cache for fast-path decisions
+class LRUCache {
+    constructor(maxSize) {
+        this.cache = new Map();
+        this.maxSize = maxSize;
+    }
+    get(key) {
+        const value = this.cache.get(key);
+        if (value !== undefined) {
+            this.cache.delete(key);
+            this.cache.set(key, value);
+        }
+        return value;
+    }
+    set(key, value) {
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        else if (this.cache.size >= this.maxSize) {
+            const first = this.cache.keys().next();
+            if (!first.done && first.value !== undefined) {
+                this.cache.delete(first.value);
+            }
+        }
+        this.cache.set(key, value);
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+class ExecutionInterceptor {
+    constructor(config = {}) {
+        this.config = {
+            failOpen: true,
+            maxLatencyMs: 5,
+            cacheSize: 10000,
+            defaultPolicy: {
+                maxCostPerWorkflow: 50, // $50 default
+                maxStepsPerWorkflow: 100, // 100 steps default
+                maxCostPerStep: 10, // $10 per step
+                minReliabilityScore: 0.3, // Block if reliability < 30%
+            },
+            ...config,
+        };
+        this.cache = new LRUCache(this.config.cacheSize);
+        this.metrics = {
+            totalRequests: 0,
+            cacheHits: 0,
+            blockedRequests: 0,
+            modifiedRequests: 0,
+            latencySamples: [],
+        };
+    }
+    /**
+     * Main interception - MUST complete in <5ms p95
+     */
+    intercept(request) {
+        const startTime = perf_hooks_1.performance.now();
+        try {
+            // 1. Cache check (sub-millisecond)
+            const cacheKey = this.generateCacheKey(request);
+            const cached = this.cache.get(cacheKey);
+            if (cached) {
+                this.metrics.cacheHits++;
+                this.recordLatency(perf_hooks_1.performance.now() - startTime);
+                return { ...cached, cacheHit: true, latencyMs: perf_hooks_1.performance.now() - startTime };
+            }
+            // 2. Evaluate against policy
+            const policyResult = this.evaluatePolicy(request);
+            // 3. Build decision result
+            const result = {
+                action: policyResult.action,
+                reason: policyResult.reason,
+                reliabilityScore: policyResult.reliabilityScore,
+                confidence: policyResult.confidence,
+                latencyMs: 0,
+                suggestedModification: policyResult.modification,
+                estimatedSavings: policyResult.action === 'block' ? request.estimatedCost : undefined,
+                cacheHit: false,
+            };
+            // 4. Cache decision
+            this.cache.set(cacheKey, result);
+            // 5. Record metrics
+            const latency = perf_hooks_1.performance.now() - startTime;
+            result.latencyMs = latency;
+            this.recordLatency(latency);
+            if (result.action === 'block') {
+                this.metrics.blockedRequests++;
+            }
+            else if (result.action === 'modify') {
+                this.metrics.modifiedRequests++;
+            }
+            return result;
+        }
+        catch (error) {
+            console.error('[AERL] Interceptor error:', error);
+            return {
+                action: this.config.failOpen ? 'allow' : 'block',
+                reason: `Interceptor error: ${error instanceof Error ? error.message : 'unknown'}`,
+                reliabilityScore: this.config.failOpen ? 0.5 : 0,
+                confidence: 0,
+                latencyMs: perf_hooks_1.performance.now() - startTime,
+                cacheHit: false,
+            };
+        }
+    }
+    evaluatePolicy(request) {
+        const ctx = request.context;
+        const policy = this.config.defaultPolicy;
+        // Calculate reliability score
+        const reliabilityScore = this.calculateReliabilityScore(request);
+        // Policy 1: Hard cost limit
+        if (ctx.totalCost + request.estimatedCost > policy.maxCostPerWorkflow) {
+            return {
+                action: 'block',
+                reason: `Workflow cost limit: $${ctx.totalCost.toFixed(2)} + $${request.estimatedCost.toFixed(2)} > $${policy.maxCostPerWorkflow}`,
+                reliabilityScore: 0.1,
+                confidence: 1.0,
+            };
+        }
+        // Policy 2: Step limit
+        if (ctx.stepNumber >= policy.maxStepsPerWorkflow) {
+            return {
+                action: 'block',
+                reason: `Step limit reached: ${ctx.stepNumber} >= ${policy.maxStepsPerWorkflow}`,
+                reliabilityScore: 0.05,
+                confidence: 1.0,
+            };
+        }
+        // Policy 3: Single step cost
+        if (request.estimatedCost > policy.maxCostPerStep) {
+            return {
+                action: 'modify',
+                reason: `Step cost high: $${request.estimatedCost.toFixed(2)} > $${policy.maxCostPerStep}, suggesting cheaper alternative`,
+                reliabilityScore: 0.4,
+                confidence: 0.8,
+                modification: {
+                    alternativeTool: 'cheaper_model',
+                    retryStrategy: 'backoff',
+                },
+            };
+        }
+        // Policy 4: Low reliability score
+        if (reliabilityScore < policy.minReliabilityScore) {
+            return {
+                action: 'modify',
+                reason: `Low reliability score: ${(reliabilityScore * 100).toFixed(0)}% < ${(policy.minReliabilityScore * 100).toFixed(0)}%, suggesting retry strategy`,
+                reliabilityScore,
+                confidence: 0.85,
+                modification: {
+                    retryStrategy: 'backoff',
+                    parameterAdjustments: { temperature: 0.3 },
+                },
+            };
+        }
+        // Allow
+        return {
+            action: 'allow',
+            reason: reliabilityScore > 0.8 ? 'High reliability' : 'Acceptable risk',
+            reliabilityScore,
+            confidence: reliabilityScore,
+        };
+    }
+    calculateReliabilityScore(request) {
+        const ctx = request.context;
+        let score = 0.5; // Start neutral
+        // Factor 1: Recent failure rate
+        const totalSteps = ctx.successCount + ctx.failureCount;
+        if (totalSteps > 0) {
+            const failureRate = ctx.failureCount / totalSteps;
+            score -= failureRate * 0.4; // Up to -0.4 for 100% failure rate
+        }
+        // Factor 2: Step progression
+        const stepRatio = ctx.stepNumber / this.config.defaultPolicy.maxStepsPerWorkflow;
+        if (stepRatio > 0.8)
+            score -= 0.2;
+        else if (stepRatio > 0.5)
+            score -= 0.1;
+        // Factor 3: Cost escalation
+        const costRatio = ctx.totalCost / this.config.defaultPolicy.maxCostPerWorkflow;
+        if (costRatio > 0.8)
+            score -= 0.2;
+        else if (costRatio > 0.5)
+            score -= 0.1;
+        // Factor 4: Success streak
+        if (ctx.successCount > 5)
+            score += 0.1;
+        if (ctx.successCount > 10)
+            score += 0.1;
+        return Math.max(0, Math.min(1, score));
+    }
+    generateCacheKey(request) {
+        const key = `${request.context.sessionId}:${request.context.stepNumber}:${request.operation}:${request.estimatedCost}`;
+        return (0, crypto_1.createHash)('sha256').update(key).digest('hex').substring(0, 32);
+    }
+    recordLatency(latencyMs) {
+        this.metrics.totalRequests++;
+        this.metrics.latencySamples.push(latencyMs);
+        if (this.metrics.latencySamples.length > 1000) {
+            this.metrics.latencySamples.shift();
+        }
+    }
+    getMetrics() {
+        const sorted = [...this.metrics.latencySamples].sort((a, b) => a - b);
+        return {
+            ...this.metrics,
+            cacheHitRate: this.metrics.totalRequests > 0 ? this.metrics.cacheHits / this.metrics.totalRequests : 0,
+            blockRate: this.metrics.totalRequests > 0 ? this.metrics.blockedRequests / this.metrics.totalRequests : 0,
+            p95LatencyMs: sorted[Math.floor(sorted.length * 0.95)] || 0,
+        };
+    }
+    reset() {
+        this.cache.clear();
+        this.metrics = {
+            totalRequests: 0,
+            cacheHits: 0,
+            blockedRequests: 0,
+            modifiedRequests: 0,
+            latencySamples: [],
+        };
+    }
+}
+exports.ExecutionInterceptor = ExecutionInterceptor;
+exports.interceptor = new ExecutionInterceptor();
+//# sourceMappingURL=ExecutionInterceptor.js.map

package/dist/aerl/ExecutionInterceptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionInterceptor.js","sourceRoot":"","sources":["../../src/aerl/ExecutionInterceptor.ts"],"names":[],"mappings":"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"}

package/dist/aerl/ExecutionMemory.d.ts

@@ -0,0 +1,138 @@
+/**
+ * AERL - Execution Memory Layer
+ *
+ * Stores hashed execution data for pattern recognition:
+ * - Hashed execution traces (no raw prompts)
+ * - Failure patterns
+ * - Loop signatures
+ * - Success/failure sequences
+ *
+ * PURPOSE: Improve future reliability decisions without storing sensitive data
+ *
+ * REQUIREMENTS:
+ * - No raw sensitive data stored
+ * - In-memory with TTL
+ * - Fixed memory budget
+ * - Pattern lookup in <1ms
+ */
+export interface ExecutionTrace {
+    traceId: string;
+    sessionId: string;
+    workflowId: string;
+    stepNumber: number;
+    operation: string;
+    inputHash: string;
+    outputHash?: string;
+    cost: number;
+    tokens: number;
+    durationMs: number;
+    timestamp: number;
+    success: boolean;
+    failureType?: string;
+}
+export interface FailurePattern {
+    patternId: string;
+    signature: string;
+    operation: string;
+    failureType: string;
+    occurrenceCount: number;
+    lastSeen: number;
+    avgCostBeforeFailure: number;
+    avgStepsBeforeFailure: number;
+}
+export interface LoopSignature {
+    loopId: string;
+    signature: string;
+    nodeSequence: string[];
+    occurrenceCount: number;
+    lastSeen: number;
+}
+export interface SuccessSequence {
+    sequenceId: string;
+    signature: string;
+    operations: string[];
+    avgCost: number;
+    avgDurationMs: number;
+    occurrenceCount: number;
+    lastSeen: number;
+}
+export declare class ExecutionMemory {
+    private traces;
+    private failurePatterns;
+    private loopSignatures;
+    private successSequences;
+    private maxTracesPerSession;
+    private maxPatterns;
+    private ttlMs;
+    constructor(config?: {
+        maxTracesPerSession?: number;
+        maxPatterns?: number;
+        ttlMinutes?: number;
+    });
+    /**
+     * Record execution trace
+     */
+    recordTrace(trace: ExecutionTrace): void;
+    /**
+     * Record loop signature
+     */
+    recordLoop(workflowId: string, nodeHashes: string[]): void;
+    /**
+     * Record success sequence for future optimization
+     */
+    recordSuccessSequence(sessionId: string, operations: string[], avgCost: number, avgDuration: number): void;
+    /**
+     * Check if input hash matches known failure pattern
+     */
+    checkFailureRisk(operation: string, inputHash: string): {
+        riskScore: number;
+        similarFailures: number;
+        avgCostBeforeFailure: number;
+    };
+    /**
+     * Check if loop pattern exists
+     */
+    checkLoopPattern(nodeHashes: string[]): {
+        isKnownLoop: boolean;
+        occurrenceCount: number;
+    };
+    /**
+     * Get session traces
+     */
+    getSessionTraces(sessionId: string): ExecutionTrace[];
+    /**
+     * Get recommended approach based on success sequences
+     */
+    getRecommendedApproach(operations: string[]): {
+        hasRecommendation: boolean;
+        avgCost: number;
+        avgDurationMs: number;
+        confidence: number;
+    };
+    private indexFailurePattern;
+    private hashLoop;
+    private hashSequence;
+    private cleanup;
+    private evictOldPatterns;
+    private evictOldest;
+    /**
+     * Get memory stats
+     */
+    getStats(): {
+        activeSessions: number;
+        totalTraces: number;
+        failurePatterns: number;
+        loopSignatures: number;
+        successSequences: number;
+    };
+    /**
+     * Clear session
+     */
+    clearSession(sessionId: string): void;
+    /**
+     * Reset all
+     */
+    reset(): void;
+}
+export declare const executionMemory: ExecutionMemory;
+//# sourceMappingURL=ExecutionMemory.d.ts.map

package/dist/aerl/ExecutionMemory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionMemory.d.ts","sourceRoot":"","sources":["../../src/aerl/ExecutionMemory.ts"],"names":[],"mappings":"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"}

package/dist/aerl/ExecutionMemory.js

@@ -0,0 +1,284 @@
+"use strict";
+/**
+ * AERL - Execution Memory Layer
+ *
+ * Stores hashed execution data for pattern recognition:
+ * - Hashed execution traces (no raw prompts)
+ * - Failure patterns
+ * - Loop signatures
+ * - Success/failure sequences
+ *
+ * PURPOSE: Improve future reliability decisions without storing sensitive data
+ *
+ * REQUIREMENTS:
+ * - No raw sensitive data stored
+ * - In-memory with TTL
+ * - Fixed memory budget
+ * - Pattern lookup in <1ms
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executionMemory = exports.ExecutionMemory = void 0;
+const crypto_1 = require("crypto");
+class ExecutionMemory {
+    constructor(config) {
+        this.traces = new Map();
+        this.failurePatterns = new Map();
+        this.loopSignatures = new Map();
+        this.successSequences = new Map();
+        this.maxTracesPerSession = config?.maxTracesPerSession || 100;
+        this.maxPatterns = config?.maxPatterns || 1000;
+        this.ttlMs = (config?.ttlMinutes || 60) * 60 * 1000;
+        setInterval(() => this.cleanup(), 60000);
+    }
+    /**
+     * Record execution trace
+     */
+    recordTrace(trace) {
+        let sessionTraces = this.traces.get(trace.sessionId);
+        if (!sessionTraces) {
+            sessionTraces = [];
+            this.traces.set(trace.sessionId, sessionTraces);
+        }
+        sessionTraces.push(trace);
+        // Limit traces per session
+        if (sessionTraces.length > this.maxTracesPerSession) {
+            sessionTraces.shift();
+        }
+        // Index by pattern if failure
+        if (!trace.success && trace.failureType) {
+            this.indexFailurePattern(trace);
+        }
+    }
+    /**
+     * Record loop signature
+     */
+    recordLoop(workflowId, nodeHashes) {
+        const signature = this.hashLoop(nodeHashes);
+        const existing = this.loopSignatures.get(signature);
+        if (existing) {
+            existing.occurrenceCount++;
+            existing.lastSeen = Date.now();
+        }
+        else {
+            this.loopSignatures.set(signature, {
+                loopId: `loop-${signature.substring(0, 8)}`,
+                signature,
+                nodeSequence: nodeHashes,
+                occurrenceCount: 1,
+                lastSeen: Date.now(),
+            });
+        }
+        // Evict old patterns if at capacity
+        if (this.loopSignatures.size > this.maxPatterns) {
+            this.evictOldest(this.loopSignatures);
+        }
+    }
+    /**
+     * Record success sequence for future optimization
+     */
+    recordSuccessSequence(sessionId, operations, avgCost, avgDuration) {
+        const signature = this.hashSequence(operations);
+        const existing = this.successSequences.get(signature);
+        if (existing) {
+            existing.occurrenceCount++;
+            existing.lastSeen = Date.now();
+            // Update averages
+            const n = existing.occurrenceCount;
+            existing.avgCost = (existing.avgCost * (n - 1) + avgCost) / n;
+            existing.avgDurationMs = (existing.avgDurationMs * (n - 1) + avgDuration) / n;
+        }
+        else {
+            this.successSequences.set(signature, {
+                sequenceId: `seq-${signature.substring(0, 8)}`,
+                signature,
+                operations: [...operations],
+                avgCost,
+                avgDurationMs: avgDuration,
+                occurrenceCount: 1,
+                lastSeen: Date.now(),
+            });
+        }
+    }
+    /**
+     * Check if input hash matches known failure pattern
+     */
+    checkFailureRisk(operation, inputHash) {
+        let matches = 0;
+        let totalCost = 0;
+        for (const pattern of this.failurePatterns.values()) {
+            if (pattern.operation === operation) {
+                // Simple similarity: check if hashes share prefix
+                if (inputHash.substring(0, 8) === pattern.signature.substring(0, 8)) {
+                    matches++;
+                    totalCost += pattern.avgCostBeforeFailure;
+                }
+            }
+        }
+        const riskScore = Math.min(1, matches / 5); // 5+ similar failures = high risk
+        const avgCost = matches > 0 ? totalCost / matches : 0;
+        return {
+            riskScore,
+            similarFailures: matches,
+            avgCostBeforeFailure: avgCost,
+        };
+    }
+    /**
+     * Check if loop pattern exists
+     */
+    checkLoopPattern(nodeHashes) {
+        const signature = this.hashLoop(nodeHashes);
+        const pattern = this.loopSignatures.get(signature);
+        return {
+            isKnownLoop: !!pattern,
+            occurrenceCount: pattern?.occurrenceCount || 0,
+        };
+    }
+    /**
+     * Get session traces
+     */
+    getSessionTraces(sessionId) {
+        return this.traces.get(sessionId) || [];
+    }
+    /**
+     * Get recommended approach based on success sequences
+     */
+    getRecommendedApproach(operations) {
+        const signature = this.hashSequence(operations);
+        const sequence = this.successSequences.get(signature);
+        if (!sequence) {
+            return {
+                hasRecommendation: false,
+                avgCost: 0,
+                avgDurationMs: 0,
+                confidence: 0,
+            };
+        }
+        // Confidence based on occurrence count
+        const confidence = Math.min(0.95, sequence.occurrenceCount / 10);
+        return {
+            hasRecommendation: true,
+            avgCost: sequence.avgCost,
+            avgDurationMs: sequence.avgDurationMs,
+            confidence,
+        };
+    }
+    indexFailurePattern(trace) {
+        // Create signature from operation + input prefix
+        const signature = (0, crypto_1.createHash)('sha256')
+            .update(`${trace.operation}:${trace.inputHash.substring(0, 16)}`)
+            .digest('hex')
+            .substring(0, 32);
+        const existing = this.failurePatterns.get(signature);
+        if (existing) {
+            existing.occurrenceCount++;
+            existing.lastSeen = Date.now();
+            // Update averages
+            const sessionTraces = this.traces.get(trace.sessionId) || [];
+            const stepsBefore = sessionTraces.filter(t => t.timestamp < trace.timestamp).length;
+            const costBefore = sessionTraces
+                .filter(t => t.timestamp < trace.timestamp)
+                .reduce((sum, t) => sum + t.cost, 0);
+            const n = existing.occurrenceCount;
+            existing.avgStepsBeforeFailure = (existing.avgStepsBeforeFailure * (n - 1) + stepsBefore) / n;
+            existing.avgCostBeforeFailure = (existing.avgCostBeforeFailure * (n - 1) + costBefore) / n;
+        }
+        else {
+            const sessionTraces = this.traces.get(trace.sessionId) || [];
+            const stepsBefore = sessionTraces.filter(t => t.timestamp < trace.timestamp).length;
+            const costBefore = sessionTraces
+                .filter(t => t.timestamp < trace.timestamp)
+                .reduce((sum, t) => sum + t.cost, 0);
+            this.failurePatterns.set(signature, {
+                patternId: `fail-${signature.substring(0, 8)}`,
+                signature,
+                operation: trace.operation,
+                failureType: trace.failureType || 'unknown',
+                occurrenceCount: 1,
+                lastSeen: Date.now(),
+                avgCostBeforeFailure: costBefore,
+                avgStepsBeforeFailure: stepsBefore,
+            });
+        }
+    }
+    hashLoop(nodeHashes) {
+        return (0, crypto_1.createHash)('sha256')
+            .update(nodeHashes.join(':'))
+            .digest('hex')
+            .substring(0, 32);
+    }
+    hashSequence(operations) {
+        return (0, crypto_1.createHash)('sha256')
+            .update(operations.join(':'))
+            .digest('hex')
+            .substring(0, 32);
+    }
+    cleanup() {
+        const now = Date.now();
+        // Clean up old traces
+        for (const [sessionId, traces] of this.traces) {
+            const recent = traces.filter(t => now - t.timestamp < this.ttlMs);
+            if (recent.length === 0) {
+                this.traces.delete(sessionId);
+            }
+            else if (recent.length < traces.length) {
+                this.traces.set(sessionId, recent);
+            }
+        }
+        // Clean up old patterns
+        this.evictOldPatterns(this.failurePatterns, now);
+        this.evictOldPatterns(this.loopSignatures, now);
+        this.evictOldPatterns(this.successSequences, now);
+    }
+    evictOldPatterns(patterns, now) {
+        for (const [key, pattern] of patterns) {
+            if (now - pattern.lastSeen > this.ttlMs) {
+                patterns.delete(key);
+            }
+        }
+    }
+    evictOldest(map) {
+        let oldest = null;
+        for (const [key, value] of map) {
+            if (!oldest || value.lastSeen < oldest.time) {
+                oldest = { key, time: value.lastSeen };
+            }
+        }
+        if (oldest) {
+            map.delete(oldest.key);
+        }
+    }
+    /**
+     * Get memory stats
+     */
+    getStats() {
+        let totalTraces = 0;
+        for (const traces of this.traces.values()) {
+            totalTraces += traces.length;
+        }
+        return {
+            activeSessions: this.traces.size,
+            totalTraces,
+            failurePatterns: this.failurePatterns.size,
+            loopSignatures: this.loopSignatures.size,
+            successSequences: this.successSequences.size,
+        };
+    }
+    /**
+     * Clear session
+     */
+    clearSession(sessionId) {
+        this.traces.delete(sessionId);
+    }
+    /**
+     * Reset all
+     */
+    reset() {
+        this.traces.clear();
+        this.failurePatterns.clear();
+        this.loopSignatures.clear();
+        this.successSequences.clear();
+    }
+}
+exports.ExecutionMemory = ExecutionMemory;
+exports.executionMemory = new ExecutionMemory();
+//# sourceMappingURL=ExecutionMemory.js.map