@alejandroroman/agent-kit 0.1.0

package/dist/tools/builtin/web-search.js

@@ -0,0 +1,99 @@
+const XAI_API_ENDPOINT = "https://api.x.ai/v1/responses";
+const DEFAULT_GROK_MODEL = "grok-4-1-fast";
+function extractGrokContent(data) {
+    for (const output of data.output ?? []) {
+        if (output.type !== "message")
+            continue;
+        for (const block of output.content ?? []) {
+            if (block.type === "output_text" && block.text) {
+                const urls = (block.annotations ?? [])
+                    .filter((a) => a.type === "url_citation" && a.url)
+                    .map((a) => a.url);
+                return { text: block.text, citations: [...new Set(urls)] };
+            }
+        }
+    }
+    return { text: data.output_text ?? "No results found.", citations: [] };
+}
+export function createWebSearchTool(options) {
+    const provider = options?.provider ?? "brave";
+    const description = provider === "grok"
+        ? "Search the web using xAI Grok. Returns AI-synthesized answers with citations from real-time web search. The count parameter is ignored for this provider."
+        : "Search the web using Brave Search. Returns titles, URLs, and snippets for the top results.";
+    return {
+        name: "web_search",
+        description,
+        parameters: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Search query" },
+                count: {
+                    type: "number",
+                    description: "Number of results to return (default 5)",
+                },
+            },
+            required: ["query"],
+        },
+        execute: async (args) => {
+            try {
+                const query = args.query;
+                const rawCount = args.count ?? 5;
+                const count = Math.max(1, Math.min(20, Math.floor(rawCount)));
+                if (provider === "grok") {
+                    const apiKey = process.env.XAI_API_KEY;
+                    if (!apiKey)
+                        return "Error: XAI_API_KEY is not set";
+                    const model = options?.grok?.model ?? DEFAULT_GROK_MODEL;
+                    const res = await fetch(XAI_API_ENDPOINT, {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json",
+                            Authorization: `Bearer ${apiKey}`,
+                        },
+                        body: JSON.stringify({
+                            model,
+                            input: [{ role: "user", content: query }],
+                            tools: [{ type: "web_search" }],
+                        }),
+                    });
+                    if (!res.ok)
+                        return `Error: xAI API returned ${res.status} ${res.statusText}`;
+                    const data = (await res.json());
+                    const { text, citations } = extractGrokContent(data);
+                    const parts = [text];
+                    if (citations.length > 0) {
+                        parts.push("\nSources:\n" + citations.map((u) => `- ${u}`).join("\n"));
+                    }
+                    return parts.join("\n");
+                }
+                const apiKey = process.env.BRAVE_SEARCH_API_KEY;
+                if (!apiKey) {
+                    return "Error: BRAVE_SEARCH_API_KEY is not set";
+                }
+                const url = new URL("https://api.search.brave.com/res/v1/web/search");
+                url.searchParams.set("q", query);
+                url.searchParams.set("count", String(count));
+                const res = await fetch(url.toString(), {
+                    headers: {
+                        "X-Subscription-Token": apiKey,
+                        Accept: "application/json",
+                    },
+                });
+                if (!res.ok) {
+                    return `Error: Brave Search API returned ${res.status} ${res.statusText}`;
+                }
+                const data = (await res.json());
+                const results = data.web?.results ?? [];
+                if (results.length === 0) {
+                    return "No results found.";
+                }
+                return results
+                    .map((r) => `${r.title}\n${r.url}\n${r.description}`)
+                    .join("\n\n");
+            }
+            catch (err) {
+                return `Error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    };
+}

package/dist/tools/builtin/write-file.d.ts

@@ -0,0 +1,3 @@
+import type { Tool } from "../types.js";
+export declare function createWriteFileTool(allowedPaths?: string[]): Tool;
+export declare const writeFileTool: Tool;

package/dist/tools/builtin/write-file.js

@@ -0,0 +1,34 @@
+import * as fs from "fs";
+import * as path from "path";
+import { validatePath } from "../sandbox.js";
+export function createWriteFileTool(allowedPaths) {
+    return {
+        name: "write_file",
+        description: "Write content to a file. Creates parent directories if needed.",
+        parameters: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Absolute path to the file" },
+                content: { type: "string", description: "Content to write" },
+            },
+            required: ["path", "content"],
+        },
+        execute: async (args) => {
+            try {
+                const filePath = args.path;
+                const validation = validatePath(filePath, allowedPaths);
+                if (!validation.allowed) {
+                    return validation.error;
+                }
+                fs.mkdirSync(path.dirname(filePath), { recursive: true });
+                fs.writeFileSync(filePath, args.content);
+                return `Wrote to ${filePath}`;
+            }
+            catch (err) {
+                return `Error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    };
+}
+// Backwards-compatible default export (unrestricted)
+export const writeFileTool = createWriteFileTool();

