whale-code 6.4.0 → 6.5.0

package/dist/server/handlers/operations.js

@@ -1,5 +1,10 @@
 // server/handlers/operations.ts — Locations, Suppliers, Alerts, Audit Trail handlers
 import { sanitizeFilterValue } from "../lib/utils.js";
+import { getClickHouseClient } from "../lib/clickhouse-client.js";
+/** Escape single quotes for ClickHouse SQL */
+function escQ(s) {
+    return s.replace(/'/g, "\\'");
+}
 export async function handleLocations(sb, args, storeId) {
     const sid = storeId;
     let q = sb.from("locations").select("id, name, address_line1, city, state, is_active, type").eq("store_id", sid);
@@ -82,50 +87,106 @@ export async function handleAuditTrail(sb, args, storeId) {
     const sid = storeId;
     const days = args.days || 1;
     const cutoff = new Date(Date.now() - days * 86400_000).toISOString();
-    // "search" action: full-text search across logs
+    const ch = getClickHouseClient();
+    const rowLimit = Math.min(args.limit || 100, 500);
+    // Business audit actions in Postgres business_audit table
+    // All action types that live in business_audit (queried by handleAuditTrail)
+    const BUSINESS_ACTIONS = [
+        "inventory.po_receive", "inventory.transfer_receive", "inventory.transfer_cancel_restore",
+        "inventory.po_create", "inventory.transfer_create", "inventory.adjustment_create",
+        "terminal_credentials_access", "payment.initiated", "payment.failed",
+        "trigger.schedule.fired", "trigger.condition.fired",
+        "trigger.condition.blocked", "trigger.condition.error",
+        "system.connection_warning",
+    ];
+    // "search" action: dual-read ClickHouse + Postgres
     if (args.action === "search") {
         const query = args.query;
         if (!query)
             return { success: false, error: "query parameter is required for search action" };
-        let sq = sb.from("audit_logs")
-            .select("id, action, severity, source, resource_type, resource_id, user_email, details, created_at")
-            .eq("store_id", sid)
-            .gte("created_at", cutoff)
-            .or(`action.ilike.%${sanitizeFilterValue(query)}%,error_message.ilike.%${sanitizeFilterValue(query)}%,user_email.ilike.%${sanitizeFilterValue(query)}%,resource_id.ilike.%${sanitizeFilterValue(query)}%`)
-            .order("created_at", { ascending: false });
-        if (args.limit)
-            sq = sq.limit(args.limit);
-        const { data, error } = await sq;
-        if (error)
-            return { success: false, error: error.message };
-        return { success: true, data: { query, entries: data, count: data?.length || 0, days } };
-    }
-    // Default action: filtered list
-    let q = sb.from("audit_logs")
-        .select("id, action, severity, source, resource_type, resource_id, details, user_email, created_at")
-        .eq("store_id", sid)
-        .gte("created_at", cutoff)
-        .order("created_at", { ascending: false });
-    if (args.limit)
-        q = q.limit(args.limit);
-    // Optional filters
-    if (args.action_filter) {
-        const sf = sanitizeFilterValue(args.action_filter);
-        q = q.ilike("action", `%${sf}%`);
+        const sq = sanitizeFilterValue(query);
+        // Parallel: ClickHouse telemetry + Postgres business audit
+        const [chSpans, pgResult] = await Promise.all([
+            ch.isEnabled
+                ? ch.query(`
+            SELECT
+              span_id AS id, operation_name AS action, severity, source,
+              '' AS resource_type, tool_name AS resource_id,
+              user_id AS user_email, attributes AS details, started_at AS created_at
+            FROM ai_spans
+            WHERE store_id = '${escQ(sid)}'
+              AND started_at >= '${cutoff}'
+              AND (operation_name ILIKE '%${escQ(sq)}%' OR error_message ILIKE '%${escQ(sq)}%' OR tool_name ILIKE '%${escQ(sq)}%')
+            ORDER BY started_at DESC
+            LIMIT ${rowLimit}
+          `)
+                : Promise.resolve([]),
+            sb.from("business_audit")
+                .select("id, action, severity, source, resource_type, resource_id, details, created_at")
+                .eq("store_id", sid)
+                .gte("created_at", cutoff)
+                .in("action", BUSINESS_ACTIONS)
+                .or(`action.ilike.%${sq}%,resource_id.ilike.%${sq}%`)
+                .order("created_at", { ascending: false })
+                .limit(rowLimit),
+        ]);
+        const entries = [...chSpans, ...(pgResult.data || [])]
+            .sort((a, b) => String(b.created_at).localeCompare(String(a.created_at)))
+            .slice(0, rowLimit);
+        return { success: true, data: { query, entries, count: entries.length, days } };
     }
-    if (args.resource_type)
-        q = q.eq("resource_type", args.resource_type);
-    if (args.severity)
-        q = q.eq("severity", args.severity);
-    if (args.source)
-        q = q.eq("source", args.source);
-    const { data, error } = await q;
-    if (error)
-        return { success: false, error: error.message };
+    // Default action: dual-read filtered list
+    const actionFilter = args.action_filter ? sanitizeFilterValue(args.action_filter) : null;
+    const severityFilter = args.severity;
+    const sourceFilter = args.source;
+    // Build ClickHouse filters
+    const chFilters = [`store_id = '${escQ(sid)}'`, `started_at >= '${cutoff}'`];
+    if (actionFilter)
+        chFilters.push(`operation_name ILIKE '%${escQ(actionFilter)}%'`);
+    if (severityFilter)
+        chFilters.push(`severity = '${escQ(severityFilter)}'`);
+    if (sourceFilter)
+        chFilters.push(`source = '${escQ(sourceFilter)}'`);
+    const [chSpans, pgResult] = await Promise.all([
+        ch.isEnabled
+            ? ch.query(`
+          SELECT
+            span_id AS id, operation_name AS action, severity, source,
+            '' AS resource_type, tool_name AS resource_id,
+            attributes AS details, user_id AS user_email, started_at AS created_at
+          FROM ai_spans
+          WHERE ${chFilters.join(" AND ")}
+          ORDER BY started_at DESC
+          LIMIT ${rowLimit}
+        `)
+            : Promise.resolve([]),
+        (() => {
+            let q = sb.from("business_audit")
+                .select("id, action, severity, source, resource_type, resource_id, details, created_at")
+                .eq("store_id", sid)
+                .gte("created_at", cutoff)
+                .in("action", BUSINESS_ACTIONS)
+                .order("created_at", { ascending: false })
+                .limit(rowLimit);
+            if (actionFilter)
+                q = q.ilike("action", `%${actionFilter}%`);
+            if (args.resource_type)
+                q = q.eq("resource_type", args.resource_type);
+            if (severityFilter)
+                q = q.eq("severity", severityFilter);
+            if (sourceFilter)
+                q = q.eq("source", sourceFilter);
+            return q;
+        })(),
+    ]);
+    const entries = [...chSpans, ...(pgResult.data || [])]
+        .sort((a, b) => String(b.created_at).localeCompare(String(a.created_at)))
+        .slice(0, rowLimit);
     // Summarize by action for quick overview
     const byAction = {};
-    for (const entry of data || []) {
-        byAction[entry.action] = (byAction[entry.action] || 0) + 1;
+    for (const entry of entries) {
+        const act = entry.action;
+        byAction[act] = (byAction[act] || 0) + 1;
     }
-    return { success: true, data: { entries: data, summary: byAction, days, count: data?.length || 0 } };
+    return { success: true, data: { entries, summary: byAction, days, count: entries.length } };
 }

package/dist/server/handlers/platform.js

@@ -1,15 +1,21 @@
+import { getClickHouseClient } from "../lib/clickhouse-client.js";
+/** Escape single quotes for ClickHouse SQL */
+function esc(s) {
+    return s.replace(/'/g, "\\'");
+}
 export async function handleWebSearch(sb, args, _storeId) {
     const query = args.query;
     const numResults = args.num_results || 5;
+    // Validate input first (cheap, no DB call)
+    if (!query) {
+        return { success: false, error: "Query parameter is required" };
+    }
     // Read from platform_secrets table first, fall back to env var
     const { data: secret } = await sb.from("platform_secrets").select("value").eq("key", "exa_api_key").single();
     const exaApiKey = secret?.value || process.env["EXA_API_KEY"];
     if (!exaApiKey) {
         return { success: false, error: "Exa API key not configured. Add 'exa_api_key' to platform_secrets table." };
     }
-    if (!query) {
-        return { success: false, error: "Query parameter is required" };
-    }
     try {
         const response = await fetch("https://api.exa.ai/search", {
             method: "POST",
@@ -47,28 +53,43 @@ export async function handleTelemetry(sb, args, storeId) {
     const hoursBack = args.hours_back || 24;
     const limit = Math.min(args.limit || 50, 200);
     switch (args.action) {
-        // ---- conversation_detail: Full conversation with messages + audit entries ----
+        // ---- conversation_detail: Full conversation with messages + ClickHouse spans ----
         case "conversation_detail": {
             const convId = args.conversation_id;
             if (!convId)
                 return { success: false, error: "conversation_id is required" };
-            const [convResult, msgResult, auditResult] = await Promise.all([
-                sb.from("ai_conversations").select("*").eq("id", convId).eq("store_id", sid).single(),
-                sb.from("ai_messages").select("*").eq("conversation_id", convId).order("created_at", { ascending: true }),
-                sb.from("audit_logs").select("id, action, severity, duration_ms, status_code, error_message, resource_id, input_tokens, output_tokens, model, created_at")
-                    .eq("conversation_id", convId).order("created_at", { ascending: true }).limit(200)
-            ]);
+            // Verify conversation belongs to this store first
+            const convResult = await sb.from("ai_conversations").select("*").eq("id", convId).eq("store_id", sid).single();
             if (convResult.error)
                 return { success: false, error: convResult.error.message };
+            // Fetch messages from Postgres + spans from ClickHouse in parallel
+            const ch = getClickHouseClient();
+            const [msgResult, spans] = await Promise.all([
+                sb.from("ai_messages").select("*").eq("conversation_id", convId).order("created_at", { ascending: true }),
+                ch.isEnabled
+                    ? ch.query(`
+              SELECT
+                span_id AS id, operation_name AS action, severity,
+                duration_ms, status_code, error_message,
+                tool_name AS resource_id,
+                prompt_tokens AS input_tokens, completion_tokens AS output_tokens,
+                model_name AS model, started_at AS created_at
+              FROM ai_spans
+              WHERE conversation_id = '${esc(convId)}'
+              ORDER BY started_at ASC
+              LIMIT 200
+            `)
+                    : Promise.resolve([]),
+            ]);
             return {
                 success: true,
                 data: {
                     conversation: convResult.data,
                     messages: msgResult.data || [],
-                    audit_entries: auditResult.data || [],
+                    audit_entries: spans,
                     message_count: msgResult.data?.length || 0,
-                    audit_count: auditResult.data?.length || 0
-                }
+                    audit_count: spans.length,
+                },
             };
         }
         // ---- conversations: List recent conversations ----
@@ -98,128 +119,224 @@ export async function handleTelemetry(sb, args, storeId) {
             const { data, error } = await sb.rpc("get_agent_analytics", { p_agent_id: agentId, p_days: days });
             return error ? { success: false, error: error.message } : { success: true, data };
         }
-        // ---- tool_analytics: Per-tool performance metrics via RPC ----
+        // ---- tool_analytics: Per-tool performance metrics via direct ClickHouse ----
         case "tool_analytics": {
-            const { data, error } = await sb.rpc("get_tool_analytics", {
-                p_store_id: sid,
-                p_hours_back: hoursBack,
-                p_tool_name: args.tool_name || null
-            });
-            return error ? { success: false, error: error.message } : { success: true, data };
+            const ch = getClickHouseClient();
+            if (!ch.isEnabled)
+                return { success: false, error: "ClickHouse not configured" };
+            const toolFilter = args.tool_name ? `AND tool_name = '${esc(args.tool_name)}'` : "";
+            const storeF = sid ? `AND store_id = '${esc(sid)}'` : "";
+            const tools = await ch.query(`
+        SELECT
+          tool_name,
+          count() AS total_calls,
+          countIf(status_code = 'OK') AS success_count,
+          countIf(status_code = 'ERROR') AS error_count,
+          countIf(duration_ms > 30000) AS timeout_count,
+          round(avg(duration_ms), 1) AS avg_ms,
+          round(quantile(0.50)(duration_ms), 1) AS p50_ms,
+          round(quantile(0.90)(duration_ms), 1) AS p90_ms,
+          round(quantile(0.95)(duration_ms), 1) AS p95_ms,
+          round(quantile(0.99)(duration_ms), 1) AS p99_ms,
+          min(duration_ms) AS min_ms,
+          max(duration_ms) AS max_ms,
+          round(100.0 * countIf(status_code = 'ERROR') / count(), 2) AS error_rate,
+          round(sum(token_cost_usd), 6) AS total_marginal_cost,
+          min(started_at) AS first_call,
+          max(started_at) AS last_call,
+          round(count() / greatest(dateDiff('minute', min(started_at), max(started_at)), 1), 2) AS calls_per_minute,
+          round(greatest(0, 100.0 - 100.0 * countIf(status_code = 'ERROR') / count() - 100.0 * countIf(duration_ms > 30000) / count()), 1) AS reliability_score
+        FROM ai_spans
+        WHERE started_at >= now() - INTERVAL ${hoursBack} HOUR
+          AND tool_name IS NOT NULL AND tool_name != ''
+          ${storeF} ${toolFilter}
+        GROUP BY tool_name
+        ORDER BY total_calls DESC
+      `);
+            const totalCalls = tools.reduce((s, t) => s + (t.total_calls || 0), 0);
+            const totalErrors = tools.reduce((s, t) => s + (t.error_count || 0), 0);
+            const totalTimeouts = tools.reduce((s, t) => s + (t.timeout_count || 0), 0);
+            const totalCost = tools.reduce((s, t) => s + (t.total_marginal_cost || 0), 0);
+            return { success: true, data: {
+                    tools,
+                    summary: {
+                        total_calls: totalCalls, total_errors: totalErrors, total_timeouts: totalTimeouts,
+                        overall_error_rate: totalCalls > 0 ? Math.round(10000 * totalErrors / totalCalls) / 100 : 0,
+                        unique_tools: tools.length, total_marginal_cost: Math.round(totalCost * 1e6) / 1e6,
+                        hours_analyzed: hoursBack,
+                    },
+                } };
         }
-        // ---- tool_timeline: Time-bucketed tool metrics via RPC ----
+        // ---- tool_timeline: Time-bucketed tool metrics via direct ClickHouse ----
         case "tool_timeline": {
+            const ch = getClickHouseClient();
+            if (!ch.isEnabled)
+                return { success: false, error: "ClickHouse not configured" };
             const bucketMinutes = args.bucket_minutes || 15;
-            const { data, error } = await sb.rpc("get_tool_timeline", {
-                p_store_id: sid,
-                p_hours_back: hoursBack,
-                p_bucket_minutes: bucketMinutes,
-                p_tool_name: args.tool_name || null
-            });
-            return error ? { success: false, error: error.message } : { success: true, data };
+            const toolFilter = args.tool_name ? `AND tool_name = '${esc(args.tool_name)}'` : "";
+            const storeF = sid ? `AND store_id = '${esc(sid)}'` : "";
+            const buckets = await ch.query(`
+        SELECT
+          toStartOfInterval(started_at, INTERVAL ${bucketMinutes} MINUTE) AS time,
+          tool_name AS tool,
+          count() AS calls,
+          countIf(status_code = 'ERROR') AS errors,
+          countIf(duration_ms > 30000) AS timeouts,
+          round(avg(duration_ms), 1) AS avg_ms,
+          round(quantile(0.95)(duration_ms), 1) AS p95_ms,
+          max(duration_ms) AS max_ms
+        FROM ai_spans
+        WHERE started_at >= now() - INTERVAL ${hoursBack} HOUR
+          AND tool_name IS NOT NULL AND tool_name != ''
+          ${storeF} ${toolFilter}
+        GROUP BY time, tool
+        ORDER BY time ASC, tool
+      `);
+            return { success: true, data: { bucket_minutes: bucketMinutes, hours_back: hoursBack, buckets } };
         }
-        // ---- trace: Full trace reconstruction via RPC ----
+        // ---- trace: Full trace reconstruction via direct ClickHouse ----
         case "trace": {
             const traceId = args.trace_id;
             if (!traceId)
                 return { success: false, error: "trace_id is required" };
-            // Verify trace belongs to this store
-            const { data: traceLog } = await sb.from("audit_logs").select("id").eq("trace_id", traceId).eq("store_id", sid).limit(1);
-            if (!traceLog?.length)
-                return { success: false, error: "Trace not found for this store" };
-            const { data, error } = await sb.rpc("get_trace", { p_trace_id: traceId });
-            return error ? { success: false, error: error.message } : { success: true, data };
+            const ch = getClickHouseClient();
+            if (!ch.isEnabled)
+                return { success: false, error: "ClickHouse not configured" };
+            const spans = await ch.query(`
+        SELECT
+          span_id, parent_span_id, trace_id, operation_name,
+          service_name, duration_ms AS duration,
+          started_at, ended_at,
+          if(status_code = 'ERROR', 'error', 'ok') AS status,
+          attributes, events
+        FROM ai_spans
+        WHERE trace_id = '${esc(traceId)}'
+        ORDER BY started_at ASC
+      `);
+            return { success: true, data: { trace_id: traceId, spans } };
         }
-        // ---- span_detail: Individual span deep-dive via RPC ----
+        // ---- span_detail: Individual span deep-dive via direct ClickHouse ----
         case "span_detail": {
             const spanId = args.span_id;
             if (!spanId)
                 return { success: false, error: "span_id is required" };
-            // Verify span belongs to this store via audit_logs
-            const { data: spanLog } = await sb.from("audit_logs").select("id").eq("id", spanId).eq("store_id", sid).limit(1);
-            if (!spanLog?.length)
-                return { success: false, error: "Span not found for this store" };
-            const { data, error } = await sb.rpc("get_tool_trace_detail", { p_span_id: spanId });
-            return error ? { success: false, error: error.message } : { success: true, data };
+            const ch = getClickHouseClient();
+            if (!ch.isEnabled)
+                return { success: false, error: "ClickHouse not configured" };
+            const spans = await ch.query(`
+        SELECT
+          span_id, operation_name, tool_name, severity, duration_ms,
+          status_code, error_message, started_at, ended_at,
+          trace_id, span_kind, service_name, model_name,
+          conversation_id, attributes
+        FROM ai_spans
+        WHERE span_id = '${esc(spanId)}'
+        LIMIT 1
+      `);
+            if (spans.length === 0)
+                return { success: false, error: "Span not found" };
+            const span = spans[0];
+            // Comparison metrics for this tool (24h lookback)
+            const toolName = span.tool_name;
+            let comparison = {};
+            if (toolName) {
+                const comp = await ch.query(`
+          SELECT
+            round(avg(duration_ms), 1) AS avg_ms,
+            round(quantile(0.95)(duration_ms), 1) AS p95_ms,
+            round(100.0 * countIf(status_code = 'ERROR') / count(), 2) AS error_rate,
+            count() AS total_calls_24h
+          FROM ai_spans
+          WHERE tool_name = '${esc(toolName)}'
+            AND started_at >= now() - INTERVAL 24 HOUR
+        `);
+                if (comp.length > 0) {
+                    comparison = {
+                        ...comp[0],
+                        is_slow: span.duration_ms > (comp[0].p95_ms || 999999),
+                    };
+                }
+            }
+            return { success: true, data: { span, comparison } };
         }
-        // ---- error_patterns: Error correlation + burst detection via RPC ----
+        // ---- error_patterns: Error correlation + burst detection via ClickHouse ----
         case "error_patterns": {
-            const { data, error } = await sb.rpc("get_tool_error_patterns", {
-                p_store_id: sid,
-                p_hours_back: hoursBack
-            });
-            return error ? { success: false, error: error.message } : { success: true, data };
+            const ch = getClickHouseClient();
+            if (!ch.isEnabled)
+                return { success: false, error: "ClickHouse not configured" };
+            const patterns = await ch.query(`
+        SELECT
+          fingerprint,
+          any(error_type) AS error_type,
+          substring(any(error_message), 1, 300) AS message,
+          any(severity) AS severity,
+          any(service_name) AS service,
+          count() AS occurrence_count,
+          min(occurred_at) AS first_seen,
+          max(occurred_at) AS last_seen,
+          uniqExact(trace_id) AS affected_traces,
+          groupUniqArrayIf(service_name, service_name != '')[1] AS primary_service
+        FROM error_events
+        WHERE occurred_at >= now() - INTERVAL ${hoursBack} HOUR
+          ${sid ? `AND store_id = '${esc(sid)}'` : ""}
+        GROUP BY fingerprint
+        ORDER BY occurrence_count DESC
+        LIMIT 50
+      `);
+            return { success: true, data: patterns };
         }
-        // ---- token_usage: Token consumption by model/day ----
+        // ---- token_usage: Token consumption by model/day via ClickHouse ----
         case "token_usage": {
-            const cutoff = new Date(Date.now() - hoursBack * 3600_000).toISOString();
-            // Build base query — if agent_id is provided, get conversation IDs first
-            let conversationFilter = null;
+            const ch = getClickHouseClient();
+            if (!ch.isEnabled)
+                return { success: false, error: "ClickHouse not configured" };
+            const storeF = sid ? `AND store_id = '${esc(sid)}'` : "";
+            let agentFilter = "";
             if (args.agent_id) {
-                const { data: convs } = await sb.from("ai_conversations")
-                    .select("id").eq("agent_id", args.agent_id).eq("store_id", sid);
-                conversationFilter = convs?.map(c => c.id) || [];
-            }
-            let q = sb.from("audit_logs")
-                .select("model, input_tokens, output_tokens, total_cost, created_at")
-                .eq("store_id", sid)
-                .gte("created_at", cutoff)
-                .not("input_tokens", "is", null);
-            if (conversationFilter !== null) {
-                if (conversationFilter.length === 0)
-                    return { success: true, data: { rows: [], summary: { total_input: 0, total_output: 0, total_cost: 0 } } };
-                q = q.in("conversation_id", conversationFilter);
+                agentFilter = `AND agent_id = '${esc(args.agent_id)}'`;
             }
-            const { data, error } = await q.order("created_at", { ascending: false }).limit(1000);
-            if (error)
-                return { success: false, error: error.message };
-            // Aggregate in-memory by model + day
-            const buckets = {};
-            for (const row of data || []) {
-                const day = row.created_at.substring(0, 10);
-                const model = row.model || "unknown";
-                const key = `${model}|${day}`;
-                if (!buckets[key])
-                    buckets[key] = { model, day, requests: 0, input_tokens: 0, output_tokens: 0, total_cost: 0 };
-                buckets[key].requests++;
-                buckets[key].input_tokens += row.input_tokens || 0;
-                buckets[key].output_tokens += row.output_tokens || 0;
-                buckets[key].total_cost += parseFloat(row.total_cost || "0");
-            }
-            const rows = Object.values(buckets).sort((a, b) => b.day.localeCompare(a.day) || b.total_cost - a.total_cost);
+            const rows = await ch.query(`
+        SELECT
+          model_name AS model,
+          toDate(hour) AS day,
+          sum(request_count) AS requests,
+          sum(prompt_tokens) AS input_tokens,
+          sum(completion_tokens) AS output_tokens,
+          round(sum(total_cost_usd), 6) AS total_cost
+        FROM token_usage_hourly
+        WHERE hour >= now() - INTERVAL ${hoursBack} HOUR
+          ${storeF} ${agentFilter}
+        GROUP BY model_name, toDate(hour)
+        ORDER BY day DESC, total_cost DESC
+      `);
             const summary = rows.reduce((acc, r) => ({
                 total_input: acc.total_input + r.input_tokens,
                 total_output: acc.total_output + r.output_tokens,
                 total_cost: acc.total_cost + r.total_cost,
-                total_requests: acc.total_requests + r.requests
+                total_requests: acc.total_requests + r.requests,
             }), { total_input: 0, total_output: 0, total_cost: 0, total_requests: 0 });
             return { success: true, data: { rows, summary, hours_back: hoursBack } };
         }
-        // ---- sources: List all telemetry sources with counts ----
+        // ---- sources: List all telemetry sources with counts via ClickHouse ----
         case "sources": {
-            const cutoff = new Date(Date.now() - hoursBack * 3600_000).toISOString();
-            const { data, error } = await sb.from("audit_logs")
-                .select("source, severity, created_at")
-                .eq("store_id", sid)
-                .gte("created_at", cutoff)
-                .not("source", "is", null)
-                .limit(1000);
-            if (error)
-                return { success: false, error: error.message };
-            // Aggregate by source
-            const sourceMap = {};
-            for (const row of data || []) {
-                const src = row.source;
-                if (!sourceMap[src])
-                    sourceMap[src] = { source: src, count: 0, errors: 0, last_seen: row.created_at };
-                sourceMap[src].count++;
-                if (row.severity === "error")
-                    sourceMap[src].errors++;
-                if (row.created_at > sourceMap[src].last_seen)
-                    sourceMap[src].last_seen = row.created_at;
-            }
-            const sources = Object.values(sourceMap).sort((a, b) => b.count - a.count);
-            return { success: true, data: { sources, total_entries: data?.length || 0, hours_back: hoursBack } };
+            const ch = getClickHouseClient();
+            if (!ch.isEnabled)
+                return { success: false, error: "ClickHouse not configured" };
+            const storeF = sid ? `AND store_id = '${esc(sid)}'` : "";
+            const sources = await ch.query(`
+        SELECT
+          source,
+          count() AS count,
+          countIf(severity = 'error') AS errors,
+          max(started_at) AS last_seen
+        FROM ai_spans
+        WHERE started_at >= now() - INTERVAL ${hoursBack} HOUR
+          AND source IS NOT NULL AND source != ''
+          ${storeF}
+        GROUP BY source
+        ORDER BY count DESC
+      `);
+            return { success: true, data: { sources, total_entries: sources.reduce((s, r) => s + r.count, 0), hours_back: hoursBack } };
         }
         default:
             return { success: false, error: `Unknown telemetry action: ${args.action}. Available: conversation_detail, conversations, agent_performance, tool_analytics, tool_timeline, trace, span_detail, error_patterns, token_usage, sources. For activity logs and inventory changes, use the audit_trail tool instead.` };

package/dist/server/handlers/remove-bg.d.ts

@@ -0,0 +1,6 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+export declare function handleRemoveBg(sb: SupabaseClient, args: Record<string, unknown>, storeId?: string): Promise<{
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}>;