openclaw-observability 1.0.0

package/dist/index.js

@@ -0,0 +1,1114 @@
+"use strict";
+/**
+ * OpenClaw audit plugin entry point
+ * Registers all 24 Plugin Hooks, assembles capture -> buffer -> writer pipeline
+ *
+ * OpenClaw hooks:
+ *   Agent: before_model_resolve, before_prompt_build, before_agent_start, agent_end
+ *   LLM:   llm_input, llm_output
+ *   Tool:  before_tool_call, after_tool_call, tool_result_persist
+ *   Msg:   message_received, message_sending, message_sent, before_message_write
+ *   Ctx:   before_compaction, after_compaction, before_reset
+ *   Session: session_start, session_end
+ *   Subagent: subagent_spawning, subagent_delivery_target, subagent_spawned, subagent_ended
+ *   Gateway: gateway_start, gateway_stop
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activate = activate;
+const config_1 = require("./config");
+const types_1 = require("./types");
+const redaction_1 = require("./redaction");
+const mysql_writer_1 = require("./storage/mysql-writer");
+const duckdb_local_writer_1 = require("./storage/duckdb-local-writer");
+const buffer_1 = require("./storage/buffer");
+const routes_1 = require("./web/routes");
+const scanner_1 = require("./security/scanner");
+/* ------------------------------------------------------------------ */
+/*  Runtime state                                                       */
+/* ------------------------------------------------------------------ */
+/** Max map entries (prevent memory leaks) */
+const MAX_MAP_ENTRIES = 1000;
+/** Map entry TTL (5 minutes) */
+const MAP_ENTRY_TTL_MS = 300_000;
+/** Max alert buffer size */
+const MAX_ALERT_BUFFER = 500;
+/** Track start time of each LLM/tool call */
+const runStartTimes = new Map();
+/**
+ * Map: requestUrl → usage from SSE final chunk
+ * We key by a monotonically increasing request ID since we can't know
+ * the sessionId at fetch time.
+ */
+const sseUsageCache = new Map();
+let sseRequestCounter = 0;
+/**
+ * Most recent SSE usage entry (LIFO — the llm_output hook fires shortly
+ * after the stream completes, so the latest entry is the one we want)
+ */
+let latestSseUsage = null;
+/** Original fetch reference */
+let originalFetch = null;
+/** Whether the fetch interceptor is installed */
+let fetchInterceptorInstalled = false;
+function installFetchInterceptor() {
+    if (fetchInterceptorInstalled)
+        return;
+    originalFetch = globalThis.fetch;
+    const origFetch = originalFetch;
+    globalThis.fetch = async function patchedFetch(input, init) {
+        // Only intercept POST requests with JSON body containing stream: true
+        if (!init?.body || init.method?.toUpperCase() !== 'POST') {
+            return origFetch(input, init);
+        }
+        let bodyStr;
+        try {
+            bodyStr = typeof init.body === 'string' ? init.body : undefined;
+        }
+        catch {
+            // Not a string body, skip
+        }
+        if (!bodyStr) {
+            return origFetch(input, init);
+        }
+        // Check if this is an OpenAI-compatible streaming request
+        let parsed;
+        try {
+            parsed = JSON.parse(bodyStr);
+        }
+        catch {
+            return origFetch(input, init);
+        }
+        if (!parsed || parsed.stream !== true || !parsed.model || !parsed.messages) {
+            return origFetch(input, init);
+        }
+        // Inject stream_options if not already present
+        if (!parsed.stream_options) {
+            parsed.stream_options = { include_usage: true };
+            init = { ...init, body: JSON.stringify(parsed) };
+        }
+        // Make the actual request
+        const response = await origFetch(input, init);
+        // Clone the response so we can read the body without consuming it for OpenClaw
+        // We use a TransformStream to tee the body and parse SSE chunks
+        if (!response.body) {
+            return response;
+        }
+        const requestId = ++sseRequestCounter;
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let sseBuffer = '';
+        let extractedUsage = null;
+        /** Parse a single SSE data line for usage info */
+        function tryExtractUsage(dataStr) {
+            try {
+                const evt = JSON.parse(dataStr);
+                if (evt.usage && (evt.usage.prompt_tokens || evt.usage.input_tokens)) {
+                    const u = evt.usage;
+                    extractedUsage = {
+                        input: u.prompt_tokens ?? u.input_tokens ?? 0,
+                        output: u.completion_tokens ?? u.output_tokens ?? 0,
+                        cacheRead: u.cache_read_input_tokens ?? 0,
+                        cacheWrite: u.cache_creation_input_tokens ?? 0,
+                        total: u.total_tokens ?? 0,
+                        timestamp: Date.now(),
+                    };
+                }
+            }
+            catch { /* ignore parse errors */ }
+        }
+        /** Process buffered SSE lines */
+        function processSseLines() {
+            const lines = sseBuffer.split('\n');
+            sseBuffer = lines.pop() || ''; // keep last incomplete line
+            for (const line of lines) {
+                if (!line.startsWith('data: '))
+                    continue;
+                const data = line.slice(6).trim();
+                if (data === '[DONE]')
+                    continue;
+                tryExtractUsage(data);
+            }
+        }
+        // Pipe response body through a pass-through ReadableStream
+        // that also extracts usage from SSE chunks
+        const newBody = new ReadableStream({
+            async start(controller) {
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done) {
+                            // Process any remaining data in the buffer
+                            if (sseBuffer.trim())
+                                processSseLines();
+                            if (extractedUsage) {
+                                sseUsageCache.set(requestId, extractedUsage);
+                                latestSseUsage = extractedUsage;
+                            }
+                            controller.close();
+                            break;
+                        }
+                        controller.enqueue(value);
+                        sseBuffer += decoder.decode(value, { stream: true });
+                        processSseLines();
+                    }
+                }
+                catch (err) {
+                    controller.error(err);
+                }
+            },
+        });
+        return new Response(newBody, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+        });
+    };
+    fetchInterceptorInstalled = true;
+    console.log('[audit-duckdb] Fetch interceptor installed for token usage tracking');
+}
+function uninstallFetchInterceptor() {
+    if (originalFetch) {
+        globalThis.fetch = originalFetch;
+        originalFetch = null;
+        fetchInterceptorInstalled = false;
+        console.log('[audit-duckdb] Fetch interceptor uninstalled');
+    }
+}
+/**
+ * Pop the most recent SSE usage (consume once per llm_output call)
+ */
+function popLatestSseUsage() {
+    const usage = latestSseUsage;
+    latestSseUsage = null;
+    // Also trim old cache entries
+    if (sseUsageCache.size > 100) {
+        const keys = Array.from(sseUsageCache.keys()).sort((a, b) => a - b);
+        for (let i = 0; i < keys.length - 50; i++) {
+            sseUsageCache.delete(keys[i]);
+        }
+    }
+    return usage;
+}
+const runInputs = new Map();
+/**
+ * Periodically clean up stale Map entries to prevent memory leaks when llm_input fires but llm_output does not
+ */
+function cleanupStaleMaps() {
+    const now = Date.now();
+    for (const [key, startTime] of runStartTimes) {
+        if (now - startTime > MAP_ENTRY_TTL_MS) {
+            runStartTimes.delete(key);
+        }
+    }
+    // runInputs has no timestamps; trim oldest entries when exceeding size limit
+    if (runInputs.size > MAX_MAP_ENTRIES) {
+        const keys = Array.from(runInputs.keys());
+        for (let i = 0; i < keys.length - MAX_MAP_ENTRIES; i++) {
+            runInputs.delete(keys[i]);
+        }
+    }
+    // sseUsageCache: trim old entries
+    if (sseUsageCache.size > 100) {
+        const keys = Array.from(sseUsageCache.keys()).sort((a, b) => a - b);
+        for (let i = 0; i < keys.length - 50; i++) {
+            sseUsageCache.delete(keys[i]);
+        }
+    }
+    // sessionContextMap: trim oversized context Map
+    if (sessionContextMap.size > MAX_MAP_ENTRIES) {
+        const keys = Array.from(sessionContextMap.keys());
+        for (let i = 0; i < keys.length - MAX_MAP_ENTRIES; i++) {
+            sessionContextMap.delete(keys[i]);
+        }
+    }
+    // sessionStatsMap: evict oldest entries when exceeding limit
+    if (sessionStatsMap.size > MAX_SESSION_STATS) {
+        const entries = Array.from(sessionStatsMap.entries());
+        entries.sort((a, b) => a[1].lastSeen.getTime() - b[1].lastSeen.getTime());
+        const toRemove = entries.length - MAX_SESSION_STATS;
+        for (let i = 0; i < toRemove; i++) {
+            sessionStatsMap.delete(entries[i][0]);
+        }
+    }
+}
+/**
+ * Extract image/media metadata from historyMessages
+ * OpenClaw message format:
+ *   UserMessage.content = string | (TextContent | ImageContent)[]
+ *   ToolResultMessage.content = (TextContent | ImageContent)[]
+ *   ImageContent = { type: "image", data: base64string, mimeType: string }
+ */
+function extractMediaMeta(historyMessages) {
+    const media = [];
+    if (!Array.isArray(historyMessages))
+        return media;
+    for (const msg of historyMessages) {
+        if (!msg || typeof msg !== 'object')
+            continue;
+        const m = msg;
+        const role = m.role;
+        const content = m.content;
+        // content can be string (plain text) or array (multimodal)
+        if (!Array.isArray(content))
+            continue;
+        const source = role === 'toolResult' ? 'tool' : 'user';
+        for (const part of content) {
+            if (!part || typeof part !== 'object')
+                continue;
+            const p = part;
+            if (p.type === 'image' && typeof p.data === 'string') {
+                const base64Len = p.data.length;
+                // base64 encoded size is ~4/3 of original, so multiply by 0.75 to approximate original bytes
+                const sizeBytes = Math.round(base64Len * 0.75);
+                media.push({
+                    mimeType: p.mimeType || 'unknown',
+                    sizeBytes,
+                    source,
+                });
+            }
+        }
+    }
+    return media;
+}
+const sessionContextMap = new Map();
+/** Most recently active sessionId (ultimate fallback when hook does not carry sessionId) */
+let lastFallbackSessionId = 'unknown';
+/** Get or create session context */
+function getSessionCtx(sessionId) {
+    let ctx = sessionContextMap.get(sessionId);
+    if (!ctx) {
+        ctx = { sessionId, userId: '', modelName: '' };
+        sessionContextMap.set(sessionId, ctx);
+    }
+    return ctx;
+}
+/** Resolve sessionId from hook parameters (priority: event → ctx → fallback) */
+function resolveSessionId(eventSessionId, ctxSessionId) {
+    if (eventSessionId && eventSessionId !== 'unknown') {
+        lastFallbackSessionId = eventSessionId;
+        return eventSessionId;
+    }
+    if (ctxSessionId && ctxSessionId !== 'unknown') {
+        lastFallbackSessionId = ctxSessionId;
+        return ctxSessionId;
+    }
+    return lastFallbackSessionId;
+}
+const sessionStatsMap = new Map();
+/** Max session stats entries */
+const MAX_SESSION_STATS = 200;
+/** Update session statistics and return AuditSession */
+function updateSessionStats(sessionId, modelName, userId, tokens) {
+    let stats = sessionStatsMap.get(sessionId);
+    if (!stats) {
+        stats = {
+            firstSeen: new Date(),
+            lastSeen: new Date(),
+            modelName,
+            userId,
+            totalActions: 0,
+            totalTokens: 0,
+        };
+        sessionStatsMap.set(sessionId, stats);
+    }
+    stats.lastSeen = new Date();
+    stats.totalActions += 1;
+    stats.totalTokens += tokens;
+    if (modelName)
+        stats.modelName = modelName;
+    if (userId)
+        stats.userId = userId;
+    return {
+        sessionId,
+        userId: stats.userId,
+        modelName: stats.modelName,
+        startTime: stats.firstSeen,
+        endTime: stats.lastSeen,
+        totalActions: stats.totalActions,
+        totalTokens: stats.totalTokens,
+    };
+}
+/** Helper to build an AuditAction (auto-fills defaults) */
+function makeAction(sessionId, overrides) {
+    const sctx = getSessionCtx(sessionId);
+    return {
+        sessionId,
+        actionType: overrides.actionType,
+        actionName: overrides.actionName,
+        modelName: overrides.modelName ?? sctx.modelName,
+        inputParams: overrides.inputParams ?? null,
+        outputResult: overrides.outputResult ?? null,
+        promptTokens: overrides.promptTokens ?? null,
+        completionTokens: overrides.completionTokens ?? null,
+        durationMs: overrides.durationMs ?? null,
+        userId: overrides.userId ?? sctx.userId,
+        createdAt: overrides.createdAt ?? new Date(),
+    };
+}
+/* ------------------------------------------------------------------ */
+/*  Plugin registration                                                         */
+/* ------------------------------------------------------------------ */
+function activate(api) {
+    const rawConfig = (api.pluginConfig || api.config || {});
+    const config = (0, config_1.resolveConfig)(rawConfig);
+    console.log(`[audit-duckdb] Config resolved: mode=${config.mode} ` +
+        (config.mode === 'remote'
+            ? `mysql.host=${config.mysql.host} mysql.database=${config.mysql.database}`
+            : `duckdb.path=${config.duckdb.path}`));
+    const redactor = new redaction_1.Redactor(config.redaction);
+    // Select storage backend based on mode
+    let writer;
+    if (config.mode === 'remote') {
+        writer = new mysql_writer_1.MySQLWriter(config.mysql);
+    }
+    else {
+        writer = new duckdb_local_writer_1.DuckDBLocalWriter(config.duckdb);
+    }
+    const buffer = new buffer_1.AsyncBatchBuffer(config.buffer, (entries) => writer.writeBatch(entries));
+    // Install fetch interceptor for token usage tracking
+    installFetchInterceptor();
+    // Security scanner
+    const securityConfig = (0, scanner_1.resolveSecurityConfig)(config.security);
+    const securityScanner = new scanner_1.SecurityScanner(securityConfig);
+    /** Security alert buffer (batch write) */
+    const alertBuffer = [];
+    let alertFlushTimer = null;
+    let mapCleanupTimer = null;
+    // Check whether database can be connected
+    //  - local mode: always available (local file, zero config)
+    //  - remote mode: requires user-configured connection info
+    const dbConfigured = config.mode === 'local'
+        || (config.mysql.host !== 'localhost' || config.mysql.password !== '');
+    if (dbConfigured) {
+        // Async background initialization
+        writer
+            .initialize()
+            .then(() => {
+            buffer.start();
+            // Start security alert flush timer (every 30s)
+            alertFlushTimer = setInterval(() => void flushAlerts(), 30000);
+            if (alertFlushTimer && typeof alertFlushTimer === 'object' && 'unref' in alertFlushTimer) {
+                alertFlushTimer.unref();
+            }
+            // Start Map cleanup timer (every 60s)
+            mapCleanupTimer = setInterval(cleanupStaleMaps, 60000);
+            if (mapCleanupTimer && typeof mapCleanupTimer === 'object' && 'unref' in mapCleanupTimer) {
+                mapCleanupTimer.unref();
+            }
+            console.log(`[audit-duckdb] Plugin activated (mode=${config.mode}, security scanner enabled)`);
+        })
+            .catch((error) => {
+            console.error('[audit-duckdb] Failed to initialize database:', error);
+        });
+    }
+    else {
+        console.log('[audit-duckdb] MySQL not configured yet — skipping database connection. ' +
+            'Please configure via Dashboard (Settings → Plugins → audit-duckdb Config) then restart.');
+    }
+    // Register audit panel Web UI (mounted on Gateway HTTP server)
+    if (typeof api.registerHttpRoute === 'function') {
+        (0, routes_1.registerAuditRoutes)(api.registerHttpRoute.bind(api), writer);
+    }
+    else {
+        console.warn('[audit-duckdb] registerHttpRoute not available — audit UI disabled');
+    }
+    // ====================== Helper functions ======================
+    /** Record action, update session stats, and run security scan */
+    function recordAction(action, tokens = 0) {
+        void buffer.addAction(action);
+        const session = updateSessionStats(action.sessionId, action.modelName, action.userId, tokens);
+        void buffer.addSession(session);
+        // --- Security scan ---
+        if (securityConfig.enabled) {
+            try {
+                const alerts = securityScanner.scan(action);
+                if (alerts.length > 0) {
+                    // Prevent alertBuffer from growing unbounded
+                    if (alertBuffer.length + alerts.length > MAX_ALERT_BUFFER) {
+                        const overflow = alertBuffer.length + alerts.length - MAX_ALERT_BUFFER;
+                        alertBuffer.splice(0, overflow);
+                        console.warn(`[audit-security] Alert buffer overflow, dropped ${overflow} oldest alerts`);
+                    }
+                    alertBuffer.push(...alerts);
+                    for (const alert of alerts) {
+                        const icon = alert.severity === 'critical' ? '🔴' : alert.severity === 'warn' ? '🟡' : 'ℹ️';
+                        console.log(`[audit-security] ${icon} ${alert.severity.toUpperCase()} ${alert.ruleId}: ${alert.ruleName} — ${alert.finding} (session=${alert.sessionId})`);
+                    }
+                    // Flush immediately on CRITICAL alerts
+                    if (alerts.some(a => a.severity === 'critical')) {
+                        void flushAlerts();
+                    }
+                }
+            }
+            catch (err) {
+                console.error('[audit-security] Scan error:', err);
+            }
+        }
+    }
+    /** Batch-write security alerts */
+    async function flushAlerts() {
+        if (alertBuffer.length === 0)
+            return;
+        const batch = alertBuffer.splice(0, alertBuffer.length);
+        try {
+            await writer.writeAlerts(batch);
+        }
+        catch (err) {
+            console.error('[audit-security] Failed to write alerts:', err);
+            // Put back into buffer
+            alertBuffer.unshift(...batch);
+        }
+    }
+    /** Safely truncate a string */
+    function truncate(s, max = 500) {
+        if (typeof s !== 'string')
+            return '';
+        return s.length > max ? s.substring(0, max) + '…' : s;
+    }
+    /** Convert bytes to human-readable format */
+    function formatBytes(bytes) {
+        if (bytes < 1024)
+            return `${bytes} B`;
+        if (bytes < 1024 * 1024)
+            return `${(bytes / 1024).toFixed(1)} KB`;
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    }
+    // =====================================================================
+    //  1. Agent lifecycle
+    // =====================================================================
+    // before_model_resolve: before model selection
+    api.on('before_model_resolve', (event, ctx) => {
+        try {
+            const e = event;
+            const c = ctx;
+            const sid = resolveSessionId(undefined, c?.sessionId);
+            const sctx = getSessionCtx(sid);
+            if (c?.agentId)
+                sctx.userId = c.agentId;
+            recordAction(makeAction(sid, {
+                actionType: types_1.ActionType.ModelResolve,
+                actionName: 'before_model_resolve',
+                userId: c?.agentId,
+                inputParams: redactor.redact({ prompt: truncate(e.prompt) }),
+            }));
+            console.log(`[audit-duckdb] before_model_resolve: session=${sid}`);
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in before_model_resolve:', err);
+        }
+    });
+    // before_prompt_build: before prompt construction
+    api.on('before_prompt_build', (event, ctx) => {
+        try {
+            const e = event;
+            const c = ctx;
+            const sid = resolveSessionId(undefined, c?.sessionId);
+            recordAction(makeAction(sid, {
+                actionType: types_1.ActionType.PromptBuild,
+                actionName: 'before_prompt_build',
+                userId: c?.agentId,
+                inputParams: redactor.redact({
+                    prompt: truncate(e.prompt),
+                    messageCount: Array.isArray(e.messages) ? e.messages.length : 0,
+                }),
+            }));
+            console.log(`[audit-duckdb] before_prompt_build: session=${sid} msgs=${Array.isArray(e.messages) ? e.messages.length : '?'}`);
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in before_prompt_build:', err);
+        }
+    });
+    // before_agent_start: skipped — legacy hook that fires twice
+    // and fully overlaps with before_model_resolve + before_prompt_build
+    // agent_end: Agent run finished
+    api.on('agent_end', (event, ctx) => {
+        try {
+            const e = event;
+            const c = ctx;
+            const sid = resolveSessionId(undefined, c?.sessionId);
+            recordAction(makeAction(sid, {
+                actionType: types_1.ActionType.AgentEnd,
+                actionName: 'agent_end',
+                userId: c?.agentId,
+                outputResult: redactor.redact({
+                    success: e.success,
+                    error: e.error,
+                    messageCount: Array.isArray(e.messages) ? e.messages.length : 0,
+                }),
+                durationMs: e.durationMs ?? null,
+            }));
+            console.log(`[audit-duckdb] agent_end: session=${sid} success=${e.success} duration=${e.durationMs}ms`);
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in agent_end:', err);
+        }
+    });
+    // =====================================================================
+    //  2. LLM calls
+    // =====================================================================
+    // llm_input: before LLM call — record start time + cache user input
+    api.on('llm_input', (event, ctx) => {
+        try {
+            const e = event;
+            const c = ctx;
+            const sid = resolveSessionId(e.sessionId, c?.sessionId);
+            const sctx = getSessionCtx(sid);
+            // Parse image/media metadata from historyMessages
+            const media = extractMediaMeta(e.historyMessages ?? []);
+            if (e.runId) {
+                runStartTimes.set(e.runId, Date.now());
+                runInputs.set(e.runId, {
+                    prompt: e.prompt,
+                    imagesCount: e.imagesCount,
+                    media: media.length > 0 ? media : undefined,
+                });
+            }
+            if (c?.agentId)
+                sctx.userId = c.agentId;
+            sctx.modelName = `${e.provider}/${e.model}`;
+            console.log(`[audit-duckdb] llm_input: session=${sid} model=${e.provider}/${e.model} runId=${e.runId} images=${e.imagesCount ?? 0} mediaParts=${media.length}`);
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in llm_input:', err);
+        }
+    });
+    // llm_output: after LLM call — primary audit record point
+    api.on('llm_output', (event, ctx) => {
+        try {
+            const e = event;
+            const c = ctx;
+            // Calculate duration
+            let durationMs = null;
+            if (e.runId && runStartTimes.has(e.runId)) {
+                durationMs = Date.now() - runStartTimes.get(e.runId);
+                runStartTimes.delete(e.runId);
+            }
+            // Retrieve cached user input
+            const cachedInput = e.runId ? runInputs.get(e.runId) : undefined;
+            if (e.runId)
+                runInputs.delete(e.runId);
+            // Token usage: multiple extraction strategies
+            const sid = resolveSessionId(e.sessionId, c?.sessionId);
+            let promptTokens = e.usage?.input ?? null;
+            let completionTokens = e.usage?.output ?? null;
+            let cacheRead = e.usage?.cacheRead ?? null;
+            let cacheWrite = e.usage?.cacheWrite ?? null;
+            // Strategy 2: extract from lastAssistant message (OpenClaw stores usage in assistant message)
+            if (promptTokens === null && completionTokens === null && e.lastAssistant) {
+                const la = e.lastAssistant;
+                const rawUsage = la.usage;
+                if (rawUsage) {
+                    const inp = rawUsage.input ?? rawUsage.inputTokens ?? rawUsage.prompt_tokens ?? rawUsage.promptTokens;
+                    const out = rawUsage.output ?? rawUsage.outputTokens ?? rawUsage.completion_tokens ?? rawUsage.completionTokens;
+                    if (typeof inp === 'number' && inp > 0)
+                        promptTokens = inp;
+                    if (typeof out === 'number' && out > 0)
+                        completionTokens = out;
+                    if (typeof rawUsage.cacheRead === 'number')
+                        cacheRead = rawUsage.cacheRead;
+                    if (typeof rawUsage.cacheWrite === 'number')
+                        cacheWrite = rawUsage.cacheWrite;
+                }
+            }
+            // Strategy 3: SSE usage captured by fetch interceptor (stream_options injection)
+            if (promptTokens === null && completionTokens === null) {
+                const sseUsage = popLatestSseUsage();
+                if (sseUsage) {
+                    promptTokens = sseUsage.input || null;
+                    completionTokens = sseUsage.output || null;
+                    cacheRead = sseUsage.cacheRead || null;
+                    cacheWrite = sseUsage.cacheWrite || null;
+                }
+            }
+            const totalTokens = (promptTokens ?? 0) + (completionTokens ?? 0);
+            const modelName = `${e.provider}/${e.model}`;
+            // Build inputParams with media metadata
+            const inputData = {
+                userMessage: cachedInput?.prompt ?? '',
+                imagesCount: cachedInput?.imagesCount ?? 0,
+            };
+            if (cachedInput?.media && cachedInput.media.length > 0) {
+                inputData.media = cachedInput.media.map((m) => ({
+                    mimeType: m.mimeType,
+                    sizeBytes: m.sizeBytes,
+                    sizeHuman: formatBytes(m.sizeBytes),
+                    source: m.source,
+                }));
+                inputData.mediaTotalBytes = cachedInput.media.reduce((sum, m) => sum + m.sizeBytes, 0);
+            }
+            const sctx = getSessionCtx(sid);
+            if (c?.agentId)
+                sctx.userId = c.agentId;
+            sctx.modelName = modelName;
+            recordAction(makeAction(sid, {
+                actionType: types_1.ActionType.Message,
+                actionName: `llm_call:${modelName}`,
+                modelName,
+                inputParams: redactor.redact(inputData),
+                outputResult: redactor.redact({
+                    assistantTexts: e.assistantTexts ?? [],
+                }),
+                promptTokens,
+                completionTokens,
+                durationMs,
+                userId: c?.agentId,
+            }), totalTokens);
+            console.log(`[audit-duckdb] llm_output: session=${e.sessionId} model=${e.model} duration=${durationMs}ms tokens=${promptTokens ?? '?'}/${completionTokens ?? '?'} cache_r=${cacheRead ?? '-'} cache_w=${cacheWrite ?? '-'}`);
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in llm_output:', err);
+        }
+    });
+    // =====================================================================
+    //  3. Context management
+    // =====================================================================
+    // before_compaction: before context compaction
+    api.on('before_compaction', (event, ctx) => {
+        try {
+            const e = event;
+            const c = ctx;
+            const sid = resolveSessionId(undefined, c?.sessionId);
+            recordAction(makeAction(sid, {
+                actionType: types_1.ActionType.Compaction,
+                actionName: 'before_compaction',
+                userId: c?.agentId,
+                inputParams: redactor.redact({
+                    messageCount: e.messageCount,
+                    compactingCount: e.compactingCount,
+                    tokenCount: e.tokenCount,
+                }),
+            }));
+            console.log(`[audit-duckdb] before_compaction: session=${sid} msgs=${e.messageCount} tokens=${e.tokenCount}`);
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in before_compaction:', err);
+        }
+    });
+    // after_compaction: after context compaction
+    api.on('after_compaction', (event, ctx) => {
+        try {
+            const e = event;
+            const c = ctx;
+            const sid = resolveSessionId(undefined, c?.sessionId);
+            recordAction(makeAction(sid, {
+                actionType: types_1.ActionType.Compaction,
+                actionName: 'after_compaction',
+                userId: c?.agentId,
+                outputResult: redactor.redact({
+                    messageCount: e.messageCount,
+                    compactedCount: e.compactedCount,
+                    tokenCount: e.tokenCount,
+                }),
+            }));
+            console.log(`[audit-duckdb] after_compaction: session=${sid} compacted=${e.compactedCount}`);
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in after_compaction:', err);
+        }
+    });
+    // before_reset: before session reset
+    api.on('before_reset', (event, ctx) => {
+        try {
+            const e = event;
+            const c = ctx;
+            const sid = resolveSessionId(undefined, c?.sessionId);
+            recordAction(makeAction(sid, {
+                actionType: types_1.ActionType.Reset,
+                actionName: 'before_reset',
+                userId: c?.agentId,
+                inputParams: redactor.redact({
+                    reason: e.reason,
+                    messageCount: Array.isArray(e.messages) ? e.messages.length : 0,
+                }),
+            }));
+            console.log(`[audit-duckdb] before_reset: session=${sid} reason=${e.reason}`);
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in before_reset:', err);
+        }
+    });
+    // =====================================================================
+    //  4. Message channel
+    // =====================================================================
+    // message_received: user message arrived
+    api.on('message_received', (event, ctx) => {
+        try {
+            const e = event;
+            const c = ctx;
+            const sid = lastFallbackSessionId;
+            if (sid === 'unknown')
+                return; // No valid session yet, skip (content will be recorded in llm_input)
+            recordAction(makeAction(sid, {
+                actionType: types_1.ActionType.UserMessage,
+                actionName: 'message_received',
+                modelName: '',
+                inputParams: redactor.redact({
+                    from: e.from,
+                    content: e.content,
+                    channelId: c?.channelId,
+                    metadata: e.metadata,
+                }),
+                createdAt: new Date(e.timestamp || Date.now()),
+            }));
+            console.log(`[audit-duckdb] message_received: from=${e.from} channel=${c?.channelId} len=${e.content?.length}`);
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in message_received:', err);
+        }
+    });
+    // message_sending: before message send (interceptable/modifiable)
+    api.on('message_sending', (event, ctx) => {
+        try {
+            const e = event;
+            const c = ctx;
+            const sid = lastFallbackSessionId;
+            if (sid === 'unknown')
+                return;
+            recordAction(makeAction(sid, {
+                actionType: types_1.ActionType.MsgSending,
+                actionName: 'message_sending',
+                modelName: '',
+                inputParams: redactor.redact({
+                    to: e.to,
+                    content: truncate(e.content, 1000),
+                    channelId: c?.channelId,
+                }),
+            }));
+            console.log(`[audit-duckdb] message_sending: to=${e.to} channel=${c?.channelId}`);
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in message_sending:', err);
+        }
+    });
+    // message_sent: message sent
+    api.on('message_sent', (event, ctx) => {
+        try {
+            const e = event;
+            const c = ctx;
+            const sid = lastFallbackSessionId;
+            if (sid === 'unknown')
+                return;
+            recordAction(makeAction(sid, {
+                actionType: types_1.ActionType.AssistantMsg,
+                actionName: 'message_sent',
+                modelName: '',
+                outputResult: redactor.redact({
+                    to: e.to,
+                    content: e.content,
+                    success: e.success,
+                    error: e.error,
+                    channelId: c?.channelId,
+                }),
+            }));
+            console.log(`[audit-duckdb] message_sent: to=${e.to} success=${e.success} channel=${c?.channelId}`);
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in message_sent:', err);
+        }
+    });
+    // before_message_write: skipped — message content already fully recorded in llm_input/llm_output, no additional audit value
+    // =====================================================================
+    //  5. Tool calls
+    // =====================================================================
+    // before_tool_call: before tool call — record start time
+    api.on('before_tool_call', (event, ctx) => {
+        try {
+            const e = event;
+            const c = ctx;
+            // Use toolCallId as timing key to avoid collision with llm_input runId
+            // Note: cannot use Date.now() as fallback, otherwise before and after generate inconsistent keys
+            const callId = e.toolCallId || c?.toolCallId || '';
+            const timingKey = callId ? `tc:${callId}` : `tc:${e.toolName}`;
+            runStartTimes.set(timingKey, Date.now());
+            // Update per-session context
+            const sid = resolveSessionId(undefined, c?.sessionId);
+            const sctx = getSessionCtx(sid);
+            if (c?.agentId)
+                sctx.userId = c.agentId;
+            console.log(`[audit-duckdb] before_tool_call: tool=${e.toolName} session=${sid} callId=${callId}`);
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in before_tool_call:', err);
+        }
+    });
+    // after_tool_call: after tool call — generate audit record
+    api.on('after_tool_call', (event, ctx) => {
+        try {
+            const e = event;
+            const c = ctx;
+            const toolName = e.toolName;
+            // Get sessionId from ctx (event does not have this field)
+            const sessionId = resolveSessionId(undefined, c?.sessionId);
+            // Calculate duration — use toolCallId as key to not interfere with LLM runId timing
+            const callId = e.toolCallId || c?.toolCallId || '';
+            const timingKey = callId ? `tc:${callId}` : `tc:${e.toolName}`;
+            let durationMs = e.durationMs ?? null;
+            if (durationMs === null && runStartTimes.has(timingKey)) {
+                durationMs = Date.now() - runStartTimes.get(timingKey);
+            }
+            runStartTimes.delete(timingKey);
+            // BUG FIX: use correct field name params (not parameters/input/args)
+            const inputParams = e.params ? redactor.redact(e.params) : null;
+            // Detect image content in tool results
+            let outputData = null;
+            if (e.error) {
+                outputData = redactor.redact({ error: e.error });
+            }
+            else if (e.result !== undefined) {
+                const raw = typeof e.result === 'object' && e.result !== null
+                    ? e.result
+                    : { value: e.result };
+                // If tool result contains content array, check for images
+                const resultContent = raw.content;
+                if (Array.isArray(resultContent)) {
+                    const toolMedia = [];
+                    for (const part of resultContent) {
+                        if (part && typeof part === 'object' && part.type === 'image' && typeof part.data === 'string') {
+                            toolMedia.push({
+                                mimeType: part.mimeType || 'unknown',
+                                sizeBytes: Math.round(part.data.length * 0.75),
+                                source: 'tool',
+                            });
+                        }
+                    }
+                    if (toolMedia.length > 0) {
+                        // Don't write full base64 to audit record, only record metadata
+                        const sanitized = { ...raw };
+                        sanitized.content = resultContent.map((part) => {
+                            if (part && typeof part === 'object' && part.type === 'image') {
+                                return {
+                                    type: 'image',
+                                    mimeType: part.mimeType || 'unknown',
+                                    sizeBytes: Math.round((part.data?.length ?? 0) * 0.75),
+                                    sizeHuman: formatBytes(Math.round((part.data?.length ?? 0) * 0.75)),
+                                    data: '[base64 omitted]',
+                                };
+                            }
+                            return part;
+                        });
+                        sanitized._mediaCount = toolMedia.length;
+                        sanitized._mediaTotalBytes = toolMedia.reduce((s, m) => s + m.sizeBytes, 0);
+                        outputData = redactor.redact(sanitized);
+                    }
+                    else {
+                        outputData = redactor.redact(raw);
+                    }
+                }
+                else {
+                    outputData = redactor.redact(raw);
+                }
+            }
+            recordAction(makeAction(sessionId, {
+                actionType: types_1.ActionType.ToolCall,
+                actionName: `tool_call:${toolName}`,
+                inputParams,
+                outputResult: outputData,
+                durationMs,
+                userId: c?.agentId,
+            }));
+            console.log(`[audit-duckdb] after_tool_call: tool=${toolName} session=${sessionId} duration=${durationMs}ms`);
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in after_tool_call:', err);
+        }
+    });
+    // tool_result_persist: tool result persistence (sync hook)
+    api.on('tool_result_persist', (event, ctx) => {
+        try {
+            const e = event;
+            const c = ctx;
+            const name = e.toolName || c?.toolName || 'unknown';
+            const sid = lastFallbackSessionId;
+            if (sid === 'unknown')
+                return;
+            recordAction(makeAction(sid, {
+                actionType: types_1.ActionType.ToolPersist,
+                actionName: `tool_persist:${name}`,
+                inputParams: redactor.redact({
+                    toolName: name,
+                    toolCallId: e.toolCallId,
+                    isSynthetic: e.isSynthetic,
+                }),
+            }));
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in tool_result_persist:', err);
+        }
+    });
+    // =====================================================================
+    //  6. Session lifecycle
+    // =====================================================================
+    // session_start: session started
+    api.on('session_start', (event, ctx) => {
+        try {
+            const e = event;
+            const c = ctx;
+            const sid = resolveSessionId(e.sessionId, c?.sessionId);
+            const sctx = getSessionCtx(sid);
+            if (c?.agentId)
+                sctx.userId = c.agentId;
+            recordAction(makeAction(sid, {
+                actionType: types_1.ActionType.SessionStart,
+                actionName: 'session_start',
+                userId: c?.agentId,
+                inputParams: redactor.redact({
+                    resumedFrom: e.resumedFrom,
+                }),
+            }));
+            console.log(`[audit-duckdb] session_start: session=${sid} resumed=${e.resumedFrom}`);
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in session_start:', err);
+        }
+    });
+    // session_end: session ended — force flush
+    api.on('session_end', (event, ctx) => {
+        try {
+            const e = event;
+            const c = ctx;
+            const sid = resolveSessionId(e.sessionId, c?.sessionId);
+            recordAction(makeAction(sid, {
+                actionType: types_1.ActionType.SessionEnd,
+                actionName: 'session_end',
+                userId: c?.agentId,
+                outputResult: redactor.redact({
+                    messageCount: e.messageCount,
+                }),
+                durationMs: e.durationMs ?? null,
+            }));
+            // Force flush to ensure session data is not lost
+            void buffer.flush();
+            // Clean up session context
+            sessionContextMap.delete(sid);
+            console.log(`[audit-duckdb] session_end: session=${sid} msgs=${e.messageCount} duration=${e.durationMs}ms`);
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in session_end:', err);
+        }
+    });
+    // =====================================================================
+    //  7. Sub-agents
+    // =====================================================================
+    // subagent_spawned: sub-agent created
+    api.on('subagent_spawned', (event, ctx) => {
+        try {
+            const e = event;
+            const c = ctx;
+            const sid = lastFallbackSessionId;
+            if (sid === 'unknown')
+                return;
+            recordAction(makeAction(sid, {
+                actionType: types_1.ActionType.SubagentSpawn,
+                actionName: `subagent_spawned:${e.agentId}`,
+                inputParams: redactor.redact({
+                    childSessionKey: e.childSessionKey,
+                    agentId: e.agentId,
+                    label: e.label,
+                    mode: e.mode,
+                    runId: e.runId,
+                    threadRequested: e.threadRequested,
+                    requesterSessionKey: c?.requesterSessionKey,
+                }),
+            }));
+            console.log(`[audit-duckdb] subagent_spawned: agent=${e.agentId} child=${e.childSessionKey}`);
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in subagent_spawned:', err);
+        }
+    });
+    // subagent_ended: sub-agent ended
+    api.on('subagent_ended', (event, ctx) => {
+        try {
+            const e = event;
+            const sid = lastFallbackSessionId;
+            if (sid === 'unknown')
+                return;
+            recordAction(makeAction(sid, {
+                actionType: types_1.ActionType.SubagentEnd,
+                actionName: `subagent_ended:${e.targetKind}`,
+                outputResult: redactor.redact({
+                    targetSessionKey: e.targetSessionKey,
+                    reason: e.reason,
+                    outcome: e.outcome,
+                    error: e.error,
+                }),
+            }));
+            console.log(`[audit-duckdb] subagent_ended: target=${e.targetSessionKey} outcome=${e.outcome}`);
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in subagent_ended:', err);
+        }
+    });
+    // =====================================================================
+    //  8. Gateway
+    // =====================================================================
+    // gateway_start: gateway started
+    api.on('gateway_start', (event) => {
+        try {
+            const e = event;
+            recordAction(makeAction('system', {
+                actionType: types_1.ActionType.GatewayStart,
+                actionName: 'gateway_start',
+                modelName: '',
+                userId: 'system',
+                inputParams: { port: e.port },
+            }));
+            console.log(`[audit-duckdb] gateway_start: port=${e.port}`);
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in gateway_start:', err);
+        }
+    });
+    // gateway_stop: gateway stopped
+    api.on('gateway_stop', (event) => {
+        try {
+            const e = event;
+            recordAction(makeAction('system', {
+                actionType: types_1.ActionType.GatewayStop,
+                actionName: 'gateway_stop',
+                modelName: '',
+                userId: 'system',
+                outputResult: { reason: e.reason },
+            }));
+            // Force flush on gateway stop
+            void buffer.flush();
+            console.log(`[audit-duckdb] gateway_stop: reason=${e.reason}`);
+        }
+        catch (err) {
+            console.error('[audit-duckdb] Error in gateway_stop:', err);
+        }
+    });
+    // =====================================================================
+    //  Return deactivate function for cleanup
+    // =====================================================================
+    return {
+        deactivate: async () => {
+            console.log('[audit-duckdb] Deactivating plugin...');
+            // Stop timers
+            if (alertFlushTimer) {
+                clearInterval(alertFlushTimer);
+                alertFlushTimer = null;
+            }
+            if (mapCleanupTimer) {
+                clearInterval(mapCleanupTimer);
+                mapCleanupTimer = null;
+            }
+            await flushAlerts();
+            await buffer.shutdown();
+            await writer.close();
+            // Uninstall fetch interceptor
+            uninstallFetchInterceptor();
+            runStartTimes.clear();
+            runInputs.clear();
+            sseUsageCache.clear();
+            latestSseUsage = null;
+            sessionStatsMap.clear();
+            sessionContextMap.clear();
+            securityScanner.reset();
+            lastFallbackSessionId = 'unknown';
+            console.log('[audit-duckdb] Plugin deactivated');
+        },
+    };
+}
+exports.default = activate;
+//# sourceMappingURL=index.js.map