@alejandroroman/agent-kit 0.1.4 → 0.2.1

package/dist/skills/activate.js

@@ -1,6 +1,32 @@
 import * as fs from "fs";
 import * as path from "path";
 import { loadSkillManifest } from "./loader.js";
+import { SpanStatusCode } from "@opentelemetry/api";
+import { getTracer, ATTR } from "../telemetry/index.js";
+/**
+ * Auto-activate all skills upfront so the LLM doesn't need to call activate_skill.
+ * Returns the skillsIndex string to append to the system prompt.
+ */
+export async function preActivateSkills(ctx, activateTool, logger) {
+    for (const manifest of ctx.manifests) {
+        try {
+            const result = await activateTool.execute({ skill_name: manifest.name });
+            if (typeof result === "string" && result.startsWith("Error")) {
+                logger?.error({ skill: manifest.name, result }, "failed to auto-activate skill");
+            }
+        }
+        catch (err) {
+            logger?.error({ err, skill: manifest.name }, "skill auto-activation threw");
+        }
+    }
+    const activatedNames = [...ctx.activatedSkills];
+    if (activatedNames.length > 0) {
+        return "\n\nThe following skills are pre-activated: "
+            + activatedNames.join(", ")
+            + ".\nTheir tools are already available — you do not need to call activate_skill.";
+    }
+    return "";
+}
 export function createActivateSkillTool(ctx) {
     return {
         name: "activate_skill",
@@ -24,39 +50,58 @@ export function createActivateSkillTool(ctx) {
             if (!manifest) {
                 return `Skill "${skillName}" is not available. Available skills: ${ctx.manifests.map((m) => m.name).join(", ")}`;
             }
-            const skillDir = path.join(ctx.skillsDir, skillName);
-            const fullManifest = loadSkillManifest(skillDir);
-            const loadedTools = [];
-            // Load prompt fragment
-            if (fullManifest.prompt) {
-                const promptPath = path.join(skillDir, fullManifest.prompt);
-                if (fs.existsSync(promptPath)) {
-                    ctx.promptFragments.push(fs.readFileSync(promptPath, "utf-8"));
+            const tracer = getTracer("skills");
+            const span = tracer.startSpan("skill.activate", {
+                attributes: {
+                    [ATTR.SKILL_NAME]: skillName,
+                },
+            });
+            try {
+                const skillDir = path.join(ctx.skillsDir, skillName);
+                const fullManifest = loadSkillManifest(skillDir);
+                const loadedTools = [];
+                // Load prompt fragment
+                if (fullManifest.prompt) {
+                    const promptPath = path.join(skillDir, fullManifest.prompt);
+                    if (fs.existsSync(promptPath)) {
+                        ctx.promptFragments.push(fs.readFileSync(promptPath, "utf-8"));
+                    }
                 }
-            }
-            // Load tools via dynamic import
-            if (fullManifest.tools) {
-                for (const toolName of fullManifest.tools) {
-                    const toolPath = path.join(skillDir, "tools", `${toolName}.ts`);
-                    if (fs.existsSync(toolPath)) {
-                        try {
-                            const mod = await import(toolPath);
-                            const tool = mod.default;
-                            ctx.toolRegistry.register(tool);
-                            loadedTools.push(tool.name);
-                        }
-                        catch (err) {
-                            return `Error loading tool "${toolName}" from skill "${skillName}": ${err instanceof Error ? err.message : String(err)}`;
+                // Load tools via dynamic import
+                if (fullManifest.tools) {
+                    for (const toolName of fullManifest.tools) {
+                        const toolPath = path.join(skillDir, "tools", `${toolName}.ts`);
+                        if (fs.existsSync(toolPath)) {
+                            try {
+                                const mod = await import(toolPath);
+                                const tool = mod.default;
+                                ctx.toolRegistry.register(tool);
+                                loadedTools.push(tool.name);
+                            }
+                            catch (err) {
+                                span.setStatus({ code: SpanStatusCode.ERROR, message: String(err) });
+                                span.recordException(err instanceof Error ? err : new Error(String(err)));
+                                return `Error loading tool "${toolName}" from skill "${skillName}": ${err instanceof Error ? err.message : String(err)}`;
+                            }
                         }
                     }
                 }
+                ctx.activatedSkills.add(skillName);
+                span.setAttribute(ATTR.SKILL_TOOLS_LOADED, loadedTools.length);
+                const parts = [`Skill "${skillName}" activated.`];
+                if (loadedTools.length > 0) {
+                    parts.push(`Tools now available: ${loadedTools.join(", ")}`);
+                }
+                return parts.join(" ");
+            }
+            catch (err) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: String(err) });
+                span.recordException(err instanceof Error ? err : new Error(String(err)));
+                throw err;
             }
-            ctx.activatedSkills.add(skillName);
-            const parts = [`Skill "${skillName}" activated.`];
-            if (loadedTools.length > 0) {
-                parts.push(`Tools now available: ${loadedTools.join(", ")}`);
+            finally {
+                span.end();
             }
-            return parts.join(" ");
         },
     };
 }

package/dist/skills/index.d.ts

@@ -1,3 +1,3 @@
 export { SkillManifestSchema, type SkillManifest } from "./schema.js";
 export { loadSkillManifest, loadAllSkillManifests } from "./loader.js";
-export { createActivateSkillTool, type SkillActivationContext } from "./activate.js";
+export { createActivateSkillTool, preActivateSkills, type SkillActivationContext } from "./activate.js";

package/dist/skills/index.js

@@ -1,3 +1,3 @@
 export { SkillManifestSchema } from "./schema.js";
 export { loadSkillManifest, loadAllSkillManifests } from "./loader.js";
-export { createActivateSkillTool } from "./activate.js";
+export { createActivateSkillTool, preActivateSkills } from "./activate.js";

package/dist/telemetry/db.d.ts

@@ -0,0 +1,63 @@
+export interface SpanRow {
+    trace_id: string;
+    span_id: string;
+    parent_span_id?: string | null;
+    name: string;
+    kind: string;
+    status: string;
+    agent?: string | null;
+    source?: string | null;
+    start_time: number;
+    end_time: number;
+    duration_ms: number;
+    attributes: string;
+    events: string;
+}
+export interface ErrorRow {
+    trace_id: string;
+    span_id: string;
+    fingerprint: string;
+    error_type?: string | null;
+    message: string;
+    stack?: string | null;
+    agent?: string | null;
+    source?: string | null;
+}
+export interface EventRow {
+    trace_id?: string | null;
+    span_id?: string | null;
+    name: string;
+    agent?: string | null;
+    body?: string;
+}
+export interface ListTracesOptions {
+    agent?: string;
+    source?: string;
+    status?: string;
+    since?: string;
+    limit?: number;
+}
+export interface RecentErrorsOptions {
+    agent?: string;
+    source?: string;
+    since?: string;
+    limit?: number;
+}
+export interface ErrorStatsOptions {
+    since?: string;
+    groupBy?: "fingerprint" | "agent";
+}
+export declare class TelemetryDb {
+    private db;
+    constructor(dbPath: string);
+    insertSpan(span: SpanRow): void;
+    insertError(error: ErrorRow): void;
+    insertEvent(event: EventRow): void;
+    getTraceSpans(traceId: string): any[];
+    listTraces(options: ListTracesOptions): any[];
+    getRecentErrors(options: RecentErrorsOptions): any[];
+    private static readonly ALLOWED_GROUP_BY;
+    getErrorStats(options: ErrorStatsOptions): any[];
+    cleanup(retentionDays: number, vacuum?: boolean): void;
+    close(): void;
+}

package/dist/telemetry/db.js

@@ -0,0 +1,193 @@
+import Database from "better-sqlite3";
+const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS spans (
+  id             INTEGER PRIMARY KEY AUTOINCREMENT,
+  trace_id       TEXT NOT NULL,
+  span_id        TEXT NOT NULL,
+  parent_span_id TEXT,
+  name           TEXT NOT NULL,
+  kind           TEXT NOT NULL DEFAULT 'internal',
+  status         TEXT NOT NULL DEFAULT 'unset',
+  agent          TEXT,
+  source         TEXT,
+  start_time     INTEGER NOT NULL,
+  end_time       INTEGER NOT NULL,
+  duration_ms    REAL NOT NULL,
+  attributes     TEXT NOT NULL DEFAULT '{}',
+  events         TEXT NOT NULL DEFAULT '[]',
+  created_at     TEXT NOT NULL DEFAULT (datetime('now')),
+  UNIQUE(trace_id, span_id)
+);
+
+CREATE TABLE IF NOT EXISTS errors (
+  id           INTEGER PRIMARY KEY AUTOINCREMENT,
+  trace_id     TEXT NOT NULL,
+  span_id      TEXT NOT NULL,
+  fingerprint  TEXT NOT NULL,
+  error_type   TEXT,
+  message      TEXT NOT NULL,
+  stack        TEXT,
+  agent        TEXT,
+  source       TEXT,
+  created_at   TEXT NOT NULL DEFAULT (datetime('now')),
+  FOREIGN KEY (trace_id, span_id) REFERENCES spans(trace_id, span_id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS events (
+  id        INTEGER PRIMARY KEY AUTOINCREMENT,
+  trace_id  TEXT,
+  span_id   TEXT,
+  name      TEXT NOT NULL,
+  agent     TEXT,
+  body      TEXT NOT NULL DEFAULT '{}',
+  timestamp TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_spans_trace ON spans(trace_id);
+CREATE INDEX IF NOT EXISTS idx_spans_parent ON spans(parent_span_id);
+CREATE INDEX IF NOT EXISTS idx_spans_name_time ON spans(name, start_time);
+CREATE INDEX IF NOT EXISTS idx_spans_agent_time ON spans(agent, created_at);
+CREATE INDEX IF NOT EXISTS idx_spans_source_time ON spans(source, created_at);
+CREATE INDEX IF NOT EXISTS idx_spans_status ON spans(status, created_at);
+CREATE INDEX IF NOT EXISTS idx_errors_agent_time ON errors(agent, created_at);
+CREATE INDEX IF NOT EXISTS idx_errors_fingerprint ON errors(fingerprint, created_at);
+CREATE INDEX IF NOT EXISTS idx_errors_trace ON errors(trace_id);
+CREATE INDEX IF NOT EXISTS idx_events_time ON events(timestamp);
+CREATE INDEX IF NOT EXISTS idx_events_agent ON events(agent, timestamp);
+CREATE INDEX IF NOT EXISTS idx_events_span ON events(span_id);
+`;
+export class TelemetryDb {
+    db;
+    constructor(dbPath) {
+        this.db = new Database(dbPath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("foreign_keys = ON");
+        this.db.exec(SCHEMA_SQL);
+    }
+    insertSpan(span) {
+        this.db
+            .prepare(`INSERT INTO spans (trace_id, span_id, parent_span_id, name, kind, status, agent, source, start_time, end_time, duration_ms, attributes, events)
+         VALUES (@trace_id, @span_id, @parent_span_id, @name, @kind, @status, @agent, @source, @start_time, @end_time, @duration_ms, @attributes, @events)`)
+            .run({
+            trace_id: span.trace_id,
+            span_id: span.span_id,
+            parent_span_id: span.parent_span_id ?? null,
+            name: span.name,
+            kind: span.kind,
+            status: span.status,
+            agent: span.agent ?? null,
+            source: span.source ?? null,
+            start_time: span.start_time,
+            end_time: span.end_time,
+            duration_ms: span.duration_ms,
+            attributes: span.attributes,
+            events: span.events,
+        });
+    }
+    insertError(error) {
+        this.db
+            .prepare(`INSERT INTO errors (trace_id, span_id, fingerprint, error_type, message, stack, agent, source)
+         VALUES (@trace_id, @span_id, @fingerprint, @error_type, @message, @stack, @agent, @source)`)
+            .run({
+            trace_id: error.trace_id,
+            span_id: error.span_id,
+            fingerprint: error.fingerprint,
+            error_type: error.error_type ?? null,
+            message: error.message,
+            stack: error.stack ?? null,
+            agent: error.agent ?? null,
+            source: error.source ?? null,
+        });
+    }
+    insertEvent(event) {
+        this.db
+            .prepare(`INSERT INTO events (trace_id, span_id, name, agent, body)
+         VALUES (@trace_id, @span_id, @name, @agent, @body)`)
+            .run({
+            trace_id: event.trace_id ?? null,
+            span_id: event.span_id ?? null,
+            name: event.name,
+            agent: event.agent ?? null,
+            body: event.body ?? "{}",
+        });
+    }
+    getTraceSpans(traceId) {
+        return this.db
+            .prepare("SELECT * FROM spans WHERE trace_id = ? ORDER BY start_time")
+            .all(traceId);
+    }
+    listTraces(options) {
+        const conditions = ["parent_span_id IS NULL"];
+        const params = [];
+        if (options.agent) {
+            conditions.push("agent = ?");
+            params.push(options.agent);
+        }
+        if (options.source) {
+            conditions.push("source = ?");
+            params.push(options.source);
+        }
+        if (options.status) {
+            conditions.push("status = ?");
+            params.push(options.status);
+        }
+        if (options.since) {
+            conditions.push("created_at >= ?");
+            params.push(options.since);
+        }
+        const limit = options.limit ?? 100;
+        const sql = `SELECT * FROM spans WHERE ${conditions.join(" AND ")} ORDER BY start_time DESC LIMIT ?`;
+        params.push(limit);
+        return this.db.prepare(sql).all(...params);
+    }
+    getRecentErrors(options) {
+        const conditions = [];
+        const params = [];
+        if (options.agent) {
+            conditions.push("agent = ?");
+            params.push(options.agent);
+        }
+        if (options.source) {
+            conditions.push("source = ?");
+            params.push(options.source);
+        }
+        if (options.since) {
+            conditions.push("created_at >= ?");
+            params.push(options.since);
+        }
+        const limit = options.limit ?? 100;
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+        const sql = `SELECT * FROM errors ${where} ORDER BY created_at DESC LIMIT ?`;
+        params.push(limit);
+        return this.db.prepare(sql).all(...params);
+    }
+    static ALLOWED_GROUP_BY = new Set(["fingerprint", "agent"]);
+    getErrorStats(options) {
+        const conditions = [];
+        const params = [];
+        if (options.since) {
+            conditions.push("created_at >= ?");
+            params.push(options.since);
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+        const groupBy = options.groupBy ?? "fingerprint";
+        if (!TelemetryDb.ALLOWED_GROUP_BY.has(groupBy)) {
+            throw new Error(`Invalid groupBy: ${groupBy}`);
+        }
+        const sql = `SELECT ${groupBy}, COUNT(*) as count FROM errors ${where} GROUP BY ${groupBy} ORDER BY count DESC`;
+        return this.db.prepare(sql).all(...params);
+    }
+    cleanup(retentionDays, vacuum = false) {
+        const cutoff = `-${retentionDays} days`;
+        this.db.transaction(() => {
+            this.db.prepare("DELETE FROM events WHERE timestamp < datetime('now', ?)").run(cutoff);
+            this.db.prepare("DELETE FROM spans WHERE created_at < datetime('now', ?)").run(cutoff);
+        })();
+        if (vacuum) {
+            this.db.exec("VACUUM");
+        }
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/telemetry/index.d.ts

@@ -0,0 +1,17 @@
+import { type Tracer } from "@opentelemetry/api";
+import { TelemetryDb } from "./db.js";
+export interface TelemetryConfig {
+    enabled?: boolean;
+    serviceName?: string;
+    otlpEndpoint?: string;
+    sentryDsn?: string;
+    dbPath?: string;
+    sampleRate?: number;
+}
+/** Get the TelemetryDb instance (available after initTelemetry with a dbPath) */
+export declare function getTelemetryDb(): TelemetryDb | undefined;
+export declare function initTelemetry(config?: TelemetryConfig): () => Promise<void>;
+export declare function getTracer(name: string): Tracer;
+export { ATTR } from "./types.js";
+export { TelemetryDb } from "./db.js";
+export { SQLiteSpanProcessor } from "./sqlite-processor.js";

package/dist/telemetry/index.js

@@ -0,0 +1,82 @@
+import * as path from "path";
+import * as os from "os";
+import { trace } from "@opentelemetry/api";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { SimpleSpanProcessor, ConsoleSpanExporter } from "@opentelemetry/sdk-trace-base";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import * as Sentry from "@sentry/node";
+import { createLogger } from "../logger.js";
+import { TelemetryDb } from "./db.js";
+import { SQLiteSpanProcessor } from "./sqlite-processor.js";
+const log = createLogger("telemetry");
+const DEFAULT_DB_PATH = path.join(os.homedir(), ".agent-kit", "telemetry.db");
+let sdk;
+let telemetryDb;
+/** Get the TelemetryDb instance (available after initTelemetry with a dbPath) */
+export function getTelemetryDb() {
+    return telemetryDb;
+}
+export function initTelemetry(config = {}) {
+    const { enabled = process.env.OTEL_ENABLED !== "false", serviceName = process.env.OTEL_SERVICE_NAME ?? "agent-kit", otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT, sentryDsn, dbPath = DEFAULT_DB_PATH, sampleRate, } = config;
+    if (!enabled) {
+        log.info("telemetry disabled");
+        return async () => { };
+    }
+    // Guard against double initialization
+    if (sdk) {
+        log.warn("telemetry already initialized, shutting down previous instance");
+        sdk.shutdown().catch(() => { });
+        sdk = undefined;
+        telemetryDb = undefined;
+    }
+    const spanProcessors = [];
+    // SQLite span processor (local persistence)
+    if (dbPath) {
+        try {
+            telemetryDb = new TelemetryDb(dbPath);
+            spanProcessors.push(new SQLiteSpanProcessor(telemetryDb));
+            log.info({ dbPath }, "SQLite span processor enabled");
+        }
+        catch (err) {
+            log.error({ err, dbPath }, "failed to initialize SQLite span processor");
+        }
+    }
+    // OTLP exporter (optional — for Grafana/Jaeger)
+    if (otlpEndpoint) {
+        spanProcessors.push(new SimpleSpanProcessor(new OTLPTraceExporter({ url: otlpEndpoint })));
+        log.info({ endpoint: otlpEndpoint }, "OTLP exporter enabled");
+    }
+    // Console exporter for dev (when no OTLP endpoint)
+    if (!otlpEndpoint && process.env.OTEL_DEBUG === "true") {
+        spanProcessors.push(new SimpleSpanProcessor(new ConsoleSpanExporter()));
+    }
+    // Sentry error tracking (optional)
+    if (sentryDsn) {
+        Sentry.init({
+            dsn: sentryDsn,
+            tracesSampleRate: sampleRate ?? 1.0,
+            release: process.env.npm_package_version,
+            environment: process.env.NODE_ENV ?? "development",
+        });
+        log.info("Sentry initialized");
+    }
+    sdk = new NodeSDK({
+        serviceName,
+        spanProcessors,
+    });
+    sdk.start();
+    log.info({ serviceName }, "telemetry initialized");
+    return async () => {
+        if (sdk) {
+            await sdk.shutdown();
+            log.info("telemetry shut down");
+        }
+        await Sentry.close(2000);
+    };
+}
+export function getTracer(name) {
+    return trace.getTracer(name);
+}
+export { ATTR } from "./types.js";
+export { TelemetryDb } from "./db.js";
+export { SQLiteSpanProcessor } from "./sqlite-processor.js";

package/dist/telemetry/sanitize.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Sanitize span attributes before persisting:
+ * 1. Redact values matching known secret patterns
+ * 2. Truncate long string values (unless key is in the safe list)
+ */
+export declare function sanitizeAttributes(attrs: Record<string, unknown>): Record<string, unknown>;

package/dist/telemetry/sanitize.js

@@ -0,0 +1,48 @@
+import { ATTR } from "./types.js";
+/**
+ * Patterns that match known secret/credential formats.
+ * If any pattern matches within a string value, the entire value is redacted.
+ */
+const SECRET_PATTERNS = [
+    /sk-[a-zA-Z0-9\-]{20,}/, // OpenAI/Anthropic API keys
+    /xoxb-[a-zA-Z0-9\-]+/, // Slack bot tokens
+    /xoxp-[a-zA-Z0-9\-]+/, // Slack user tokens
+    /xapp-[a-zA-Z0-9\-]+/, // Slack app tokens
+    /Bearer\s+[a-zA-Z0-9\-_.]+/, // Bearer tokens
+    /https?:\/\/[^@\s]+@[^\s]*sentry\.io[^\s]*/, // Sentry DSNs
+    /ghp_[a-zA-Z0-9]{36,}/, // GitHub personal access tokens
+    /gho_[a-zA-Z0-9]{36,}/, // GitHub OAuth tokens
+];
+const MAX_STRING_LENGTH = 500;
+/**
+ * ATTR keys that are controlled by our code and should never be truncated.
+ * They are still checked for secret patterns (in case a user accidentally
+ * passes a credential as e.g. an agent name).
+ */
+const SAFE_KEYS = new Set(Object.values(ATTR));
+/**
+ * Sanitize span attributes before persisting:
+ * 1. Redact values matching known secret patterns
+ * 2. Truncate long string values (unless key is in the safe list)
+ */
+export function sanitizeAttributes(attrs) {
+    const result = {};
+    for (const [key, value] of Object.entries(attrs)) {
+        result[key] = sanitizeValue(key, value);
+    }
+    return result;
+}
+function sanitizeValue(key, value) {
+    if (typeof value !== "string")
+        return value;
+    // Check for secret patterns — always, even for safe keys
+    for (const pattern of SECRET_PATTERNS) {
+        if (pattern.test(value))
+            return "[REDACTED]";
+    }
+    // Truncate long strings, but skip safe (ATTR) keys
+    if (!SAFE_KEYS.has(key) && value.length > MAX_STRING_LENGTH) {
+        return value.slice(0, MAX_STRING_LENGTH) + "...[truncated]";
+    }
+    return value;
+}

package/dist/telemetry/sqlite-processor.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from "@opentelemetry/api";
+import type { SpanProcessor, Span, ReadableSpan } from "@opentelemetry/sdk-trace-base";
+import type { TelemetryDb } from "./db.js";
+export declare class SQLiteSpanProcessor implements SpanProcessor {
+    private db;
+    constructor(db: TelemetryDb);
+    onStart(_span: Span, _parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}

package/dist/telemetry/sqlite-processor.js

@@ -0,0 +1,108 @@
+import { SpanStatusCode } from "@opentelemetry/api";
+import { sanitizeAttributes } from "./sanitize.js";
+import { ATTR } from "./types.js";
+const SPAN_KIND_MAP = {
+    0: "internal",
+    1: "server",
+    2: "client",
+    3: "producer",
+    4: "consumer",
+};
+const STATUS_MAP = {
+    [SpanStatusCode.UNSET]: "unset",
+    [SpanStatusCode.OK]: "ok",
+    [SpanStatusCode.ERROR]: "error",
+};
+/** Convert OTel HrTime [seconds, nanoseconds] to milliseconds */
+function hrToMs(hr) {
+    return hr[0] * 1000 + hr[1] / 1e6;
+}
+/**
+ * Generate an error fingerprint from exception info.
+ * Prefers: error_type + first file + line from stack trace.
+ * Fallback: error_type + message.
+ */
+function generateFingerprint(errorType, message, stack) {
+    const type = errorType ?? "Error";
+    if (stack) {
+        // Try to extract file:line from first stack frame
+        // Match patterns like: at Object.<anonymous> (src/agent/loop.ts:42:10)
+        // or: at src/agent/loop.ts:42:10
+        const frameMatch = stack.match(/(?:at\s+(?:.*?\s+)?(?:\()?)((?:[a-zA-Z]:)?[^:(\s]+):(\d+)/);
+        if (frameMatch) {
+            const file = frameMatch[1];
+            const line = frameMatch[2];
+            return `${type}:${file}:${line}`;
+        }
+    }
+    return `${type}:${message}`;
+}
+export class SQLiteSpanProcessor {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    onStart(_span, _parentContext) {
+        // no-op
+    }
+    onEnd(span) {
+        const ctx = span.spanContext();
+        const traceId = ctx.traceId;
+        const spanId = ctx.spanId;
+        const parentSpanId = span.parentSpanContext?.spanId ?? null;
+        const agent = span.attributes[ATTR.AGENT];
+        const source = span.attributes[ATTR.SOURCE];
+        const startTime = hrToMs(span.startTime);
+        const endTime = hrToMs(span.endTime);
+        const durationMs = hrToMs(span.duration);
+        const kind = SPAN_KIND_MAP[span.kind] ?? "internal";
+        const status = STATUS_MAP[span.status.code] ?? "unset";
+        // Serialize all span events for storage
+        const serializedEvents = span.events.map((e) => ({
+            name: e.name,
+            time: hrToMs(e.time),
+            attributes: e.attributes ?? {},
+        }));
+        // Insert span
+        this.db.insertSpan({
+            trace_id: traceId,
+            span_id: spanId,
+            parent_span_id: parentSpanId,
+            name: span.name,
+            kind,
+            status,
+            agent: agent ?? null,
+            source: source ?? null,
+            start_time: startTime,
+            end_time: endTime,
+            duration_ms: durationMs,
+            attributes: JSON.stringify(sanitizeAttributes(span.attributes)),
+            events: JSON.stringify(serializedEvents),
+        });
+        // Extract exception events and write to errors table
+        for (const event of span.events) {
+            if (event.name === "exception") {
+                const errorType = event.attributes?.["exception.type"];
+                const message = event.attributes?.["exception.message"] ?? "Unknown error";
+                const stack = event.attributes?.["exception.stacktrace"];
+                const fingerprint = generateFingerprint(errorType, message, stack);
+                this.db.insertError({
+                    trace_id: traceId,
+                    span_id: spanId,
+                    fingerprint,
+                    error_type: errorType ?? null,
+                    message,
+                    stack: stack ?? null,
+                    agent: agent ?? null,
+                    source: source ?? null,
+                });
+            }
+        }
+    }
+    async shutdown() {
+        this.db.close();
+    }
+    async forceFlush() {
+        // Writes are synchronous with better-sqlite3, nothing to flush
+    }
+}