@agenttrace-io/sdk 0.1.9

package/dist/storage.js

@@ -0,0 +1,1479 @@
+/**
+ * AgentTrace -- SQLite Storage Layer
+ * Local storage for agent traces with zero cloud dependency
+ */
+import Database from 'better-sqlite3';
+import { randomUUID, randomBytes, createHash } from 'node:crypto';
+import { statSync } from 'node:fs';
+export class TraceStorage {
+    db;
+    dbPath;
+    _droppedTraces = 0;
+    tenantId;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static _connections = new Map();
+    constructor(dbPath = './agenttrace.db', tenantId) {
+        this.dbPath = dbPath;
+        this.tenantId = tenantId || '';
+        const existing = TraceStorage._connections.get(dbPath);
+        if (existing) {
+            existing.refCount++;
+            this.db = existing.db;
+        }
+        else {
+            const db = new Database(dbPath);
+            db.pragma('journal_mode = WAL');
+            db.pragma('foreign_keys = ON');
+            this.db = db;
+            TraceStorage._connections.set(dbPath, { db, refCount: 1 });
+            this.initSchema();
+        }
+    }
+    initSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS runs (
+        id TEXT PRIMARY KEY,
+        tenant_id TEXT,
+        name TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'running',
+        trace_count INTEGER DEFAULT 0,
+        total_prompt_tokens INTEGER DEFAULT 0,
+        total_completion_tokens INTEGER DEFAULT 0,
+        total_tokens INTEGER DEFAULT 0,
+        total_tool_calls INTEGER DEFAULT 0,
+        total_latency_ms INTEGER DEFAULT 0,
+        total_cost_usd REAL DEFAULT 0,
+        error_count INTEGER DEFAULT 0,
+        started_at INTEGER NOT NULL,
+        completed_at INTEGER,
+        metadata TEXT DEFAULT '{}',
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS traces (
+        id TEXT PRIMARY KEY,
+        tenant_id TEXT,
+        run_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        status TEXT NOT NULL,
+        input TEXT,
+        output TEXT,
+        prompt_tokens INTEGER DEFAULT 0,
+        completion_tokens INTEGER DEFAULT 0,
+        total_tokens INTEGER DEFAULT 0,
+        model TEXT,
+        provider TEXT,
+        latency_ms INTEGER DEFAULT 0,
+        cost_usd REAL DEFAULT 0,
+        error TEXT,
+        metadata TEXT DEFAULT '{}',
+        parent_id TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        FOREIGN KEY (run_id) REFERENCES runs(id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS tool_calls (
+        id TEXT PRIMARY KEY,
+        trace_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        input TEXT,
+        output TEXT,
+        latency_ms INTEGER DEFAULT 0,
+        success INTEGER DEFAULT 1,
+        error TEXT,
+        timestamp INTEGER NOT NULL,
+        FOREIGN KEY (trace_id) REFERENCES traces(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_traces_run_id ON traces(run_id);
+      CREATE INDEX IF NOT EXISTS idx_traces_status ON traces(status);
+      CREATE INDEX IF NOT EXISTS idx_traces_created_at ON traces(created_at);
+      CREATE INDEX IF NOT EXISTS idx_traces_cost ON traces(cost_usd);
+      CREATE INDEX IF NOT EXISTS idx_traces_parent_id ON traces(parent_id);
+      CREATE INDEX IF NOT EXISTS idx_tool_calls_trace_id ON tool_calls(trace_id);
+      CREATE INDEX IF NOT EXISTS idx_tool_calls_name ON tool_calls(name);
+
+      CREATE TABLE IF NOT EXISTS scores (
+        id TEXT PRIMARY KEY,
+        trace_id TEXT NOT NULL REFERENCES traces(id),
+        name TEXT NOT NULL,
+        value REAL NOT NULL,
+        created_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_scores_trace_id ON scores(trace_id);
+      CREATE INDEX IF NOT EXISTS idx_scores_name ON scores(name);
+
+      CREATE TABLE IF NOT EXISTS alerts (
+        id TEXT PRIMARY KEY,
+        name TEXT UNIQUE NOT NULL,
+        config TEXT NOT NULL,
+        created_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS alert_history (
+        id TEXT PRIMARY KEY,
+        alert_name TEXT NOT NULL,
+        triggered_at INTEGER NOT NULL,
+        stats TEXT NOT NULL,
+        delivered INTEGER DEFAULT 0,
+        error TEXT,
+        created_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_alerts_name ON alerts(name);
+      CREATE INDEX IF NOT EXISTS idx_alert_history_alert_name ON alert_history(alert_name);
+      CREATE INDEX IF NOT EXISTS idx_alert_history_triggered_at ON alert_history(triggered_at);
+
+      CREATE TABLE IF NOT EXISTS trace_links (
+        id TEXT PRIMARY KEY,
+        source_trace_id TEXT NOT NULL,
+        target_trace_id TEXT NOT NULL,
+        relation TEXT NOT NULL DEFAULT 'related',
+        created_at INTEGER NOT NULL,
+        FOREIGN KEY (source_trace_id) REFERENCES traces(id) ON DELETE CASCADE,
+        FOREIGN KEY (target_trace_id) REFERENCES traces(id) ON DELETE CASCADE
+      );
+      CREATE INDEX IF NOT EXISTS idx_trace_links_source ON trace_links(source_trace_id);
+      CREATE INDEX IF NOT EXISTS idx_trace_links_target ON trace_links(target_trace_id);
+
+      CREATE TABLE IF NOT EXISTS agent_usage (
+        id TEXT PRIMARY KEY,
+        tenant_id TEXT,
+        agent_name TEXT NOT NULL,
+        agent_type TEXT,
+        session_id TEXT,
+        action TEXT NOT NULL,
+        target TEXT,
+        tokens_used INTEGER DEFAULT 0,
+        cost_usd REAL DEFAULT 0,
+        duration_ms INTEGER DEFAULT 0,
+        status TEXT DEFAULT 'success',
+        metadata TEXT DEFAULT '{}',
+        created_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_agent_usage_agent_name ON agent_usage(agent_name);
+      CREATE INDEX IF NOT EXISTS idx_agent_usage_session_id ON agent_usage(session_id);
+      CREATE INDEX IF NOT EXISTS idx_agent_usage_action ON agent_usage(action);
+      CREATE INDEX IF NOT EXISTS idx_agent_usage_status ON agent_usage(status);
+      CREATE INDEX IF NOT EXISTS idx_agent_usage_created_at ON agent_usage(created_at);
+
+      CREATE TABLE IF NOT EXISTS webhooks (
+        id TEXT PRIMARY KEY,
+        url TEXT NOT NULL,
+        secret TEXT,
+        events TEXT NOT NULL,
+        enabled INTEGER DEFAULT 1,
+        created_at INTEGER NOT NULL,
+        last_triggered_at INTEGER,
+        failure_count INTEGER DEFAULT 0
+      );
+      CREATE INDEX IF NOT EXISTS idx_webhooks_enabled ON webhooks(enabled);
+      CREATE INDEX IF NOT EXISTS idx_webhooks_created_at ON webhooks(created_at);
+
+      CREATE TABLE IF NOT EXISTS api_keys (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        key_hash TEXT NOT NULL UNIQUE,
+        key_preview TEXT NOT NULL,
+        permissions TEXT NOT NULL DEFAULT '["read","write"]',
+        created_at INTEGER NOT NULL,
+        last_used_at INTEGER,
+        enabled INTEGER DEFAULT 1
+      );
+      CREATE INDEX IF NOT EXISTS idx_api_keys_created_at ON api_keys(created_at);
+
+      CREATE TABLE IF NOT EXISTS projects (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        api_key TEXT NOT NULL UNIQUE,
+        created_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_projects_api_key ON projects(api_key);
+
+      CREATE TABLE IF NOT EXISTS settings (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS version (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS budgets (
+        agent_name TEXT PRIMARY KEY,
+        max_tokens_per_day INTEGER DEFAULT 0,
+        max_cost_per_day REAL DEFAULT 0,
+        created_at INTEGER NOT NULL
+      );
+    `);
+        // Migration tracking
+        const version = this.db
+            .prepare('SELECT value FROM version WHERE key = ?')
+            .get('schema_version');
+        if (!version) {
+            this.db.prepare('INSERT INTO version (key, value) VALUES (?, ?)').run('schema_version', '3');
+        }
+        // v2+ migration for multi-agent tracing (parent_id + trace_links)
+        const verRow = this.db
+            .prepare('SELECT value FROM version WHERE key = ?')
+            .get('schema_version');
+        const schemaVer = verRow ? parseInt(String(verRow.value), 10) : 0;
+        if (schemaVer < 2) {
+            try {
+                this.db.exec('ALTER TABLE traces ADD COLUMN parent_id TEXT');
+            }
+            catch (_) {
+                /* column may already exist (e.g. partial migration) */
+            }
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS trace_links (
+          id TEXT PRIMARY KEY,
+          source_trace_id TEXT NOT NULL,
+          target_trace_id TEXT NOT NULL,
+          relation TEXT NOT NULL DEFAULT 'related',
+          created_at INTEGER NOT NULL,
+          FOREIGN KEY (source_trace_id) REFERENCES traces(id) ON DELETE CASCADE,
+          FOREIGN KEY (target_trace_id) REFERENCES traces(id) ON DELETE CASCADE
+        );
+        CREATE INDEX IF NOT EXISTS idx_trace_links_source ON trace_links(source_trace_id);
+        CREATE INDEX IF NOT EXISTS idx_trace_links_target ON trace_links(target_trace_id);
+      `);
+            this.db
+                .prepare('INSERT OR REPLACE INTO version (key, value) VALUES (?, ?)')
+                .run('schema_version', '2');
+        }
+        // v3+ migration for multi-tenant (projects table + tenant_id on agent_usage)
+        if (schemaVer < 3) {
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS projects (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL,
+          api_key TEXT NOT NULL UNIQUE,
+          created_at INTEGER NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_projects_api_key ON projects(api_key);
+      `);
+            try {
+                this.db.exec('ALTER TABLE agent_usage ADD COLUMN tenant_id TEXT');
+            }
+            catch (_) {
+                /* column may already exist */
+            }
+            try {
+                this.db.exec('ALTER TABLE runs ADD COLUMN tenant_id TEXT');
+            }
+            catch (_) {
+                /* column may already exist */
+            }
+            try {
+                this.db.exec('ALTER TABLE traces ADD COLUMN tenant_id TEXT');
+            }
+            catch (_) {
+                /* column may already exist */
+            }
+            this.db
+                .prepare('INSERT OR REPLACE INTO version (key, value) VALUES (?, ?)')
+                .run('schema_version', '3');
+        }
+    }
+    // ---- Run operations ----
+    createRun(run) {
+        const now = Date.now();
+        const stmt = this.db.prepare(`
+      INSERT INTO runs (id, tenant_id, name, status, started_at, metadata, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(run.id, run.tenantId || null, run.name, 'running', run.startedAt, JSON.stringify(run.metadata || {}), now, now);
+        return this.getRun(run.id);
+    }
+    getRun(id) {
+        const row = this.db.prepare('SELECT * FROM runs WHERE id = ?').get(id);
+        if (!row)
+            return null;
+        return this.rowToRun(row);
+    }
+    getRuns(limit = 100) {
+        let sql = 'SELECT * FROM runs WHERE 1=1';
+        const params = [];
+        const tenantId = this.tenantId;
+        if (tenantId) {
+            sql += ' AND tenant_id = ?';
+            params.push(tenantId);
+        }
+        sql += ' ORDER BY started_at DESC LIMIT ?';
+        params.push(limit);
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map((r) => this.rowToRun(r));
+    }
+    completeRun(id, status) {
+        const now = Date.now();
+        this.db
+            .prepare(`
+      UPDATE runs SET status = ?, completed_at = ?, updated_at = ? WHERE id = ?
+    `)
+            .run(status, now, now, id);
+    }
+    updateRunStats(runId, tokens, toolCalls, latencyMs, costUsd) {
+        this.db
+            .prepare(`
+      UPDATE runs SET
+        total_prompt_tokens = total_prompt_tokens + ?,
+        total_completion_tokens = total_completion_tokens + ?,
+        total_tokens = total_tokens + ?,
+        total_tool_calls = total_tool_calls + ?,
+        total_latency_ms = total_latency_ms + ?,
+        total_cost_usd = total_cost_usd + ?,
+        trace_count = trace_count + 1,
+        updated_at = ?
+      WHERE id = ?
+    `)
+            .run(tokens.promptTokens, tokens.completionTokens, tokens.totalTokens, toolCalls, latencyMs, costUsd, Date.now(), runId);
+    }
+    // ---- Trace operations ----
+    createTrace(trace) {
+        this.db.transaction(() => {
+            const now = Date.now();
+            const stmt = this.db.prepare(`
+      INSERT INTO traces (id, tenant_id, run_id, name, status, input, output, prompt_tokens, completion_tokens, total_tokens, model, provider, latency_ms, cost_usd, error, metadata, parent_id, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+            stmt.run(trace.id, trace.tenantId || null, trace.runId, trace.name, trace.status, JSON.stringify(trace.input), JSON.stringify(trace.output), trace.tokens.promptTokens, trace.tokens.completionTokens, trace.tokens.totalTokens, trace.tokens.model || null, trace.tokens.provider || null, trace.latencyMs, trace.costUsd, trace.error || null, JSON.stringify(trace.metadata), trace.parentId || null, now, now);
+            // Insert tool calls
+            const toolStmt = this.db.prepare(`
+      INSERT INTO tool_calls (id, trace_id, name, input, output, latency_ms, success, error, timestamp)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+            for (const tc of trace.toolCalls) {
+                toolStmt.run(tc.id, trace.id, tc.name, JSON.stringify(tc.input), JSON.stringify(tc.output), tc.latencyMs, tc.success ? 1 : 0, tc.error || null, tc.timestamp);
+            }
+            // Update run stats
+            this.updateRunStats(trace.runId, trace.tokens, trace.toolCalls.length, trace.latencyMs, trace.costUsd);
+        })();
+        return this.getTrace(trace.id);
+    }
+    getTrace(id) {
+        const row = this.db.prepare('SELECT * FROM traces WHERE id = ?').get(id);
+        if (!row)
+            return null;
+        return this.rowToTrace(row);
+    }
+    getTraces(filter = {}) {
+        let sql = 'SELECT * FROM traces WHERE 1=1';
+        const params = [];
+        const tenantId = this.tenantId;
+        if (tenantId) {
+            sql += ' AND tenant_id = ?';
+            params.push(tenantId);
+        }
+        if (filter.runId) {
+            sql += ' AND run_id = ?';
+            params.push(filter.runId);
+        }
+        if (filter.status?.length) {
+            sql += ` AND status IN (${filter.status.map(() => '?').join(',')})`;
+            params.push(...filter.status);
+        }
+        if (filter.name) {
+            sql += ' AND name LIKE ?';
+            params.push(`%${filter.name}%`);
+        }
+        if (filter.fromDate) {
+            sql += ' AND created_at >= ?';
+            params.push(filter.fromDate);
+        }
+        if (filter.toDate) {
+            sql += ' AND created_at <= ?';
+            params.push(filter.toDate);
+        }
+        if (filter.minCost !== undefined) {
+            sql += ' AND cost_usd >= ?';
+            params.push(filter.minCost);
+        }
+        if (filter.maxCost !== undefined) {
+            sql += ' AND cost_usd <= ?';
+            params.push(filter.maxCost);
+        }
+        if (filter.minLatency !== undefined) {
+            sql += ' AND latency_ms >= ?';
+            params.push(filter.minLatency);
+        }
+        if (filter.maxLatency !== undefined) {
+            sql += ' AND latency_ms <= ?';
+            params.push(filter.maxLatency);
+        }
+        sql += ' ORDER BY created_at DESC';
+        if (filter.limit) {
+            sql += ' LIMIT ?';
+            params.push(filter.limit);
+        }
+        if (filter.offset) {
+            sql += ' OFFSET ?';
+            params.push(filter.offset);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map((r) => this.rowToTrace(r));
+    }
+    // ---- Score operations (for evaluation framework) ----
+    createScore(id, traceId, name, value) {
+        const now = Date.now();
+        this.db
+            .prepare(`
+      INSERT INTO scores (id, trace_id, name, value, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `)
+            .run(id, traceId, name, value, now);
+    }
+    getScores(traceId) {
+        let sql = 'SELECT * FROM scores';
+        const params = [];
+        if (traceId) {
+            sql += ' WHERE trace_id = ?';
+            params.push(traceId);
+        }
+        sql += ' ORDER BY created_at DESC';
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map((r) => {
+            const rec = r;
+            return {
+                id: rec.id,
+                traceId: rec.trace_id,
+                name: rec.name,
+                value: Number(rec.value),
+                createdAt: Number(rec.created_at),
+            };
+        });
+    }
+    // ---- Alert operations (v0.2 alerting & webhooks) ----
+    saveAlert(name, config) {
+        const now = Date.now();
+        const id = name;
+        this.db
+            .prepare(`
+      INSERT INTO alerts (id, name, config, created_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(name) DO UPDATE SET config = excluded.config
+    `)
+            .run(id, name, JSON.stringify(config), now);
+    }
+    getStoredAlerts() {
+        const rows = this.db
+            .prepare('SELECT * FROM alerts ORDER BY created_at DESC')
+            .all();
+        return rows.map((r) => {
+            const rec = r;
+            return {
+                name: rec.name,
+                config: JSON.parse(rec.config || '{}'),
+                createdAt: Number(rec.created_at),
+            };
+        });
+    }
+    insertAlertHistory(entry) {
+        const now = Date.now();
+        this.db
+            .prepare(`
+      INSERT INTO alert_history (id, alert_name, triggered_at, stats, delivered, error, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `)
+            .run(entry.id, entry.alertName, entry.triggeredAt, JSON.stringify(entry.stats || {}), entry.delivered ? 1 : 0, entry.error || null, now);
+    }
+    getAlertHistory() {
+        const rows = this.db
+            .prepare('SELECT * FROM alert_history ORDER BY triggered_at DESC')
+            .all();
+        return rows.map((r) => {
+            const rec = r;
+            return {
+                id: rec.id,
+                alertName: rec.alert_name,
+                triggeredAt: Number(rec.triggered_at),
+                stats: JSON.parse(rec.stats || '{}'),
+                delivered: rec.delivered === 1,
+                error: rec.error || undefined,
+            };
+        });
+    }
+    // ---- Multi-agent tracing (parent/child + links) v0.2 ----
+    setTraceParent(traceId, parentId) {
+        this.db
+            .prepare('UPDATE traces SET parent_id = ?, updated_at = ? WHERE id = ?')
+            .run(parentId, Date.now(), traceId);
+    }
+    getTraceParentId(traceId) {
+        const row = this.db
+            .prepare('SELECT parent_id FROM traces WHERE id = ?')
+            .get(traceId);
+        const rec = row;
+        return rec && rec.parent_id ? String(rec.parent_id) : null;
+    }
+    getChildTraceIds(parentId) {
+        const rows = this.db
+            .prepare('SELECT id FROM traces WHERE parent_id = ? ORDER BY created_at ASC')
+            .all(parentId);
+        return rows.map((r) => String(r.id));
+    }
+    getLinkedTraceIds(traceId) {
+        const rows = this.db
+            .prepare(`
+        SELECT DISTINCT target_trace_id AS id FROM trace_links WHERE source_trace_id = ? AND relation = 'related'
+        UNION
+        SELECT DISTINCT source_trace_id AS id FROM trace_links WHERE target_trace_id = ? AND relation = 'related'
+      `)
+            .all(traceId, traceId);
+        return rows
+            .map((r) => String(r.id))
+            .filter((id) => id !== traceId);
+    }
+    linkTraces(traceIds) {
+        if (!traceIds || traceIds.length < 2)
+            return;
+        const now = Date.now();
+        const stmt = this.db.prepare(`
+      INSERT OR IGNORE INTO trace_links (id, source_trace_id, target_trace_id, relation, created_at)
+      VALUES (?, ?, ?, 'related', ?)
+    `);
+        for (let i = 0; i < traceIds.length; i++) {
+            for (let j = i + 1; j < traceIds.length; j++) {
+                stmt.run(randomUUID(), traceIds[i], traceIds[j], now);
+            }
+        }
+    }
+    getTraceTree(traceId) {
+        // Walk up parent chain to find ultimate root (cycle safe)
+        let rootId = traceId;
+        const upSeen = new Set();
+        while (true) {
+            if (upSeen.has(rootId))
+                break;
+            upSeen.add(rootId);
+            const p = this.getTraceParentId(rootId);
+            if (!p)
+                break;
+            rootId = p;
+        }
+        const visited = new Set();
+        const build = (id) => {
+            if (visited.has(id))
+                return null;
+            visited.add(id);
+            const trace = this.getTrace(id);
+            if (!trace)
+                return null;
+            const childIdSet = new Set();
+            for (const c of this.getChildTraceIds(id))
+                childIdSet.add(c);
+            for (const l of this.getLinkedTraceIds(id))
+                childIdSet.add(l);
+            const children = [];
+            // sort for deterministic tree order
+            const sortedChildren = Array.from(childIdSet).sort();
+            for (const cid of sortedChildren) {
+                const node = build(cid);
+                if (node)
+                    children.push(node);
+            }
+            return { trace, children };
+        };
+        const rootNode = build(rootId);
+        if (rootNode)
+            return rootNode;
+        // fallback for the requested id itself
+        const t = this.getTrace(traceId);
+        if (!t) {
+            throw new Error(`Trace ${traceId} not found`);
+        }
+        return { trace: t, children: [] };
+    }
+    // ---- Agent usage tracking ----
+    recordAgentUsage(params) {
+        this.db
+            .prepare(`
+      INSERT INTO agent_usage (id, tenant_id, agent_name, agent_type, session_id, action, target, tokens_used, cost_usd, duration_ms, status, metadata, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `)
+            .run(params.id, params.tenantId || null, params.agentName, params.agentType || null, params.sessionId || null, params.action, params.target || null, params.tokensUsed ?? 0, params.costUsd ?? 0, params.durationMs ?? 0, params.status || 'success', JSON.stringify(params.metadata || {}), params.createdAt || Date.now());
+    }
+    getAgentUsage(filter = {}, tenantId) {
+        let sql = 'SELECT * FROM agent_usage WHERE 1=1';
+        const params = [];
+        const effTenant = tenantId || this.tenantId;
+        if (effTenant) {
+            sql += ' AND tenant_id = ?';
+            params.push(effTenant);
+        }
+        if (filter.agentName) {
+            sql += ' AND agent_name = ?';
+            params.push(filter.agentName);
+        }
+        if (filter.agentType) {
+            sql += ' AND agent_type = ?';
+            params.push(filter.agentType);
+        }
+        if (filter.action) {
+            sql += ' AND action = ?';
+            params.push(filter.action);
+        }
+        if (filter.status) {
+            if (Array.isArray(filter.status)) {
+                sql += ` AND status IN (${filter.status.map(() => '?').join(',')})`;
+                params.push(...filter.status);
+            }
+            else {
+                sql += ' AND status = ?';
+                params.push(filter.status);
+            }
+        }
+        if (filter.fromDate) {
+            sql += ' AND created_at >= ?';
+            params.push(filter.fromDate);
+        }
+        if (filter.toDate) {
+            sql += ' AND created_at <= ?';
+            params.push(filter.toDate);
+        }
+        sql += ' ORDER BY created_at DESC';
+        if (filter.limit) {
+            sql += ' LIMIT ?';
+            params.push(filter.limit);
+        }
+        if (filter.offset) {
+            sql += ' OFFSET ?';
+            params.push(filter.offset);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map((r) => this.rowToAgentUsage(r));
+    }
+    getUsageStats(agentName, fromDate, toDate, tenantId) {
+        const whereParts = [];
+        const params = [];
+        const effTenant = tenantId || this.tenantId;
+        if (effTenant) {
+            whereParts.push('tenant_id = ?');
+            params.push(effTenant);
+        }
+        if (agentName) {
+            whereParts.push('agent_name = ?');
+            params.push(agentName);
+        }
+        if (fromDate) {
+            whereParts.push('created_at >= ?');
+            params.push(fromDate);
+        }
+        if (toDate) {
+            whereParts.push('created_at <= ?');
+            params.push(toDate);
+        }
+        const where = whereParts.length ? ` WHERE ${whereParts.join(' AND ')}` : '';
+        const totalActionsRow = this.db
+            .prepare(`SELECT COUNT(*) as c FROM agent_usage${where}`)
+            .get(...params);
+        const totalActions = totalActionsRow ? totalActionsRow.c : 0;
+        const totalAgentsRow = this.db
+            .prepare(`SELECT COUNT(DISTINCT agent_name) as c FROM agent_usage${where}`)
+            .get(...params);
+        const totalAgents = totalAgentsRow ? totalAgentsRow.c : 0;
+        const totals = this.db
+            .prepare(`SELECT 
+          COALESCE(SUM(tokens_used), 0) as tokens,
+          COALESCE(SUM(cost_usd), 0) as cost,
+          COALESCE(AVG(duration_ms), 0) as avgDur
+         FROM agent_usage${where}`)
+            .get(...params);
+        const totalTokens = totals ? Number(totals.tokens) : 0;
+        const totalCostUsd = totals ? Number(totals.cost) : 0;
+        const avgDurationMs = totals ? Number(totals.avgDur) : 0;
+        const byTypeRows = this.db
+            .prepare(`SELECT action, COUNT(*) as count FROM agent_usage${where} GROUP BY action ORDER BY count DESC`)
+            .all(...params);
+        const actionsByType = {};
+        for (const row of byTypeRows) {
+            const rec = row;
+            actionsByType[String(rec.action)] = Number(rec.count);
+        }
+        const topRows = this.db
+            .prepare(`SELECT 
+          agent_name,
+          COUNT(*) as actions,
+          COALESCE(SUM(tokens_used), 0) as tokens,
+          COALESCE(SUM(cost_usd), 0) as cost
+         FROM agent_usage${where} 
+         GROUP BY agent_name 
+         ORDER BY actions DESC, cost DESC 
+         LIMIT 10`)
+            .all(...params);
+        const topAgents = topRows.map((r) => {
+            const rec = r;
+            return {
+                agentName: String(rec.agent_name),
+                actions: Number(rec.actions),
+                tokens: Number(rec.tokens),
+                costUsd: Number(rec.cost),
+            };
+        });
+        return {
+            totalAgents,
+            totalActions,
+            totalTokens,
+            totalCostUsd,
+            avgDurationMs,
+            actionsByType,
+            topAgents,
+        };
+    }
+    getActiveAgents() {
+        const rows = this.db
+            .prepare(`
+      SELECT agent_name, MAX(created_at) as last_ts, COUNT(*) as total
+      FROM agent_usage
+      GROUP BY agent_name
+      ORDER BY last_ts DESC
+    `)
+            .all();
+        return rows.map((r) => {
+            const rec = r;
+            const lastTs = Number(rec.last_ts) || Date.now();
+            return {
+                agentName: String(rec.agent_name),
+                lastActive: new Date(lastTs).toISOString(),
+                totalActions: Number(rec.total),
+            };
+        });
+    }
+    // ---- Agent usage query helpers for CLI (who / sessions / cost) ----
+    getAgentWho(filter = {}) {
+        const f = {};
+        if (filter.agentType)
+            f.agentType = filter.agentType;
+        if (filter.activeOnly) {
+            f.fromDate = Date.now() - 30 * 60 * 1000;
+        }
+        const recs = this.getAgentUsage({ ...f, limit: 20000 });
+        const map = new Map();
+        for (const r of recs) {
+            let g = map.get(r.agentName);
+            if (!g) {
+                g = {
+                    type: r.agentType,
+                    lastAction: r.action,
+                    lastTs: r.createdAt,
+                    actions: 0,
+                    tokens: 0,
+                    cost: 0,
+                };
+                map.set(r.agentName, g);
+            }
+            if (r.agentType && !g.type)
+                g.type = r.agentType;
+            if (r.createdAt >= g.lastTs) {
+                g.lastTs = r.createdAt;
+                g.lastAction = r.action;
+                if (r.sessionId)
+                    g.lastSession = r.sessionId;
+            }
+            g.actions += 1;
+            g.tokens += r.tokensUsed || 0;
+            g.cost += r.costUsd || 0;
+        }
+        const list = Array.from(map.entries()).map(([name, g]) => ({
+            agentName: name,
+            agentType: g.type,
+            sessionId: g.lastSession,
+            lastAction: g.lastAction,
+            actions: g.actions,
+            tokens: g.tokens,
+            costUsd: g.cost,
+            lastActive: g.lastTs,
+        }));
+        list.sort((a, b) => b.lastActive - a.lastActive);
+        const lim = filter.limit && filter.limit > 0 ? filter.limit : 100;
+        return list.slice(0, lim).map(({ lastActive: _lastActive, ...rest }) => rest);
+    }
+    getAgentSessions(filter = {}) {
+        const f = {};
+        if (filter.agentName)
+            f.agentName = filter.agentName;
+        if (filter.activeOnly) {
+            f.fromDate = Date.now() - 30 * 60 * 1000;
+        }
+        const recs = this.getAgentUsage({ ...f, limit: 20000 });
+        const groups = new Map();
+        for (const r of recs) {
+            const sid = r.sessionId || '';
+            const key = `${r.agentName}::${sid}`;
+            let g = groups.get(key);
+            if (!g) {
+                g = {
+                    agentName: r.agentName,
+                    ts: [],
+                    actions: 0,
+                    tokens: 0,
+                    cost: 0,
+                    statuses: [],
+                    lastStatus: r.status,
+                    lastTs: r.createdAt,
+                };
+                groups.set(key, g);
+            }
+            g.ts.push(r.createdAt);
+            g.actions += 1;
+            g.tokens += r.tokensUsed || 0;
+            g.cost += r.costUsd || 0;
+            g.statuses.push(r.status);
+            if (r.createdAt >= g.lastTs) {
+                g.lastTs = r.createdAt;
+                g.lastStatus = r.status;
+            }
+        }
+        let list = Array.from(groups.entries()).map(([key, g]) => {
+            const sorted = [...g.ts].sort((a, b) => a - b);
+            const startedAt = sorted[0] ?? g.lastTs;
+            const last = sorted[sorted.length - 1] ?? g.lastTs;
+            const dur = Math.max(0, last - startedAt);
+            // session status: use last action's status, or 'failure' if any bad
+            let status = g.lastStatus;
+            if (g.statuses.some((s) => s === 'failure' || s === 'timeout')) {
+                status = g.statuses.includes('failure') ? 'failure' : 'timeout';
+            }
+            const sid = key.split('::')[1] || 'n/a';
+            return {
+                sessionId: sid,
+                agentName: g.agentName,
+                startedAt,
+                durationMs: dur,
+                actions: g.actions,
+                tokens: g.tokens,
+                costUsd: g.cost,
+                status,
+            };
+        });
+        if (filter.activeOnly) {
+            const cutoff = Date.now() - 30 * 60 * 1000;
+            list = list.filter((s) => s.startedAt + s.durationMs >= cutoff || s.startedAt >= cutoff);
+        }
+        list.sort((a, b) => b.startedAt - a.startedAt);
+        const lim = filter.limit && filter.limit > 0 ? filter.limit : 100;
+        return list.slice(0, lim);
+    }
+    getAgentCostSummary(filter = {}) {
+        const recs = this.getAgentUsage({
+            agentName: filter.agentName,
+            fromDate: filter.fromDate,
+            toDate: filter.toDate,
+            limit: 100000,
+        });
+        let totalCostUsd = 0;
+        const costByAgent = {};
+        const costByModel = {};
+        for (const r of recs) {
+            const c = r.costUsd || 0;
+            totalCostUsd += c;
+            costByAgent[r.agentName] = (costByAgent[r.agentName] || 0) + c;
+            const meta = r.metadata || {};
+            const model = typeof meta.model === 'string'
+                ? meta.model
+                : 'unknown';
+            costByModel[model] = (costByModel[model] || 0) + c;
+        }
+        return { totalCostUsd, costByAgent, costByModel };
+    }
+    // ---- API Key management (stored hashed with SHA-256) ----
+    // ---- Stats ----
+    getStats(tenantId) {
+        const where = tenantId ? ' WHERE tenant_id = ?' : '';
+        const traceWhere = tenantId ? ' WHERE tenant_id = ?' : '';
+        const params = tenantId ? [tenantId] : [];
+        const totalRuns = this.db
+            .prepare('SELECT COUNT(*) as c FROM runs' + where)
+            .get(...params);
+        const totalTraces = this.db
+            .prepare('SELECT COUNT(*) as c FROM traces' + traceWhere)
+            .get(...params);
+        const successCount = this.db
+            .prepare('SELECT COUNT(*) as c FROM traces' +
+            traceWhere +
+            (tenantId ? ' AND' : ' WHERE') +
+            " status = 'success'")
+            .get(...params);
+        const avgLatency = this.db
+            .prepare('SELECT AVG(latency_ms) as v FROM traces' + traceWhere)
+            .get(...params);
+        const totalCost = this.db
+            .prepare('SELECT SUM(cost_usd) as v FROM traces' + traceWhere)
+            .get(...params);
+        const totalTokens = this.db
+            .prepare('SELECT SUM(total_tokens) as v FROM traces' + traceWhere)
+            .get(...params);
+        const topTools = this.db
+            .prepare(`
+      SELECT tc.name, COUNT(*) as count, AVG(tc.latency_ms) as avgLatencyMs
+      FROM tool_calls tc
+      INNER JOIN traces t ON tc.trace_id = t.id${tenantId ? ' WHERE t.tenant_id = ?' : ''}
+      GROUP BY tc.name ORDER BY count DESC LIMIT 10
+    `)
+            .all(...(tenantId ? [tenantId] : []));
+        const topToolsMapped = topTools.map((t) => {
+            const rec = t;
+            return {
+                name: rec.name,
+                count: Number(rec.count),
+                avgLatencyMs: Number(rec.avgLatencyMs),
+            };
+        });
+        const topErrors = this.db
+            .prepare(`
+      SELECT error, COUNT(*) as count FROM traces
+      WHERE error IS NOT NULL AND error != ''${tenantId ? ' AND tenant_id = ?' : ''}
+      GROUP BY error ORDER BY count DESC LIMIT 10
+    `)
+            .all(...(tenantId ? [tenantId] : []));
+        const topErrorsMapped = topErrors.map((e) => {
+            const rec = e;
+            return { error: rec.error, count: Number(rec.count) };
+        });
+        const costByModelRows = this.db
+            .prepare(`
+      SELECT COALESCE(model, 'unknown') as model, SUM(cost_usd) as cost
+      FROM traces${traceWhere} GROUP BY model
+    `)
+            .all(...params);
+        const costByModel = {};
+        for (const r of costByModelRows) {
+            const rec = r;
+            costByModel[rec.model] = Number(rec.cost) || 0;
+        }
+        return {
+            totalRuns: totalRuns.c,
+            totalTraces: totalTraces.c,
+            successRate: totalTraces.c > 0 ? successCount.c / totalTraces.c : 0,
+            avgLatencyMs: avgLatency.v || 0,
+            totalCostUsd: totalCost.v || 0,
+            costByModel,
+            totalTokens: totalTokens.v || 0,
+            avgTokensPerTrace: totalTraces.c > 0 ? totalTokens.v / totalTraces.c : 0,
+            topTools: topToolsMapped,
+            topErrors: topErrorsMapped,
+            droppedTraces: this._droppedTraces || 0,
+        };
+    }
+    getCostBreakdown(runId, tenantId) {
+        const whereParts = [];
+        const params = [];
+        if (runId) {
+            whereParts.push('run_id = ?');
+            params.push(runId);
+        }
+        if (tenantId) {
+            whereParts.push('tenant_id = ?');
+            params.push(tenantId);
+        }
+        const where = whereParts.length ? ' WHERE ' + whereParts.join(' AND ') : '';
+        const totalCost = this.db
+            .prepare(`SELECT SUM(cost_usd) as v FROM traces${where}`)
+            .get(...params);
+        const costByModelRows = this.db
+            .prepare(`SELECT COALESCE(model, 'unknown') as model, SUM(cost_usd) as cost FROM traces${where} GROUP BY model`)
+            .all(...params);
+        const costByModel = {};
+        for (const r of costByModelRows) {
+            const rec = r;
+            costByModel[rec.model] = Number(rec.cost) || 0;
+        }
+        const byDayRows = this.db
+            .prepare(`SELECT strftime('%Y-%m-%d', created_at / 1000, 'unixepoch') as day, SUM(cost_usd) as cost FROM traces${where} GROUP BY day ORDER BY day`)
+            .all(...params);
+        const costByDay = {};
+        for (const r of byDayRows) {
+            const rec = r;
+            if (rec.day) {
+                costByDay[rec.day] = Number(rec.cost) || 0;
+            }
+        }
+        return {
+            totalCostUsd: totalCost.v || 0,
+            costByModel,
+            costByDay,
+        };
+    }
+    // ---- Cleanup ----
+    cleanup(maxTraces = 10000) {
+        let deleted = 0;
+        const txn = this.db.transaction(() => {
+            const count = this.db.prepare('SELECT COUNT(*) as c FROM traces').get();
+            if (count.c <= maxTraces)
+                return;
+            deleted = count.c - maxTraces;
+            this.db
+                .prepare(`
+      DELETE FROM traces WHERE id IN (
+        SELECT id FROM traces ORDER BY created_at ASC LIMIT ?
+      )
+    `)
+                .run(deleted);
+        });
+        txn();
+        return deleted;
+    }
+    cleanupOldTraces(before) {
+        if (!before || before <= 0)
+            return 0;
+        // Clean dependents that do not have ON DELETE CASCADE (scores, trace_links)
+        this.db
+            .prepare(`DELETE FROM scores WHERE trace_id IN (SELECT id FROM traces WHERE created_at < ?)`)
+            .run(before);
+        this.db
+            .prepare(`
+        DELETE FROM trace_links
+        WHERE source_trace_id IN (SELECT id FROM traces WHERE created_at < ?)
+           OR target_trace_id IN (SELECT id FROM traces WHERE created_at < ?)
+      `)
+            .run(before, before);
+        const res = this.db.prepare('DELETE FROM traces WHERE created_at < ?').run(before);
+        return res.changes ?? 0;
+    }
+    cleanupOldRuns(before) {
+        if (!before || before <= 0)
+            return 0;
+        // CASCADE will delete associated traces + their tool_calls
+        const res = this.db.prepare('DELETE FROM runs WHERE started_at < ?').run(before);
+        return res.changes ?? 0;
+    }
+    cleanupOldAgentUsage(before) {
+        if (!before || before <= 0)
+            return 0;
+        const res = this.db.prepare('DELETE FROM agent_usage WHERE created_at < ?').run(before);
+        return res.changes ?? 0;
+    }
+    // ---- Retention policy (persisted) ----
+    getSetting(key) {
+        const row = this.db.prepare('SELECT value FROM settings WHERE key = ?').get(key);
+        return row && typeof row.value === 'string' ? row.value : null;
+    }
+    setSetting(key, value) {
+        this.db.prepare('INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)').run(key, value);
+    }
+    getRetentionPolicy() {
+        const rdStr = this.getSetting('retentionDays');
+        const ciStr = this.getSetting('cleanupIntervalHours');
+        return {
+            retentionDays: rdStr !== null ? Math.max(0, parseInt(rdStr, 10) || 0) : 30,
+            cleanupIntervalHours: ciStr !== null ? Math.max(1, parseInt(ciStr, 10) || 24) : 24,
+        };
+    }
+    setRetentionPolicy(retentionDays, cleanupIntervalHours) {
+        const days = Math.max(0, Math.floor(Number(retentionDays) || 0));
+        this.setSetting('retentionDays', String(days));
+        if (cleanupIntervalHours !== undefined) {
+            const hrs = Math.max(1, Math.floor(Number(cleanupIntervalHours) || 24));
+            this.setSetting('cleanupIntervalHours', String(hrs));
+        }
+    }
+    // ---- Health / Integrity ----
+    getHealthInfo() {
+        const traceCountRow = this.db.prepare('SELECT COUNT(*) as c FROM traces').get();
+        const traceCount = traceCountRow ? traceCountRow.c : 0;
+        const dbSize = this.getDbSize();
+        const integrity = this.checkIntegrity();
+        return {
+            dbPath: this.dbPath,
+            traceCount,
+            dbSize,
+            integrity,
+        };
+    }
+    getDbSize() {
+        if (!this.dbPath || this.dbPath === ':memory:') {
+            return 0;
+        }
+        try {
+            return statSync(this.dbPath).size;
+        }
+        catch (_) {
+            return 0;
+        }
+    }
+    checkIntegrity() {
+        const required = [
+            'runs',
+            'traces',
+            'tool_calls',
+            'scores',
+            'alerts',
+            'alert_history',
+            'trace_links',
+            'agent_usage',
+            'webhooks',
+            'api_keys',
+            'version',
+        ];
+        const existingRows = this.db
+            .prepare("SELECT name FROM sqlite_master WHERE type='table'")
+            .all();
+        const existing = new Set(existingRows.map((r) => r.name));
+        const missing = required.filter((t) => !existing.has(t));
+        const tablesExist = missing.length === 0;
+        // PRAGMA integrity_check
+        let pragmaMsg = '';
+        try {
+            const res = this.db.pragma('integrity_check');
+            const ok = Array.isArray(res) && res.length === 1 && res[0]?.integrity_check === 'ok';
+            if (!ok) {
+                pragmaMsg = res && res[0] ? String(res[0].integrity_check) : 'failed';
+            }
+        }
+        catch (e) {
+            pragmaMsg = String(e);
+        }
+        let orphanCount = 0;
+        const orphanDetails = [];
+        if (tablesExist) {
+            const ot = this.db
+                .prepare('SELECT COUNT(*) as c FROM traces WHERE run_id NOT IN (SELECT id FROM runs)')
+                .get();
+            if (ot && ot.c > 0) {
+                orphanCount += ot.c;
+                orphanDetails.push(`traces without run: ${ot.c}`);
+            }
+            const otc = this.db
+                .prepare('SELECT COUNT(*) as c FROM tool_calls WHERE trace_id NOT IN (SELECT id FROM traces)')
+                .get();
+            if (otc && otc.c > 0) {
+                orphanCount += otc.c;
+                orphanDetails.push(`tool_calls without trace: ${otc.c}`);
+            }
+            const osc = this.db
+                .prepare('SELECT COUNT(*) as c FROM scores WHERE trace_id NOT IN (SELECT id FROM traces)')
+                .get();
+            if (osc && osc.c > 0) {
+                orphanCount += osc.c;
+                orphanDetails.push(`scores without trace: ${osc.c}`);
+            }
+            const ol = this.db
+                .prepare(`
+          SELECT COUNT(*) as c FROM trace_links
+          WHERE source_trace_id NOT IN (SELECT id FROM traces)
+             OR target_trace_id NOT IN (SELECT id FROM traces)
+        `)
+                .get();
+            if (ol && ol.c > 0) {
+                orphanCount += ol.c;
+                orphanDetails.push(`trace_links orphaned: ${ol.c}`);
+            }
+        }
+        const noOrphans = orphanCount === 0;
+        const detailsParts = [];
+        if (pragmaMsg)
+            detailsParts.push(`pragma: ${pragmaMsg}`);
+        if (orphanDetails.length)
+            detailsParts.push(...orphanDetails);
+        const details = detailsParts.length ? detailsParts.join('; ') : undefined;
+        return {
+            tablesExist,
+            noOrphans,
+            details,
+        };
+    }
+    // ---- Helpers ----
+    rowToRun(row) {
+        const r = row;
+        return {
+            id: r.id,
+            tenantId: r.tenant_id || undefined,
+            name: r.name,
+            status: r.status,
+            traceCount: Number(r.trace_count),
+            totalTokens: {
+                promptTokens: Number(r.total_prompt_tokens),
+                completionTokens: Number(r.total_completion_tokens),
+                totalTokens: Number(r.total_tokens),
+            },
+            totalToolCalls: Number(r.total_tool_calls),
+            totalLatencyMs: Number(r.total_latency_ms),
+            totalCostUsd: Number(r.total_cost_usd),
+            errorCount: Number(r.error_count),
+            startedAt: Number(r.started_at),
+            completedAt: r.completed_at != null ? Number(r.completed_at) : undefined,
+            metadata: JSON.parse(r.metadata || '{}'),
+        };
+    }
+    safeJsonParse(val) {
+        if (val == null || val === '' || val === 'null')
+            return null;
+        try {
+            return JSON.parse(val);
+        }
+        catch {
+            return val;
+        }
+    }
+    rowToTrace(row) {
+        const r = row;
+        const toolCallsRows = this.db
+            .prepare('SELECT * FROM tool_calls WHERE trace_id = ? ORDER BY timestamp')
+            .all(r.id);
+        return {
+            id: r.id,
+            runId: r.run_id,
+            name: r.name,
+            status: r.status,
+            input: this.safeJsonParse(r.input),
+            output: this.safeJsonParse(r.output),
+            tokens: {
+                promptTokens: Number(r.prompt_tokens),
+                completionTokens: Number(r.completion_tokens),
+                totalTokens: Number(r.total_tokens),
+                model: r.model,
+                provider: r.provider,
+            },
+            toolCalls: toolCallsRows.map((tc) => {
+                const t = tc;
+                return {
+                    id: t.id,
+                    name: t.name,
+                    input: this.safeJsonParse(t.input),
+                    output: this.safeJsonParse(t.output),
+                    latencyMs: Number(t.latency_ms),
+                    success: t.success === 1,
+                    error: t.error,
+                    timestamp: Number(t.timestamp),
+                };
+            }),
+            latencyMs: Number(r.latency_ms),
+            costUsd: Number(r.cost_usd),
+            error: r.error,
+            metadata: JSON.parse(r.metadata || '{}'),
+            parentId: r.parent_id || undefined,
+            tenantId: r.tenant_id || undefined,
+            createdAt: Number(r.created_at),
+            updatedAt: Number(r.updated_at),
+        };
+    }
+    rowToAgentUsage(row) {
+        const r = row;
+        return {
+            id: r.id,
+            tenantId: r.tenant_id || undefined,
+            agentName: r.agent_name,
+            agentType: r.agent_type || undefined,
+            sessionId: r.session_id || undefined,
+            action: r.action,
+            target: r.target || undefined,
+            tokensUsed: Number(r.tokens_used) || 0,
+            costUsd: Number(r.cost_usd) || 0,
+            durationMs: Number(r.duration_ms) || 0,
+            status: r.status || 'success',
+            metadata: JSON.parse(r.metadata || '{}'),
+            createdAt: Number(r.created_at),
+        };
+    }
+    // ── Webhook Management ──────────────────────────────────────────
+    registerWebhook(url, events, secret) {
+        const id = randomUUID();
+        this.db
+            .prepare(`
+      INSERT INTO webhooks (id, url, secret, events, enabled, created_at)
+      VALUES (?, ?, ?, ?, 1, ?)
+    `)
+            .run(id, url, secret || null, JSON.stringify(events), Date.now());
+        return id;
+    }
+    getWebhooks() {
+        const rows = this.db
+            .prepare(`
+      SELECT id, url, secret, events, enabled, created_at, last_triggered_at, failure_count
+      FROM webhooks ORDER BY created_at DESC
+    `)
+            .all();
+        return rows.map((r) => ({
+            id: r.id,
+            url: r.url,
+            secret: r.secret || undefined,
+            events: JSON.parse(r.events || '[]'),
+            enabled: !!r.enabled,
+            createdAt: Number(r.created_at),
+            lastTriggeredAt: r.last_triggered_at || undefined,
+            failureCount: Number(r.failure_count) || 0,
+        }));
+    }
+    deleteWebhook(id) {
+        this.db.prepare(`DELETE FROM webhooks WHERE id = ?`).run(id);
+    }
+    updateWebhookLastTriggered(id) {
+        this.db
+            .prepare(`
+      UPDATE webhooks SET last_triggered_at = ? WHERE id = ?
+    `)
+            .run(Date.now(), id);
+    }
+    incrementWebhookFailures(id) {
+        this.db
+            .prepare(`
+      UPDATE webhooks SET failure_count = failure_count + 1 WHERE id = ?
+    `)
+            .run(id);
+    }
+    resetWebhookFailures(id) {
+        this.db
+            .prepare(`
+      UPDATE webhooks SET failure_count = 0 WHERE id = ?
+    `)
+            .run(id);
+    }
+    getEnabledWebhooksForEvent(event) {
+        const rows = this.db
+            .prepare(`
+      SELECT id, url, secret, events, enabled, created_at, last_triggered_at, failure_count
+      FROM webhooks WHERE enabled = 1
+    `)
+            .all();
+        return rows
+            .map((r) => ({
+            id: r.id,
+            url: r.url,
+            secret: r.secret || undefined,
+            events: JSON.parse(r.events || '[]'),
+            enabled: !!r.enabled,
+            createdAt: Number(r.created_at),
+            lastTriggeredAt: r.last_triggered_at || undefined,
+            failureCount: Number(r.failure_count) || 0,
+        }))
+            .filter((w) => w.events.includes(event));
+    }
+    // ── API Key Management ──────────────────────────────────────────
+    createApiKey(name, permissions = ['read', 'write'], key) {
+        const id = randomUUID();
+        const secretKey = key || randomBytes(32).toString('hex');
+        const keyHash = createHash('sha256').update(secretKey).digest('hex');
+        const now = Date.now();
+        const keyPreview = secretKey.slice(0, 8) + '****';
+        this.db
+            .prepare(`
+      INSERT INTO api_keys (id, name, key_hash, key_preview, permissions, created_at, enabled)
+      VALUES (?, ?, ?, ?, ?, ?, 1)
+    `)
+            .run(id, name, keyHash, keyPreview, JSON.stringify(permissions), now);
+        return { id, name, key: secretKey, preview: keyPreview, createdAt: now };
+    }
+    getApiKeys() {
+        const rows = this.db
+            .prepare(`
+      SELECT id, name, created_at, last_used_at, enabled
+      FROM api_keys ORDER BY created_at DESC
+    `)
+            .all();
+        return rows.map((r) => ({
+            id: r.id,
+            name: r.name,
+            createdAt: Number(r.created_at),
+            lastUsedAt: r.last_used_at || null,
+            enabled: !!r.enabled,
+        }));
+    }
+    validateApiKey(key) {
+        const keyHash = createHash('sha256').update(key).digest('hex');
+        const row = this.db
+            .prepare(`
+      SELECT id, permissions, enabled FROM api_keys WHERE key_hash = ?
+    `)
+            .get(keyHash);
+        if (!row || !row.enabled)
+            return { valid: false, permissions: [] };
+        this.db
+            .prepare(`UPDATE api_keys SET last_used_at = ? WHERE key_hash = ?`)
+            .run(Date.now(), keyHash);
+        return { valid: true, permissions: JSON.parse(row.permissions || '[]') };
+    }
+    revokeApiKey(id) {
+        this.db.prepare(`DELETE FROM api_keys WHERE id = ?`).run(id);
+    }
+    // ── Storage Stats ───────────────────────────────────────────────
+    getStorageStats() {
+        let totalSizeBytes = 0;
+        try {
+            totalSizeBytes = statSync(this.dbPath).size;
+        }
+        catch (_) {
+            // DB file may be :memory: or not yet created
+        }
+        const traceCount = this.db.prepare(`SELECT COUNT(*) as c FROM traces`).get();
+        const runCount = this.db.prepare(`SELECT COUNT(*) as c FROM runs`).get();
+        const oldest = this.db.prepare(`SELECT MIN(created_at) as v FROM traces`).get();
+        const newest = this.db.prepare(`SELECT MAX(created_at) as v FROM traces`).get();
+        return {
+            totalSizeBytes,
+            traceCount: traceCount.c,
+            runCount: runCount.c,
+            oldestTrace: oldest.v,
+            newestTrace: newest.v,
+        };
+    }
+    // ── Project / Multi-tenant CRUD ─────────────────────────────────
+    createProject(name) {
+        const id = randomUUID();
+        const apiKey = `at_${randomBytes(24).toString('hex')}`;
+        const now = Date.now();
+        this.db
+            .prepare('INSERT INTO projects (id, name, api_key, created_at) VALUES (?, ?, ?, ?)')
+            .run(id, name, apiKey, now);
+        return { id, name, apiKey, createdAt: now };
+    }
+    getProject(apiKey) {
+        const row = this.db
+            .prepare('SELECT id, name, api_key, created_at FROM projects WHERE api_key = ?')
+            .get(apiKey);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            name: row.name,
+            apiKey: row.api_key,
+            createdAt: row.created_at,
+        };
+    }
+    getProjectById(id) {
+        const row = this.db
+            .prepare('SELECT id, name, api_key, created_at FROM projects WHERE id = ?')
+            .get(id);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            name: row.name,
+            apiKey: row.api_key,
+            createdAt: row.created_at,
+        };
+    }
+    listProjects() {
+        const rows = this.db
+            .prepare('SELECT id, name, api_key, created_at FROM projects ORDER BY created_at DESC')
+            .all();
+        return rows.map((r) => ({
+            id: r.id,
+            name: r.name,
+            apiKey: r.api_key,
+            createdAt: r.created_at,
+        }));
+    }
+    deleteProject(id) {
+        const res = this.db.prepare('DELETE FROM projects WHERE id = ?').run(id);
+        return (res.changes ?? 0) > 0;
+    }
+    close() {
+        const entry = TraceStorage._connections.get(this.dbPath);
+        if (entry) {
+            entry.refCount--;
+            if (entry.refCount <= 0) {
+                entry.db.close();
+                TraceStorage._connections.delete(this.dbPath);
+            }
+        }
+        else {
+            this.db.close();
+        }
+    }
+}
+//# sourceMappingURL=storage.js.map