opc-agent 0.8.0 → 0.9.0

package/dist/cli.js

@@ -50,7 +50,11 @@ const content_writer_1 = require("./templates/content-writer");
 const legal_assistant_1 = require("./templates/legal-assistant");
 const financial_advisor_1 = require("./templates/financial-advisor");
 const executive_assistant_1 = require("./templates/executive-assistant");
+const data_analyst_1 = require("./templates/data-analyst");
+const teacher_1 = require("./templates/teacher");
 const analytics_1 = require("./analytics");
+const analytics_engine_1 = require("./core/analytics-engine");
+const testing_1 = require("./testing");
 const openclaw_1 = require("./deploy/openclaw");
 const hermes_1 = require("./deploy/hermes");
 const workflow_1 = require("./core/workflow");
@@ -90,6 +94,8 @@ const TEMPLATES = {
     'legal-assistant': { label: 'Legal Assistant - contract review + compliance + legal research', factory: legal_assistant_1.createLegalAssistantConfig },
     'financial-advisor': { label: 'Financial Advisor - budget analysis + expense tracking + planning', factory: financial_advisor_1.createFinancialAdvisorConfig },
     'executive-assistant': { label: 'Executive Assistant - calendar + email drafting + meeting prep', factory: executive_assistant_1.createExecutiveAssistantConfig },
+    'data-analyst': { label: 'Data Analyst - data querying + visualization + insights', factory: data_analyst_1.createDataAnalystConfig },
+    'teacher': { label: 'Teacher - lesson planning + quizzes + concept explanation', factory: teacher_1.createTeacherConfig },
 };
 async function promptUser(question, defaultValue) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -113,7 +119,7 @@ async function select(question, options) {
 program
     .name('opc')
     .description('OPC Agent - Open Agent Framework for business workstations')
-    .version('0.6.0');
+    .version('0.9.0');
 // ── Init command ─────────────────────────────────────────────
 program
     .command('init')
@@ -396,25 +402,47 @@ program
 // ── Test command ─────────────────────────────────────────────
 program
     .command('test')
-    .description('Run agent in sandbox mode')
+    .description('Run agent tests defined in OAD or tests.yaml')
     .option('-f, --file <file>', 'OAD file', 'oad.yaml')
+    .option('--json', 'Output as JSON')
     .action(async (opts) => {
     loadDotEnv();
-    console.log(`\n${icon.gear} Running agent in sandbox mode...`);
-    const runtime = new runtime_1.AgentRuntime();
-    await runtime.loadConfig(opts.file);
-    const agent = await runtime.initialize();
-    console.log(`${icon.success} Agent "${color.bold(agent.name)}" initialized in sandbox.`);
-    console.log(`   State: ${agent.state}`);
-    console.log(`   Sending test message...`);
-    const response = await agent.handleMessage({
-        id: 'test_1',
-        role: 'user',
-        content: 'Hello! What can you help me with?',
-        timestamp: Date.now(),
-    });
-    console.log(`   Response: ${response.content.slice(0, 200)}`);
-    console.log(`${icon.success} Sandbox test passed.\n`);
+    console.log(`\n${icon.gear} Running agent tests...\n`);
+    try {
+        const report = await (0, testing_1.runTests)(opts.file);
+        if (opts.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log((0, testing_1.formatReport)(report));
+        }
+        process.exit(report.failed > 0 ? 1 : 0);
+    }
+    catch (err) {
+        console.error(`${icon.error} Test failed:`, err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+// ── Analytics command ────────────────────────────────────────
+program
+    .command('analytics')
+    .description('Show agent analytics and usage stats')
+    .option('--json', 'Output as JSON')
+    .option('--clear', 'Clear analytics data')
+    .action(async (opts) => {
+    const engine = new analytics_engine_1.AnalyticsEngine('.');
+    if (opts.clear) {
+        engine.clear();
+        console.log(`${icon.success} Analytics data cleared.`);
+        return;
+    }
+    const stats = engine.getStats();
+    if (opts.json) {
+        console.log(JSON.stringify(stats, null, 2));
+    }
+    else {
+        console.log(analytics_engine_1.AnalyticsEngine.formatStats(stats));
+    }
 });
 // ── Dev command ──────────────────────────────────────────────
 program

package/dist/core/analytics-engine.d.ts

@@ -0,0 +1,51 @@
+export interface AnalyticsEvent {
+    type: 'message' | 'llm_call' | 'tool_use' | 'error';
+    timestamp: number;
+    data: Record<string, any>;
+}
+export interface AnalyticsStats {
+    totalMessages: number;
+    totalLLMCalls: number;
+    totalToolUses: number;
+    totalErrors: number;
+    avgResponseTimeMs: number;
+    totalTokens: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    topSkills: {
+        name: string;
+        count: number;
+    }[];
+    topErrors: {
+        message: string;
+        count: number;
+    }[];
+    messagesPerDay: Record<string, number>;
+    period: {
+        from: number;
+        to: number;
+    };
+}
+export declare class AnalyticsEngine {
+    private dataDir;
+    private eventsFile;
+    private events;
+    constructor(dataDir?: string);
+    private load;
+    private save;
+    track(type: AnalyticsEvent['type'], data: Record<string, any>): void;
+    trackMessage(userId: string, responseTimeMs: number, tokensIn: number, tokensOut: number): void;
+    trackLLMCall(provider: string, model: string, tokensIn: number, tokensOut: number, latencyMs: number): void;
+    trackToolUse(toolName: string, success: boolean, latencyMs: number): void;
+    trackError(error: string, context?: string): void;
+    getStats(fromTs?: number, toTs?: number): AnalyticsStats;
+    getRecentEvents(limit?: number): AnalyticsEvent[];
+    clear(): void;
+    /**
+     * Format stats for CLI display.
+     */
+    static formatStats(stats: AnalyticsStats): string;
+}
+//# sourceMappingURL=analytics-engine.d.ts.map

package/dist/core/analytics-engine.js

@@ -0,0 +1,186 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyticsEngine = void 0;
+/**
+ * Analytics Engine - Persistent analytics with JSON file storage.
+ * Tracks every message, LLM call, tool use, and error with timestamps.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class AnalyticsEngine {
+    dataDir;
+    eventsFile;
+    events = [];
+    constructor(dataDir = '.') {
+        this.dataDir = path.resolve(dataDir, 'data');
+        this.eventsFile = path.join(this.dataDir, 'analytics.json');
+        this.load();
+    }
+    load() {
+        try {
+            if (fs.existsSync(this.eventsFile)) {
+                const raw = fs.readFileSync(this.eventsFile, 'utf-8');
+                this.events = JSON.parse(raw);
+            }
+        }
+        catch {
+            this.events = [];
+        }
+    }
+    save() {
+        if (!fs.existsSync(this.dataDir)) {
+            fs.mkdirSync(this.dataDir, { recursive: true });
+        }
+        // Keep last 10000 events to prevent unbounded growth
+        if (this.events.length > 10000) {
+            this.events = this.events.slice(-10000);
+        }
+        fs.writeFileSync(this.eventsFile, JSON.stringify(this.events, null, 2));
+    }
+    track(type, data) {
+        this.events.push({ type, timestamp: Date.now(), data });
+        this.save();
+    }
+    trackMessage(userId, responseTimeMs, tokensIn, tokensOut) {
+        this.track('message', { userId, responseTimeMs, tokensIn, tokensOut });
+    }
+    trackLLMCall(provider, model, tokensIn, tokensOut, latencyMs) {
+        this.track('llm_call', { provider, model, tokensIn, tokensOut, latencyMs });
+    }
+    trackToolUse(toolName, success, latencyMs) {
+        this.track('tool_use', { toolName, success, latencyMs });
+    }
+    trackError(error, context) {
+        this.track('error', { error, context });
+    }
+    getStats(fromTs, toTs) {
+        const now = Date.now();
+        const from = fromTs ?? 0;
+        const to = toTs ?? now;
+        const filtered = this.events.filter(e => e.timestamp >= from && e.timestamp <= to);
+        const messages = filtered.filter(e => e.type === 'message');
+        const llmCalls = filtered.filter(e => e.type === 'llm_call');
+        const toolUses = filtered.filter(e => e.type === 'tool_use');
+        const errors = filtered.filter(e => e.type === 'error');
+        // Avg response time
+        const totalResponseTime = messages.reduce((sum, e) => sum + (e.data.responseTimeMs ?? 0), 0);
+        const avgResponseTimeMs = messages.length > 0 ? Math.round(totalResponseTime / messages.length) : 0;
+        // Total tokens
+        const totalTokensIn = llmCalls.reduce((sum, e) => sum + (e.data.tokensIn ?? 0), 0);
+        const totalTokensOut = llmCalls.reduce((sum, e) => sum + (e.data.tokensOut ?? 0), 0);
+        // Top skills (from tool_use)
+        const skillCounts = {};
+        for (const e of toolUses) {
+            const name = e.data.toolName ?? 'unknown';
+            skillCounts[name] = (skillCounts[name] ?? 0) + 1;
+        }
+        const topSkills = Object.entries(skillCounts)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([name, count]) => ({ name, count }));
+        // Top errors
+        const errorCounts = {};
+        for (const e of errors) {
+            const msg = e.data.error ?? 'unknown';
+            errorCounts[msg] = (errorCounts[msg] ?? 0) + 1;
+        }
+        const topErrors = Object.entries(errorCounts)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([message, count]) => ({ message, count }));
+        // Messages per day
+        const messagesPerDay = {};
+        for (const e of messages) {
+            const day = new Date(e.timestamp).toISOString().slice(0, 10);
+            messagesPerDay[day] = (messagesPerDay[day] ?? 0) + 1;
+        }
+        return {
+            totalMessages: messages.length,
+            totalLLMCalls: llmCalls.length,
+            totalToolUses: toolUses.length,
+            totalErrors: errors.length,
+            avgResponseTimeMs,
+            totalTokens: { input: totalTokensIn, output: totalTokensOut, total: totalTokensIn + totalTokensOut },
+            topSkills,
+            topErrors,
+            messagesPerDay,
+            period: { from, to },
+        };
+    }
+    getRecentEvents(limit = 50) {
+        return this.events.slice(-limit);
+    }
+    clear() {
+        this.events = [];
+        this.save();
+    }
+    /**
+     * Format stats for CLI display.
+     */
+    static formatStats(stats) {
+        const lines = [];
+        lines.push('');
+        lines.push('══════════════════════════════════════════');
+        lines.push('  OPC Agent Analytics');
+        lines.push('══════════════════════════════════════════');
+        lines.push('');
+        lines.push(`  📨 Messages:        ${stats.totalMessages}`);
+        lines.push(`  🤖 LLM Calls:       ${stats.totalLLMCalls}`);
+        lines.push(`  🔧 Tool Uses:        ${stats.totalToolUses}`);
+        lines.push(`  ❌ Errors:           ${stats.totalErrors}`);
+        lines.push(`  ⏱  Avg Response:     ${stats.avgResponseTimeMs}ms`);
+        lines.push(`  🪙 Tokens:           ${stats.totalTokens.total} (in: ${stats.totalTokens.input}, out: ${stats.totalTokens.output})`);
+        lines.push('');
+        if (stats.topSkills.length > 0) {
+            lines.push('  Top Skills:');
+            for (const s of stats.topSkills.slice(0, 5)) {
+                lines.push(`    • ${s.name}: ${s.count}`);
+            }
+            lines.push('');
+        }
+        if (stats.topErrors.length > 0) {
+            lines.push('  Top Errors:');
+            for (const e of stats.topErrors.slice(0, 3)) {
+                lines.push(`    • ${e.message}: ${e.count}`);
+            }
+            lines.push('');
+        }
+        lines.push('──────────────────────────────────────────');
+        return lines.join('\n');
+    }
+}
+exports.AnalyticsEngine = AnalyticsEngine;
+//# sourceMappingURL=analytics-engine.js.map

package/dist/core/cache.d.ts

@@ -0,0 +1,47 @@
+export interface CacheEntry {
+    key: string;
+    value: string;
+    createdAt: number;
+    ttlMs: number;
+    hits: number;
+}
+export interface CacheConfig {
+    enabled: boolean;
+    ttlMs: number;
+    maxEntries: number;
+    dataDir: string;
+}
+export declare class LLMCache {
+    private cache;
+    private config;
+    private filePath;
+    private stats;
+    constructor(config?: Partial<CacheConfig>);
+    private load;
+    private save;
+    private isExpired;
+    /**
+     * Generate a cache key from messages and system prompt.
+     */
+    static makeKey(messages: Array<{
+        role: string;
+        content: string;
+    }>, systemPrompt?: string): string;
+    /**
+     * Get a cached response. Returns null if not found or expired.
+     */
+    get(key: string): string | null;
+    /**
+     * Set a cached response.
+     */
+    set(key: string, value: string, ttlMs?: number): void;
+    getStats(): {
+        hits: number;
+        misses: number;
+        evictions: number;
+        size: number;
+        hitRate: string;
+    };
+    clear(): void;
+}
+//# sourceMappingURL=cache.d.ts.map

package/dist/core/cache.js

@@ -0,0 +1,156 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMCache = void 0;
+/**
+ * Caching Layer - Cache LLM responses with configurable TTL.
+ * Hash-based key from input messages + system prompt.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+class LLMCache {
+    cache = new Map();
+    config;
+    filePath;
+    stats = { hits: 0, misses: 0, evictions: 0 };
+    constructor(config) {
+        this.config = {
+            enabled: config?.enabled ?? true,
+            ttlMs: config?.ttlMs ?? 3600_000, // 1 hour default
+            maxEntries: config?.maxEntries ?? 1000,
+            dataDir: config?.dataDir ?? '.',
+        };
+        this.filePath = path.join(this.config.dataDir, 'data', 'cache.json');
+        this.load();
+    }
+    load() {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                const raw = fs.readFileSync(this.filePath, 'utf-8');
+                const entries = JSON.parse(raw);
+                for (const entry of entries) {
+                    if (!this.isExpired(entry)) {
+                        this.cache.set(entry.key, entry);
+                    }
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    save() {
+        const dir = path.dirname(this.filePath);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        const entries = Array.from(this.cache.values());
+        fs.writeFileSync(this.filePath, JSON.stringify(entries));
+    }
+    isExpired(entry) {
+        return Date.now() - entry.createdAt > entry.ttlMs;
+    }
+    /**
+     * Generate a cache key from messages and system prompt.
+     */
+    static makeKey(messages, systemPrompt) {
+        const payload = JSON.stringify({ systemPrompt, messages: messages.map(m => ({ role: m.role, content: m.content })) });
+        return crypto.createHash('sha256').update(payload).digest('hex').slice(0, 16);
+    }
+    /**
+     * Get a cached response. Returns null if not found or expired.
+     */
+    get(key) {
+        if (!this.config.enabled)
+            return null;
+        const entry = this.cache.get(key);
+        if (!entry || this.isExpired(entry)) {
+            if (entry) {
+                this.cache.delete(key);
+                this.stats.evictions++;
+            }
+            this.stats.misses++;
+            return null;
+        }
+        entry.hits++;
+        this.stats.hits++;
+        return entry.value;
+    }
+    /**
+     * Set a cached response.
+     */
+    set(key, value, ttlMs) {
+        if (!this.config.enabled)
+            return;
+        // Evict oldest if at capacity
+        if (this.cache.size >= this.config.maxEntries) {
+            let oldestKey = null;
+            let oldestTime = Infinity;
+            for (const [k, v] of this.cache) {
+                if (v.createdAt < oldestTime) {
+                    oldestTime = v.createdAt;
+                    oldestKey = k;
+                }
+            }
+            if (oldestKey) {
+                this.cache.delete(oldestKey);
+                this.stats.evictions++;
+            }
+        }
+        this.cache.set(key, {
+            key,
+            value,
+            createdAt: Date.now(),
+            ttlMs: ttlMs ?? this.config.ttlMs,
+            hits: 0,
+        });
+        this.save();
+    }
+    getStats() {
+        const total = this.stats.hits + this.stats.misses;
+        return {
+            ...this.stats,
+            size: this.cache.size,
+            hitRate: total > 0 ? `${((this.stats.hits / total) * 100).toFixed(1)}%` : '0%',
+        };
+    }
+    clear() {
+        this.cache.clear();
+        this.stats = { hits: 0, misses: 0, evictions: 0 };
+        this.save();
+    }
+}
+exports.LLMCache = LLMCache;
+//# sourceMappingURL=cache.js.map

package/dist/core/rate-limiter.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Rate Limiter - Per-user and per-provider rate limiting with queuing.
+ */
+interface RateLimitConfig {
+    maxRequests: number;
+    windowMs: number;
+}
+export declare class RateLimiter {
+    private userLimits;
+    private providerLimits;
+    private userConfig;
+    private providerConfig;
+    private maxQueueSize;
+    constructor(opts?: {
+        userLimit?: RateLimitConfig;
+        providerLimit?: RateLimitConfig;
+        maxQueueSize?: number;
+    });
+    /**
+     * Check if a request is allowed. If not, queues it with backpressure.
+     * Returns a promise that resolves when the request can proceed.
+     */
+    acquire(userId: string, provider: string): Promise<void>;
+    private checkLimit;
+    private processQueue;
+    /**
+     * Get current usage stats.
+     */
+    getUsage(userId?: string, provider?: string): {
+        user?: {
+            used: number;
+            limit: number;
+            windowMs: number;
+        };
+        provider?: {
+            used: number;
+            limit: number;
+            windowMs: number;
+        };
+    };
+    /**
+     * Reset all limits.
+     */
+    reset(): void;
+}
+export {};
+//# sourceMappingURL=rate-limiter.d.ts.map

package/dist/core/rate-limiter.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Rate Limiter - Per-user and per-provider rate limiting with queuing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimiter = void 0;
+class RateLimiter {
+    userLimits = new Map();
+    providerLimits = new Map();
+    userConfig;
+    providerConfig;
+    maxQueueSize;
+    constructor(opts) {
+        this.userConfig = opts?.userLimit ?? { maxRequests: 60, windowMs: 60_000 };
+        this.providerConfig = opts?.providerLimit ?? { maxRequests: 100, windowMs: 60_000 };
+        this.maxQueueSize = opts?.maxQueueSize ?? 50;
+    }
+    /**
+     * Check if a request is allowed. If not, queues it with backpressure.
+     * Returns a promise that resolves when the request can proceed.
+     */
+    async acquire(userId, provider) {
+        await this.checkLimit(userId, this.userLimits, this.userConfig, 'user');
+        await this.checkLimit(provider, this.providerLimits, this.providerConfig, 'provider');
+    }
+    async checkLimit(key, limits, config, type) {
+        let entry = limits.get(key);
+        if (!entry) {
+            entry = { timestamps: [], queue: [] };
+            limits.set(key, entry);
+        }
+        const now = Date.now();
+        // Prune old timestamps
+        entry.timestamps = entry.timestamps.filter(t => t > now - config.windowMs);
+        if (entry.timestamps.length < config.maxRequests) {
+            entry.timestamps.push(now);
+            return;
+        }
+        // Rate limited - queue with backpressure
+        if (entry.queue.length >= this.maxQueueSize) {
+            throw new Error(`Rate limit exceeded for ${type} "${key}" and queue is full (${this.maxQueueSize})`);
+        }
+        return new Promise((resolve, reject) => {
+            entry.queue.push({ resolve, reject });
+            // Set timeout to process queue when window expires
+            const oldestTs = entry.timestamps[0];
+            const waitMs = oldestTs + config.windowMs - now + 10;
+            setTimeout(() => {
+                this.processQueue(key, limits, config);
+            }, Math.max(waitMs, 100));
+        });
+    }
+    processQueue(key, limits, config) {
+        const entry = limits.get(key);
+        if (!entry || entry.queue.length === 0)
+            return;
+        const now = Date.now();
+        entry.timestamps = entry.timestamps.filter(t => t > now - config.windowMs);
+        while (entry.queue.length > 0 && entry.timestamps.length < config.maxRequests) {
+            entry.timestamps.push(now);
+            const item = entry.queue.shift();
+            item.resolve();
+        }
+    }
+    /**
+     * Get current usage stats.
+     */
+    getUsage(userId, provider) {
+        const now = Date.now();
+        const result = {};
+        if (userId) {
+            const entry = this.userLimits.get(userId);
+            const used = entry ? entry.timestamps.filter(t => t > now - this.userConfig.windowMs).length : 0;
+            result.user = { used, limit: this.userConfig.maxRequests, windowMs: this.userConfig.windowMs };
+        }
+        if (provider) {
+            const entry = this.providerLimits.get(provider);
+            const used = entry ? entry.timestamps.filter(t => t > now - this.providerConfig.windowMs).length : 0;
+            result.provider = { used, limit: this.providerConfig.maxRequests, windowMs: this.providerConfig.windowMs };
+        }
+        return result;
+    }
+    /**
+     * Reset all limits.
+     */
+    reset() {
+        this.userLimits.clear();
+        this.providerLimits.clear();
+    }
+}
+exports.RateLimiter = RateLimiter;
+//# sourceMappingURL=rate-limiter.js.map