package/dist/tools/registry.d.ts

@@ -0,0 +1,10 @@
+import type { Tool } from "./types.js";
+export declare class ToolRegistry {
+    private tools;
+    register(tool: Tool): void;
+    resolve(names: string[]): Tool[];
+    list(): string[];
+    validateAgents(agents: Record<string, {
+        tools: string[];
+    }>): void;
+}

package/dist/tools/registry.js

@@ -0,0 +1,26 @@
+export class ToolRegistry {
+    tools = new Map();
+    register(tool) {
+        this.tools.set(tool.name, tool);
+    }
+    resolve(names) {
+        return names.map((name) => {
+            const tool = this.tools.get(name);
+            if (!tool)
+                throw new Error(`Unknown tool "${name}"`);
+            return tool;
+        });
+    }
+    list() {
+        return [...this.tools.keys()];
+    }
+    validateAgents(agents) {
+        for (const [agentName, agent] of Object.entries(agents)) {
+            for (const toolName of agent.tools) {
+                if (!this.tools.has(toolName)) {
+                    throw new Error(`Unknown tool "${toolName}" for agent "${agentName}"`);
+                }
+            }
+        }
+    }
+}

package/dist/tools/sandbox.d.ts

@@ -0,0 +1,9 @@
+export interface ValidationResult {
+    allowed: boolean;
+    denied: string[];
+    error?: string;
+}
+export declare function parseCommandSegments(command: string): string[];
+export declare function containsShellMetachars(command: string): boolean;
+export declare function validateCommand(command: string, allowedCommands: string[] | undefined): ValidationResult;
+export declare function validatePath(filePath: string, allowedPaths: string[] | undefined): ValidationResult;

package/dist/tools/sandbox.js

@@ -0,0 +1,74 @@
+import * as fs from "fs";
+import * as path from "path";
+export function parseCommandSegments(command) {
+    if (!command.trim())
+        return [];
+    return command
+        .split(/\s*(?:\|\||&&|;|\||\r?\n)\s*/)
+        .map((seg) => seg.trim().split(/\s+/)[0])
+        .filter(Boolean);
+}
+export function containsShellMetachars(command) {
+    return /`|\$\(|<\(|>\(|(?:^|[^>&])&(?!&)|[\r\n]/.test(command);
+}
+export function validateCommand(command, allowedCommands) {
+    if (!allowedCommands)
+        return { allowed: true, denied: [] };
+    if (containsShellMetachars(command)) {
+        return {
+            allowed: false,
+            denied: [],
+            error: "Error: Shell metacharacters are not allowed in sandboxed commands.",
+        };
+    }
+    const segments = parseCommandSegments(command);
+    const denied = segments.filter((cmd) => !allowedCommands.includes(cmd));
+    if (denied.length === 0)
+        return { allowed: true, denied: [] };
+    return {
+        allowed: false,
+        denied,
+        error: `Error: Command "${denied.join('", "')}" is not allowed. Allowed commands: ${allowedCommands.join(", ")}`,
+    };
+}
+/**
+ * Resolve a path to its canonical form, following symlinks.
+ * For paths that don't exist yet (write case), resolve the parent directory
+ * and append the basename to prevent symlink escapes.
+ */
+function resolveRealPath(filePath) {
+    try {
+        return fs.realpathSync(filePath);
+    }
+    catch {
+        // File doesn't exist yet — resolve parent + basename
+        const dir = path.dirname(filePath);
+        try {
+            return path.join(fs.realpathSync(dir), path.basename(filePath));
+        }
+        catch {
+            // Parent doesn't exist either — fall back to path.resolve
+            return path.resolve(filePath);
+        }
+    }
+}
+function isPathWithinAllowedPath(realFilePath, realAllowedPath) {
+    if (realFilePath === realAllowedPath)
+        return true;
+    const relative = path.relative(realAllowedPath, realFilePath);
+    return Boolean(relative) && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+export function validatePath(filePath, allowedPaths) {
+    if (!allowedPaths)
+        return { allowed: true, denied: [] };
+    const realFilePath = resolveRealPath(filePath);
+    const realAllowedPaths = allowedPaths.map((p) => resolveRealPath(p));
+    const allowed = realAllowedPaths.some((ap) => isPathWithinAllowedPath(realFilePath, ap));
+    if (allowed)
+        return { allowed: true, denied: [] };
+    return {
+        allowed: false,
+        denied: [realFilePath],
+        error: `Error: Path "${realFilePath}" is not allowed. Allowed paths: ${realAllowedPaths.join(", ")}`,
+    };
+}

package/dist/tools/types.d.ts

@@ -0,0 +1,8 @@
+import type { ToolDefinition } from "../llm/types.js";
+export interface Tool {
+    name: string;
+    description: string;
+    parameters: ToolDefinition["parameters"];
+    execute: (args: Record<string, unknown>) => Promise<string>;
+}
+export declare function toolToDefinition(tool: Tool): ToolDefinition;

package/dist/tools/types.js

@@ -0,0 +1,7 @@
+export function toolToDefinition(tool) {
+    return {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters,
+    };
+}

package/dist/usage/index.d.ts

@@ -0,0 +1,4 @@
+export { createUsageStore, type UsageStore } from "./store.js";
+export { estimateCost, PRICING } from "./pricing.js";
+export { GROUP_BY_VALUES } from "./types.js";
+export type { LLMCallRecord, AgentRunRecord, CallFilters, RunFilters, GroupBy, SummaryFilters, UsageSummaryRow, } from "./types.js";

package/dist/usage/index.js

@@ -0,0 +1,3 @@
+export { createUsageStore } from "./store.js";
+export { estimateCost, PRICING } from "./pricing.js";
+export { GROUP_BY_VALUES } from "./types.js";

package/dist/usage/pricing.d.ts

@@ -0,0 +1,10 @@
+import type { TokenUsage } from "../llm/types.js";
+interface ModelPricing {
+    inputPerMTok: number;
+    outputPerMTok: number;
+    cacheCreationPerMTok: number;
+    cacheReadPerMTok: number;
+}
+declare const PRICING: Record<string, ModelPricing>;
+export declare function estimateCost(model: string, usage: TokenUsage): number;
+export { PRICING };

package/dist/usage/pricing.js

@@ -0,0 +1,35 @@
+import { createLogger } from "../logger.js";
+const log = createLogger("pricing");
+const PRICING = {
+    "anthropic:claude-opus-4-6": {
+        inputPerMTok: 5,
+        outputPerMTok: 25,
+        cacheCreationPerMTok: 6.25,
+        cacheReadPerMTok: 0.5,
+    },
+    "anthropic:claude-sonnet-4-6": {
+        inputPerMTok: 3,
+        outputPerMTok: 15,
+        cacheCreationPerMTok: 3.75,
+        cacheReadPerMTok: 0.3,
+    },
+    "anthropic:claude-haiku-4-5-20251001": {
+        inputPerMTok: 1,
+        outputPerMTok: 5,
+        cacheCreationPerMTok: 1.25,
+        cacheReadPerMTok: 0.1,
+    },
+};
+export function estimateCost(model, usage) {
+    const pricing = PRICING[model];
+    if (!pricing) {
+        log.warn({ model }, "no pricing data for model");
+        return 0;
+    }
+    return ((usage.inputTokens * pricing.inputPerMTok +
+        usage.outputTokens * pricing.outputPerMTok +
+        usage.cacheCreationTokens * pricing.cacheCreationPerMTok +
+        usage.cacheReadTokens * pricing.cacheReadPerMTok) /
+        1_000_000);
+}
+export { PRICING };

package/dist/usage/schema.d.ts

@@ -0,0 +1 @@
+export declare const USAGE_SCHEMA_SQL = "\nCREATE TABLE IF NOT EXISTS llm_calls (\n  id TEXT PRIMARY KEY,\n  run_id TEXT NOT NULL,\n  agent_name TEXT NOT NULL,\n  provider TEXT NOT NULL,\n  model TEXT NOT NULL,\n  input_tokens INTEGER NOT NULL DEFAULT 0,\n  output_tokens INTEGER NOT NULL DEFAULT 0,\n  cache_creation_tokens INTEGER NOT NULL DEFAULT 0,\n  cache_read_tokens INTEGER NOT NULL DEFAULT 0,\n  reasoning_tokens INTEGER NOT NULL DEFAULT 0,\n  stop_reason TEXT NOT NULL,\n  latency_ms INTEGER NOT NULL DEFAULT 0,\n  estimated_cost_usd REAL NOT NULL DEFAULT 0,\n  created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))\n);\n\nCREATE INDEX IF NOT EXISTS idx_llm_calls_run_id ON llm_calls(run_id);\nCREATE INDEX IF NOT EXISTS idx_llm_calls_agent_name ON llm_calls(agent_name);\nCREATE INDEX IF NOT EXISTS idx_llm_calls_model ON llm_calls(model);\nCREATE INDEX IF NOT EXISTS idx_llm_calls_created_at ON llm_calls(created_at);\n\nCREATE TABLE IF NOT EXISTS agent_runs (\n  id TEXT PRIMARY KEY,\n  agent_name TEXT NOT NULL,\n  source TEXT NOT NULL,\n  model TEXT NOT NULL,\n  total_input_tokens INTEGER NOT NULL DEFAULT 0,\n  total_output_tokens INTEGER NOT NULL DEFAULT 0,\n  total_cache_creation_tokens INTEGER NOT NULL DEFAULT 0,\n  total_cache_read_tokens INTEGER NOT NULL DEFAULT 0,\n  total_reasoning_tokens INTEGER NOT NULL DEFAULT 0,\n  iterations INTEGER NOT NULL DEFAULT 0,\n  tool_calls_count INTEGER NOT NULL DEFAULT 0,\n  estimated_cost_usd REAL NOT NULL DEFAULT 0,\n  duration_ms INTEGER NOT NULL DEFAULT 0,\n  created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))\n);\n\nCREATE INDEX IF NOT EXISTS idx_agent_runs_agent_name ON agent_runs(agent_name);\nCREATE INDEX IF NOT EXISTS idx_agent_runs_source ON agent_runs(source);\nCREATE INDEX IF NOT EXISTS idx_agent_runs_model ON agent_runs(model);\nCREATE INDEX IF NOT EXISTS idx_agent_runs_created_at ON agent_runs(created_at);\n";

package/dist/usage/schema.js

@@ -0,0 +1,45 @@
+export const USAGE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS llm_calls (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL,
+  agent_name TEXT NOT NULL,
+  provider TEXT NOT NULL,
+  model TEXT NOT NULL,
+  input_tokens INTEGER NOT NULL DEFAULT 0,
+  output_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_creation_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+  reasoning_tokens INTEGER NOT NULL DEFAULT 0,
+  stop_reason TEXT NOT NULL,
+  latency_ms INTEGER NOT NULL DEFAULT 0,
+  estimated_cost_usd REAL NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_llm_calls_run_id ON llm_calls(run_id);
+CREATE INDEX IF NOT EXISTS idx_llm_calls_agent_name ON llm_calls(agent_name);
+CREATE INDEX IF NOT EXISTS idx_llm_calls_model ON llm_calls(model);
+CREATE INDEX IF NOT EXISTS idx_llm_calls_created_at ON llm_calls(created_at);
+
+CREATE TABLE IF NOT EXISTS agent_runs (
+  id TEXT PRIMARY KEY,
+  agent_name TEXT NOT NULL,
+  source TEXT NOT NULL,
+  model TEXT NOT NULL,
+  total_input_tokens INTEGER NOT NULL DEFAULT 0,
+  total_output_tokens INTEGER NOT NULL DEFAULT 0,
+  total_cache_creation_tokens INTEGER NOT NULL DEFAULT 0,
+  total_cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+  total_reasoning_tokens INTEGER NOT NULL DEFAULT 0,
+  iterations INTEGER NOT NULL DEFAULT 0,
+  tool_calls_count INTEGER NOT NULL DEFAULT 0,
+  estimated_cost_usd REAL NOT NULL DEFAULT 0,
+  duration_ms INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_agent_runs_agent_name ON agent_runs(agent_name);
+CREATE INDEX IF NOT EXISTS idx_agent_runs_source ON agent_runs(source);
+CREATE INDEX IF NOT EXISTS idx_agent_runs_model ON agent_runs(model);
+CREATE INDEX IF NOT EXISTS idx_agent_runs_created_at ON agent_runs(created_at);
+`;

package/dist/usage/store.d.ts

@@ -0,0 +1,10 @@
+import type { LLMCallRecord, AgentRunRecord, CallFilters, RunFilters, SummaryFilters, UsageSummaryRow } from "./types.js";
+export interface UsageStore {
+    recordCall(call: LLMCallRecord): void;
+    recordRun(run: AgentRunRecord): void;
+    getCalls(filters: CallFilters): LLMCallRecord[];
+    getRuns(filters: RunFilters): AgentRunRecord[];
+    getSummary(filters: SummaryFilters): UsageSummaryRow[];
+    close(): void;
+}
+export declare function createUsageStore(dbPath: string): UsageStore;

package/dist/usage/store.js

@@ -0,0 +1,227 @@
+import Database from "better-sqlite3";
+import { nanoid } from "nanoid";
+import { USAGE_SCHEMA_SQL } from "./schema.js";
+import { estimateCost } from "./pricing.js";
+export function createUsageStore(dbPath) {
+    const db = new Database(dbPath);
+    db.pragma("journal_mode = WAL");
+    db.exec(USAGE_SCHEMA_SQL);
+    const insertCall = db.prepare(`
+    INSERT INTO llm_calls (id, run_id, agent_name, provider, model, input_tokens, output_tokens,
+      cache_creation_tokens, cache_read_tokens, reasoning_tokens,
+      stop_reason, latency_ms, estimated_cost_usd)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    const insertRun = db.prepare(`
+    INSERT INTO agent_runs (id, agent_name, source, model, total_input_tokens, total_output_tokens,
+      total_cache_creation_tokens, total_cache_read_tokens, total_reasoning_tokens,
+      iterations, tool_calls_count, estimated_cost_usd, duration_ms)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    return {
+        recordCall(call) {
+            const id = call.id ?? nanoid();
+            const cost = call.estimatedCostUsd ?? estimateCost(call.model, call.usage);
+            insertCall.run(id, call.runId, call.agentName, call.provider, call.model, call.usage.inputTokens, call.usage.outputTokens, call.usage.cacheCreationTokens, call.usage.cacheReadTokens, call.usage.reasoningTokens, call.stopReason, call.latencyMs, cost);
+        },
+        recordRun(run) {
+            const cost = run.estimatedCostUsd ?? estimateCost(run.model, run.usage);
+            insertRun.run(run.id, run.agentName, run.source, run.model, run.usage.inputTokens, run.usage.outputTokens, run.usage.cacheCreationTokens, run.usage.cacheReadTokens, run.usage.reasoningTokens, run.iterations, run.toolCallsCount, cost, run.durationMs);
+        },
+        getCalls(filters) {
+            const conditions = [];
+            const params = [];
+            if (filters.model) {
+                conditions.push("model = ?");
+                params.push(filters.model);
+            }
+            if (filters.agentName) {
+                conditions.push("agent_name = ?");
+                params.push(filters.agentName);
+            }
+            if (filters.runId) {
+                conditions.push("run_id = ?");
+                params.push(filters.runId);
+            }
+            if (filters.from) {
+                conditions.push("created_at >= ?");
+                params.push(filters.from);
+            }
+            if (filters.to) {
+                conditions.push("created_at <= ?");
+                params.push(filters.to);
+            }
+            const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+            const limit = filters.limit ?? 50;
+            const offset = filters.offset ?? 0;
+            const rows = db.prepare(`SELECT * FROM llm_calls ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+            return rows.map(rowToCallRecord);
+        },
+        getRuns(filters) {
+            const conditions = [];
+            const params = [];
+            if (filters.agentName) {
+                conditions.push("agent_name = ?");
+                params.push(filters.agentName);
+            }
+            if (filters.source) {
+                conditions.push("source = ?");
+                params.push(filters.source);
+            }
+            if (filters.model) {
+                conditions.push("model = ?");
+                params.push(filters.model);
+            }
+            if (filters.from) {
+                conditions.push("created_at >= ?");
+                params.push(filters.from);
+            }
+            if (filters.to) {
+                conditions.push("created_at <= ?");
+                params.push(filters.to);
+            }
+            const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+            const limit = filters.limit ?? 50;
+            const offset = filters.offset ?? 0;
+            const rows = db.prepare(`SELECT * FROM agent_runs ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+            return rows.map(rowToRunRecord);
+        },
+        getSummary(filters) {
+            const conditions = [];
+            const params = [];
+            if (filters.from) {
+                conditions.push("c.created_at >= ?");
+                params.push(filters.from);
+            }
+            if (filters.to) {
+                conditions.push("c.created_at <= ?");
+                params.push(filters.to);
+            }
+            const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+            const groupCol = (() => {
+                switch (filters.groupBy) {
+                    case "model": return "c.model";
+                    case "agent": return "c.agent_name";
+                    case "source": return "r.source";
+                    case "day": return "date(c.created_at)";
+                    default: return "'all'";
+                }
+            })();
+            if (filters.groupBy === "source") {
+                const rows = db.prepare(`
+          SELECT r.source as grp,
+            SUM(c.input_tokens) as total_input,
+            SUM(c.output_tokens) as total_output,
+            SUM(c.cache_creation_tokens) as total_cache_creation,
+            SUM(c.cache_read_tokens) as total_cache_read,
+            SUM(c.reasoning_tokens) as total_reasoning,
+            SUM(c.estimated_cost_usd) as total_cost,
+            COUNT(DISTINCT c.id) as call_count,
+            COUNT(DISTINCT r.id) as run_count
+          FROM llm_calls c
+          JOIN agent_runs r ON c.run_id = r.id
+          ${where}
+          GROUP BY grp ORDER BY grp
+        `).all(...params);
+                return rows.map(summaryRowMapper);
+            }
+            const callRows = db.prepare(`
+        SELECT ${groupCol} as grp,
+          SUM(input_tokens) as total_input,
+          SUM(output_tokens) as total_output,
+          SUM(cache_creation_tokens) as total_cache_creation,
+          SUM(cache_read_tokens) as total_cache_read,
+          SUM(reasoning_tokens) as total_reasoning,
+          SUM(estimated_cost_usd) as total_cost,
+          COUNT(*) as call_count
+        FROM llm_calls c ${where}
+        GROUP BY grp ORDER BY grp
+      `).all(...params);
+            const runGroupCol = (() => {
+                switch (filters.groupBy) {
+                    case "model": return "model";
+                    case "agent": return "agent_name";
+                    case "day": return "date(created_at)";
+                    default: return "'all'";
+                }
+            })();
+            const runConditions = [];
+            const runParams = [];
+            if (filters.from) {
+                runConditions.push("created_at >= ?");
+                runParams.push(filters.from);
+            }
+            if (filters.to) {
+                runConditions.push("created_at <= ?");
+                runParams.push(filters.to);
+            }
+            const runWhere = runConditions.length > 0 ? `WHERE ${runConditions.join(" AND ")}` : "";
+            const runRows = db.prepare(`
+        SELECT ${runGroupCol} as grp, COUNT(*) as run_count
+        FROM agent_runs ${runWhere}
+        GROUP BY grp
+      `).all(...runParams);
+            const runCountMap = new Map(runRows.map((r) => [String(r.grp), r.run_count]));
+            return callRows.map((row) => ({
+                ...summaryRowMapper(row),
+                runCount: runCountMap.get(String(row.grp)) ?? 0,
+            }));
+        },
+        close() {
+            db.close();
+        },
+    };
+}
+function summaryRowMapper(row) {
+    return {
+        group: String(row.grp),
+        totalInputTokens: row.total_input ?? 0,
+        totalOutputTokens: row.total_output ?? 0,
+        totalCacheCreationTokens: row.total_cache_creation ?? 0,
+        totalCacheReadTokens: row.total_cache_read ?? 0,
+        totalReasoningTokens: row.total_reasoning ?? 0,
+        totalCostUsd: row.total_cost ?? 0,
+        callCount: row.call_count ?? 0,
+        runCount: row.run_count ?? 0,
+    };
+}
+function rowToCallRecord(row) {
+    return {
+        id: row.id,
+        runId: row.run_id,
+        agentName: row.agent_name,
+        provider: row.provider,
+        model: row.model,
+        usage: {
+            inputTokens: row.input_tokens,
+            outputTokens: row.output_tokens,
+            cacheCreationTokens: row.cache_creation_tokens,
+            cacheReadTokens: row.cache_read_tokens,
+            reasoningTokens: row.reasoning_tokens,
+        },
+        stopReason: row.stop_reason,
+        latencyMs: row.latency_ms,
+        estimatedCostUsd: row.estimated_cost_usd,
+        createdAt: row.created_at,
+    };
+}
+function rowToRunRecord(row) {
+    return {
+        id: row.id,
+        agentName: row.agent_name,
+        source: row.source,
+        model: row.model,
+        usage: {
+            inputTokens: row.total_input_tokens,
+            outputTokens: row.total_output_tokens,
+            cacheCreationTokens: row.total_cache_creation_tokens,
+            cacheReadTokens: row.total_cache_read_tokens,
+            reasoningTokens: row.total_reasoning_tokens,
+        },
+        iterations: row.iterations,
+        toolCallsCount: row.tool_calls_count,
+        estimatedCostUsd: row.estimated_cost_usd,
+        durationMs: row.duration_ms,
+        createdAt: row.created_at,
+    };
+}