@pasko70/pibo 1.9.9 → 1.9.11

package/dist/data/session-store.js

@@ -0,0 +1,63 @@
+export class SessionStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    upsertSession(input) {
+        const now = input.lastActivityAt ?? new Date().toISOString();
+        const title = input.session.title || previewText(input.firstMessagePreview ?? "") || "Untitled Session";
+        const baseColumns = [
+            "id", "pi_session_id", "room_id", "root_session_id", "parent_id", "origin_id", "channel", "kind", "profile", "active_model_json", "workspace", "title", "first_message_preview", "status", "metadata_json", "created_at", "updated_at", "last_activity_at",
+        ];
+        const values = [
+            input.session.id,
+            input.session.piSessionId,
+            input.roomId,
+            rootSessionId(input.session),
+            input.session.parentId ?? null,
+            input.session.originId ?? null,
+            input.session.channel,
+            input.session.kind,
+            input.session.profile,
+            input.session.activeModel ? JSON.stringify(input.session.activeModel) : null,
+            input.session.workspace ?? null,
+            title,
+            previewText(input.firstMessagePreview ?? "") ?? null,
+            input.status ?? "running",
+            JSON.stringify((input.session.metadata ?? {})),
+            input.session.createdAt,
+            now,
+            now,
+        ];
+        const assignments = [
+            "pi_session_id = excluded.pi_session_id",
+            "room_id = excluded.room_id",
+            "root_session_id = excluded.root_session_id",
+            "parent_id = excluded.parent_id",
+            "origin_id = excluded.origin_id",
+            "channel = excluded.channel",
+            "kind = excluded.kind",
+            "profile = excluded.profile",
+            "active_model_json = excluded.active_model_json",
+            "workspace = excluded.workspace",
+            "title = excluded.title",
+            "first_message_preview = COALESCE(sessions.first_message_preview, excluded.first_message_preview)",
+            "status = excluded.status",
+            "metadata_json = excluded.metadata_json",
+            "updated_at = excluded.updated_at",
+            "last_activity_at = excluded.last_activity_at",
+        ];
+        this.db.prepare(`
+			INSERT INTO sessions (${baseColumns.join(", ")})
+			VALUES (${baseColumns.map(() => "?").join(", ")})
+			ON CONFLICT(id) DO UPDATE SET ${assignments.join(", ")}
+		`).run(...values);
+    }
+}
+export function rootSessionId(session) {
+    return session.parentId ? (typeof session.metadata?.rootSessionId === "string" ? session.metadata.rootSessionId : session.parentId) : session.id;
+}
+function previewText(text) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    return normalized ? normalized.slice(0, 512) : undefined;
+}

package/dist/data/sqlite-schema.js

@@ -0,0 +1,12 @@
+export function sqliteTableExists(db, tableName) {
+    const row = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(tableName);
+    return Boolean(row);
+}
+export function sqliteTableColumns(db, tableName) {
+    if (!sqliteTableExists(db, tableName))
+        return new Set();
+    return new Set(db.prepare(`PRAGMA table_info(${quoteIdentifier(tableName)})`).all().map((column) => column.name));
+}
+function quoteIdentifier(value) {
+    return `"${value.replaceAll('"', '""')}"`;
+}

package/dist/data/telemetry-preview.js

@@ -0,0 +1,65 @@
+const DEFAULT_PREVIEW_MAX_BYTES = 2048;
+const HARD_PREVIEW_MAX_BYTES = 16 * 1024;
+export function createTelemetryBoundedPreview(input) {
+    const hardMaxBytes = clampLimit(input.hardMaxBytes ?? HARD_PREVIEW_MAX_BYTES, 1, HARD_PREVIEW_MAX_BYTES);
+    const maxBytes = clampLimit(input.maxBytes ?? DEFAULT_PREVIEW_MAX_BYTES, 1, hardMaxBytes);
+    const text = stringifyPreviewValue(input.value, input.valueKind);
+    const buffer = Buffer.from(text, "utf8");
+    const truncated = buffer.byteLength > maxBytes;
+    return {
+        text: truncated ? truncateUtf8(text, maxBytes) : text,
+        byteSize: buffer.byteLength,
+        maxBytes,
+        truncated,
+        contentType: input.contentType ?? (input.valueKind === "json" || typeof input.value === "object" ? "application/json" : "text/plain"),
+        valueKind: input.valueKind ?? inferPreviewKind(input.value),
+        volumeControlled: true,
+    };
+}
+export function telemetrySafeJsonObject(value, allowedKeys) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return {};
+    const allowed = allowedKeys ? new Set(allowedKeys) : undefined;
+    const output = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if (allowed && !allowed.has(key))
+            continue;
+        if (typeof raw === "string" || typeof raw === "number" || typeof raw === "boolean" || raw === null)
+            output[key] = raw;
+    }
+    return output;
+}
+export function telemetrySafeTopLevelKeys(value, limit = 50) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return [];
+    return Object.keys(value).filter((key) => key.length <= 128).slice(0, clampLimit(limit, 0, 200));
+}
+function stringifyPreviewValue(value, valueKind) {
+    if (typeof value === "string")
+        return value;
+    if (valueKind === "headers" && value && typeof value === "object" && !Array.isArray(value)) {
+        return Object.entries(value).map(([key, raw]) => `${key}: ${typeof raw === "string" ? raw : String(raw)}`).join("\n");
+    }
+    try {
+        return JSON.stringify(value, null, 2) ?? "";
+    }
+    catch {
+        return String(value);
+    }
+}
+function truncateUtf8(text, maxBytes) {
+    let truncated = Buffer.from(text, "utf8").subarray(0, maxBytes).toString("utf8");
+    while (Buffer.byteLength(truncated, "utf8") > maxBytes)
+        truncated = truncated.slice(0, -1);
+    return truncated;
+}
+function inferPreviewKind(value) {
+    if (typeof value === "string")
+        return "text";
+    if (value && typeof value === "object")
+        return "json";
+    return "unknown";
+}
+function clampLimit(value, min, max) {
+    return Math.max(min, Math.min(value, max));
+}

package/dist/data/telemetry-queries.js

@@ -0,0 +1,212 @@
+import { phaseFromRow, providerEventFromRow, providerRequestFromRow, toolCallFromRow, turnFromRow, } from "./telemetry-rows.js";
+const DEFAULT_TELEMETRY_LIST_LIMIT = 20;
+const MAX_TELEMETRY_LIST_LIMIT = 200;
+const DEFAULT_STALE_THRESHOLD_MS = 5 * 60 * 1000;
+export function listTelemetrySessions(db, input = {}) {
+    const limit = normalizeTelemetryListLimit(input.limit);
+    const nowMs = Date.parse(input.now ?? new Date().toISOString());
+    const thresholdMs = input.thresholdMs ?? DEFAULT_STALE_THRESHOLD_MS;
+    const rows = db.prepare(`
+		SELECT t.*, counts.turn_count AS turn_count FROM telemetry_turns t
+		JOIN (
+			SELECT pibo_session_id, MAX(updated_at) AS max_updated, COUNT(*) AS turn_count
+			FROM telemetry_turns
+			GROUP BY pibo_session_id
+		) counts ON counts.pibo_session_id = t.pibo_session_id AND counts.max_updated = t.updated_at
+		ORDER BY t.updated_at DESC
+		LIMIT ?
+	`).all(limit);
+    return rows.map((row) => telemetrySessionSummaryFromTurnRow(db, row, Number(row.turn_count), nowMs, thresholdMs));
+}
+export function getTelemetrySessionDetail(db, piboSessionId, input = {}) {
+    const recentTurns = listTelemetryTurnsForSession(db, piboSessionId, input);
+    if (recentTurns.length === 0)
+        return undefined;
+    const activeTurn = recentTurns.find((turn) => turn.status === "queued" || turn.status === "running") ?? recentTurns[0];
+    const activePhase = getTelemetryActivePhaseForSession(db, piboSessionId, activeTurn.turnId);
+    const providerRequests = listTelemetryProviderRequestsForTurn(db, activeTurn.turnId, input);
+    const toolCalls = listTelemetryToolCallsForTurn(db, activeTurn.turnId, input);
+    return {
+        piboSessionId,
+        activeTurn,
+        activePhase,
+        recentTurns,
+        providerRequests,
+        toolCalls,
+        nextCommands: telemetryNextCommands({ piboSessionId, turnId: activeTurn.turnId, providerRequests, toolCalls }),
+    };
+}
+export function getTelemetryTurnTimeline(db, turnIdOrEventId, input = {}) {
+    const turn = getTelemetryTurn(db, turnIdOrEventId) ?? getTelemetryTurnByEventId(db, turnIdOrEventId);
+    if (!turn)
+        return undefined;
+    const limit = normalizeTelemetryListLimit(input.limit);
+    const phaseRows = db.prepare(`
+		SELECT * FROM telemetry_phases
+		WHERE turn_id = ?
+		ORDER BY started_at ASC, created_at ASC
+		LIMIT ?
+	`).all(turn.turnId, limit);
+    const phases = phaseRows.map(phaseFromRow);
+    const providerRequests = listTelemetryProviderRequestsForTurn(db, turn.turnId, input);
+    const toolCalls = listTelemetryToolCallsForTurn(db, turn.turnId, input);
+    return {
+        turn,
+        phases,
+        providerRequests,
+        toolCalls,
+        nextCommands: telemetryNextCommands({ piboSessionId: turn.piboSessionId, turnId: turn.turnId, providerRequests, toolCalls }),
+    };
+}
+export function listTelemetryProviderEventsPage(db, providerRequestId, input = {}) {
+    const limit = normalizeTelemetryListLimit(input.limit);
+    const afterSequence = input.afterSequence ?? -1;
+    const rows = db.prepare(`
+		SELECT * FROM telemetry_provider_events
+		WHERE provider_request_id = ? AND sequence > ?
+		ORDER BY sequence ASC
+		LIMIT ?
+	`).all(providerRequestId, afterSequence, limit + 1);
+    const hasMore = rows.length > limit;
+    const pageRows = rows.slice(0, limit).map(providerEventFromRow);
+    return {
+        providerRequestId,
+        rows: pageRows,
+        limit,
+        afterSequence,
+        nextAfterSequence: hasMore && pageRows.length > 0 ? pageRows[pageRows.length - 1]?.sequence : undefined,
+        hasMore,
+        truncated: hasMore,
+        storageMode: "per_event",
+    };
+}
+export function listTelemetryStaleWork(db, input = {}) {
+    const limit = normalizeTelemetryListLimit(input.limit);
+    const thresholdMs = input.thresholdMs ?? DEFAULT_STALE_THRESHOLD_MS;
+    const nowMs = Date.parse(input.now ?? new Date().toISOString());
+    const rows = db.prepare(`
+		SELECT * FROM telemetry_phases
+		WHERE status = 'open'
+		ORDER BY COALESCE(last_progress_at, started_at) ASC
+		LIMIT ?
+	`).all(MAX_TELEMETRY_LIST_LIMIT);
+    return rows.map(phaseFromRow)
+        .map((phase) => {
+        const progress = phase.lastProgressAt ?? phase.startedAt;
+        const staleForMs = Number.isFinite(nowMs) ? Math.max(0, nowMs - Date.parse(progress)) : 0;
+        const turn = getTelemetryTurn(db, phase.turnId);
+        return { phase, staleForMs, turn };
+    })
+        .filter((item) => item.staleForMs >= thresholdMs)
+        .slice(0, limit)
+        .map(({ phase, staleForMs, turn }) => ({
+        piboSessionId: phase.piboSessionId,
+        turnId: phase.turnId,
+        phaseId: phase.phaseId,
+        phase: phase.name,
+        lastProgressAt: phase.lastProgressAt ?? phase.startedAt,
+        staleForMs,
+        thresholdMs,
+        queueDepth: turn?.queueDepth,
+        nextCommands: telemetryNextCommands({ piboSessionId: phase.piboSessionId, turnId: phase.turnId, phase }),
+    }));
+}
+function getTelemetryTurn(db, turnId) {
+    const row = db.prepare("SELECT * FROM telemetry_turns WHERE turn_id = ?").get(turnId);
+    return row ? turnFromRow(row) : undefined;
+}
+function listTelemetryTurnsForSession(db, piboSessionId, input = {}) {
+    const limit = normalizeTelemetryListLimit(input.limit);
+    const rows = db.prepare(`
+		SELECT * FROM telemetry_turns
+		WHERE pibo_session_id = ?
+		ORDER BY updated_at DESC
+		LIMIT ?
+	`).all(piboSessionId, limit);
+    return rows.map(turnFromRow);
+}
+function getTelemetryTurnByEventId(db, eventId) {
+    const row = db.prepare(`
+		SELECT * FROM telemetry_turns
+		WHERE event_id = ? OR input_event_id = ?
+		ORDER BY updated_at DESC
+		LIMIT 1
+	`).get(eventId, eventId);
+    return row ? turnFromRow(row) : undefined;
+}
+function getTelemetryActivePhaseForSession(db, piboSessionId, turnId) {
+    const row = turnId
+        ? db.prepare(`
+			SELECT * FROM telemetry_phases
+			WHERE pibo_session_id = ? AND turn_id = ? AND status = 'open'
+			ORDER BY COALESCE(last_progress_at, started_at) DESC
+			LIMIT 1
+		`).get(piboSessionId, turnId)
+        : db.prepare(`
+			SELECT * FROM telemetry_phases
+			WHERE pibo_session_id = ? AND status = 'open'
+			ORDER BY COALESCE(last_progress_at, started_at) DESC
+			LIMIT 1
+		`).get(piboSessionId);
+    return row ? phaseFromRow(row) : undefined;
+}
+function listTelemetryProviderRequestsForTurn(db, turnId, input = {}) {
+    const limit = normalizeTelemetryListLimit(input.limit);
+    const rows = db.prepare(`
+		SELECT * FROM telemetry_provider_requests
+		WHERE turn_id = ?
+		ORDER BY started_at ASC
+		LIMIT ?
+	`).all(turnId, limit);
+    return rows.map(providerRequestFromRow);
+}
+function listTelemetryToolCallsForTurn(db, turnId, input = {}) {
+    const limit = normalizeTelemetryListLimit(input.limit);
+    const rows = db.prepare(`
+		SELECT * FROM telemetry_tool_calls
+		WHERE turn_id = ?
+		ORDER BY COALESCE(args_started_at, created_at) ASC
+		LIMIT ?
+	`).all(turnId, limit);
+    return rows.map(toolCallFromRow);
+}
+function telemetrySessionSummaryFromTurnRow(db, row, turnCount, nowMs, thresholdMs) {
+    const turn = turnFromRow(row);
+    const activePhase = getTelemetryActivePhaseForSession(db, turn.piboSessionId, turn.turnId);
+    const lastProgressAt = activePhase?.lastProgressAt ?? activePhase?.startedAt ?? turn.lastProgressAt ?? turn.startedAt ?? turn.queuedAt;
+    const staleForMs = Number.isFinite(nowMs) ? Math.max(0, nowMs - Date.parse(lastProgressAt)) : undefined;
+    return {
+        piboSessionId: turn.piboSessionId,
+        status: turn.status ?? "idle",
+        activeTurnId: turn.status === "queued" || turn.status === "running" ? turn.turnId : undefined,
+        activePhase,
+        queueDepth: turn.queueDepth,
+        lastProgressAt,
+        staleForMs,
+        isStale: typeof staleForMs === "number" && staleForMs >= thresholdMs && (turn.status === "queued" || turn.status === "running" || activePhase?.status === "open"),
+        turnCount,
+        nextCommands: telemetryNextCommands({ piboSessionId: turn.piboSessionId, turnId: turn.turnId, phase: activePhase }),
+    };
+}
+function telemetryNextCommands(input) {
+    const commands = [];
+    if (input.piboSessionId)
+        commands.push(`pibo debug telemetry session ${input.piboSessionId}`);
+    if (input.turnId)
+        commands.push(`pibo debug telemetry turn ${input.turnId}`);
+    const providerRequestId = input.phase?.providerRequestId ?? input.providerRequests?.[0]?.providerRequestId;
+    if (providerRequestId) {
+        commands.push(`pibo debug telemetry provider ${providerRequestId}`);
+        commands.push(`pibo debug telemetry provider ${providerRequestId} events --limit 20`);
+    }
+    const toolCallId = input.phase?.toolCallId ?? input.toolCalls?.[0]?.toolCallId;
+    if (toolCallId)
+        commands.push(`pibo debug telemetry tool ${toolCallId}`);
+    return [...new Set(commands)];
+}
+function normalizeTelemetryListLimit(value) {
+    return clampLimit(value ?? DEFAULT_TELEMETRY_LIST_LIMIT, 1, MAX_TELEMETRY_LIST_LIMIT);
+}
+function clampLimit(value, min, max) {
+    return Math.max(min, Math.min(value, max));
+}

package/dist/data/telemetry-retention.js

@@ -0,0 +1,50 @@
+const RETENTION_CLASSES = ["live", "diagnostic", "provider_event", "incident", "payload_preview"];
+const PRUNE_TABLES = [
+    { table: "telemetry_provider_events", cutoffColumn: "received_at", byteExpression: "byte_size" },
+    { table: "telemetry_tool_calls", cutoffColumn: "updated_at", byteExpression: "0" },
+    { table: "telemetry_provider_requests", cutoffColumn: "updated_at", byteExpression: "COALESCE(bytes_received, 0)" },
+    { table: "telemetry_phases", cutoffColumn: "updated_at", byteExpression: "0" },
+    { table: "telemetry_turns", cutoffColumn: "updated_at", byteExpression: "0" },
+];
+export function getTelemetryRetentionStats(db) {
+    const rows = [];
+    for (const retentionClass of RETENTION_CLASSES) {
+        rows.push(statsForTable(db, "turns", "telemetry_turns", "0", retentionClass));
+        rows.push(statsForTable(db, "phases", "telemetry_phases", "0", retentionClass));
+        rows.push(statsForTable(db, "provider_requests", "telemetry_provider_requests", "COALESCE(bytes_received, 0)", retentionClass));
+        rows.push(statsForTable(db, "provider_events", "telemetry_provider_events", "byte_size", retentionClass));
+        rows.push(statsForTable(db, "tool_calls", "telemetry_tool_calls", "0", retentionClass));
+    }
+    const presentRows = rows.filter((row) => row.rowCount > 0 || row.retentionClass === "payload_preview");
+    return {
+        rows: presentRows,
+        totalRows: presentRows.reduce((sum, row) => sum + row.rowCount, 0),
+        totalBytes: presentRows.reduce((sum, row) => sum + row.byteCount, 0),
+    };
+}
+export function pruneTelemetryRetention(db, input) {
+    const plan = telemetryPrunePlan(db, input.retentionClass, input.before);
+    if (!input.apply) {
+        return { retentionClass: input.retentionClass, before: input.before, applied: false, rowsMatched: plan.rows, bytesMatched: plan.bytes, rowsDeleted: 0 };
+    }
+    let rowsDeleted = 0;
+    for (const spec of PRUNE_TABLES) {
+        const result = db.prepare(`DELETE FROM ${spec.table} WHERE retention_class = ? AND ${spec.cutoffColumn} < ?`).run(input.retentionClass, input.before);
+        rowsDeleted += Number(result.changes ?? 0);
+    }
+    return { retentionClass: input.retentionClass, before: input.before, applied: true, rowsMatched: plan.rows, bytesMatched: plan.bytes, rowsDeleted };
+}
+function statsForTable(db, table, sqlTable, byteExpression, retentionClass) {
+    const row = db.prepare(`SELECT COUNT(*) AS row_count, COALESCE(SUM(${byteExpression}), 0) AS byte_count FROM ${sqlTable} WHERE retention_class = ?`).get(retentionClass);
+    return { retentionClass, table, rowCount: Number(row.row_count ?? 0), byteCount: Number(row.byte_count ?? 0) };
+}
+function telemetryPrunePlan(db, retentionClass, before) {
+    let rows = 0;
+    let bytes = 0;
+    for (const spec of PRUNE_TABLES) {
+        const row = db.prepare(`SELECT COUNT(*) AS row_count, COALESCE(SUM(${spec.byteExpression}), 0) AS byte_count FROM ${spec.table} WHERE retention_class = ? AND ${spec.cutoffColumn} < ?`).get(retentionClass, before);
+        rows += Number(row.row_count ?? 0);
+        bytes += Number(row.byte_count ?? 0);
+    }
+    return { rows, bytes };
+}

package/dist/data/telemetry-rows.js

@@ -0,0 +1,158 @@
+export function turnFromRow(row) {
+    return {
+        turnId: row.turn_id,
+        piboSessionId: row.pibo_session_id,
+        rootSessionId: row.root_session_id ?? undefined,
+        roomId: row.room_id ?? undefined,
+        inputEventId: row.input_event_id ?? undefined,
+        eventId: row.event_id ?? undefined,
+        eventStreamId: row.event_stream_id ?? undefined,
+        payloadRef: row.payload_ref ?? undefined,
+        runId: row.run_id ?? undefined,
+        source: row.source,
+        status: row.status,
+        currentPhase: row.current_phase ?? undefined,
+        queuedAt: row.queued_at,
+        startedAt: row.started_at ?? undefined,
+        completedAt: row.completed_at ?? undefined,
+        lastProgressAt: row.last_progress_at ?? undefined,
+        queuedBehind: row.queued_behind ?? undefined,
+        queueDepth: row.queue_depth ?? undefined,
+        summary: row.summary ?? undefined,
+        retentionClass: row.retention_class,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        metadata: parseJsonObject(row.metadata_json),
+    };
+}
+export function phaseFromRow(row) {
+    return {
+        phaseId: row.phase_id,
+        turnId: row.turn_id,
+        piboSessionId: row.pibo_session_id,
+        rootSessionId: row.root_session_id ?? undefined,
+        roomId: row.room_id ?? undefined,
+        name: row.name,
+        status: row.status,
+        startedAt: row.started_at,
+        endedAt: row.ended_at ?? undefined,
+        lastProgressAt: row.last_progress_at ?? undefined,
+        durationMs: row.duration_ms ?? undefined,
+        providerRequestId: row.provider_request_id ?? undefined,
+        toolCallId: row.tool_call_id ?? undefined,
+        eventStreamId: row.event_stream_id ?? undefined,
+        eventId: row.event_id ?? undefined,
+        payloadRef: row.payload_ref ?? undefined,
+        runId: row.run_id ?? undefined,
+        counters: parseJsonObject(row.counters_json),
+        summary: row.summary ?? undefined,
+        retentionClass: row.retention_class,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+export function providerRequestFromRow(row) {
+    return {
+        providerRequestId: row.provider_request_id,
+        piboSessionId: row.pibo_session_id,
+        rootSessionId: row.root_session_id ?? undefined,
+        roomId: row.room_id ?? undefined,
+        turnId: row.turn_id,
+        phaseId: row.phase_id ?? undefined,
+        provider: row.provider,
+        api: row.api,
+        model: row.model,
+        transport: row.transport,
+        serviceTier: row.service_tier ?? undefined,
+        status: row.status,
+        startedAt: row.started_at,
+        responseHeadersAt: row.response_headers_at ?? undefined,
+        firstByteAt: row.first_byte_at ?? undefined,
+        lastRawEventAt: row.last_raw_event_at ?? undefined,
+        lastNormalizedEventAt: row.last_normalized_event_at ?? undefined,
+        completedAt: row.completed_at ?? undefined,
+        httpStatus: row.http_status ?? undefined,
+        upstreamResponseId: row.upstream_response_id ?? undefined,
+        rawEventCount: row.raw_event_count,
+        normalizedEventCount: row.normalized_event_count,
+        parseErrorCount: row.parse_error_count,
+        unknownEventCount: row.unknown_event_count,
+        bytesReceived: row.bytes_received ?? undefined,
+        eventTypeCounts: parseJsonObject(row.event_type_counts_json),
+        eventStreamId: row.event_stream_id ?? undefined,
+        eventId: row.event_id ?? undefined,
+        payloadRef: row.payload_ref ?? undefined,
+        errorCategory: row.error_category ?? undefined,
+        errorMessage: row.error_message ?? undefined,
+        captureMode: row.capture_mode,
+        retentionClass: row.retention_class,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+export function providerEventFromRow(row) {
+    return {
+        rawEventId: row.raw_event_id,
+        providerRequestId: row.provider_request_id,
+        piboSessionId: row.pibo_session_id ?? undefined,
+        turnId: row.turn_id ?? undefined,
+        phaseId: row.phase_id ?? undefined,
+        sequence: row.sequence,
+        receivedAt: row.received_at,
+        eventType: row.event_type,
+        byteSize: row.byte_size,
+        parseStatus: row.parse_status,
+        normalizedType: row.normalized_type ?? undefined,
+        eventStreamId: row.event_stream_id ?? undefined,
+        eventId: row.event_id ?? undefined,
+        itemId: row.item_id ?? undefined,
+        toolCallId: row.tool_call_id ?? undefined,
+        payloadRef: row.payload_ref ?? undefined,
+        payloadPreviewRef: row.payload_preview_ref ?? undefined,
+        safeFields: parseJsonObject(row.safe_fields_json),
+        retentionClass: row.retention_class,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+export function toolCallFromRow(row) {
+    return {
+        toolCallId: row.tool_call_id,
+        piboSessionId: row.pibo_session_id,
+        rootSessionId: row.root_session_id ?? undefined,
+        roomId: row.room_id ?? undefined,
+        turnId: row.turn_id,
+        providerRequestId: row.provider_request_id ?? undefined,
+        providerItemId: row.provider_item_id ?? undefined,
+        outputIndex: row.output_index ?? undefined,
+        toolName: row.tool_name,
+        status: row.status,
+        argsStartedAt: row.args_started_at ?? undefined,
+        firstDeltaAt: row.first_delta_at ?? undefined,
+        lastDeltaAt: row.last_delta_at ?? undefined,
+        argsCompletedAt: row.args_completed_at ?? undefined,
+        executionStartedAt: row.execution_started_at ?? undefined,
+        executionEndedAt: row.execution_ended_at ?? undefined,
+        durationMs: row.duration_ms ?? undefined,
+        argsBytes: row.args_bytes,
+        parseStatus: row.parse_status,
+        safeArgKeys: parseStringArray(row.safe_arg_keys_json),
+        eventStreamId: row.event_stream_id ?? undefined,
+        eventId: row.event_id ?? undefined,
+        payloadRef: row.payload_ref ?? undefined,
+        runId: row.run_id ?? undefined,
+        errorCategory: row.error_category ?? undefined,
+        errorMessage: row.error_message ?? undefined,
+        retentionClass: row.retention_class,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function parseJsonObject(text) {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+}
+function parseStringArray(text) {
+    const parsed = JSON.parse(text);
+    return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : [];
+}

package/dist/data/telemetry-writer.js

@@ -0,0 +1,114 @@
+const DEFAULT_FLUSH_INTERVAL_MS = 25;
+const DEFAULT_MAX_PENDING_OPERATIONS = 1_024;
+/**
+ * Gateway-scoped, ordered telemetry writer.
+ *
+ * Normal writes are deferred briefly so telemetry from multiple routed sessions
+ * shares one SQLite transaction. The queue never drops lifecycle events: when
+ * the hard bound is reached, it drains immediately in the caller instead.
+ */
+export class AsyncTelemetryWriter {
+    store;
+    options;
+    flushIntervalMs;
+    maxPendingOperations;
+    pending = [];
+    flushTimer;
+    flushing = false;
+    closed = false;
+    constructor(store, options = {}) {
+        this.store = store;
+        this.options = options;
+        this.flushIntervalMs = nonNegativeFinite(options.flushIntervalMs, DEFAULT_FLUSH_INTERVAL_MS);
+        this.maxPendingOperations = positiveInteger(options.maxPendingOperations, DEFAULT_MAX_PENDING_OPERATIONS);
+    }
+    enqueue(write, onError) {
+        if (this.closed) {
+            this.reportError(new Error("Telemetry writer is closed."), onError);
+            return false;
+        }
+        this.pending.push({ write, onError });
+        if (this.pending.length >= this.maxPendingOperations) {
+            this.flushNow();
+        }
+        else {
+            this.scheduleFlush();
+        }
+        return true;
+    }
+    async flush() {
+        this.flushNow();
+    }
+    async dispose() {
+        if (this.closed)
+            return;
+        this.flushNow();
+        this.closed = true;
+    }
+    scheduleFlush() {
+        if (this.flushTimer)
+            return;
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = undefined;
+            this.flushNow();
+        }, this.flushIntervalMs);
+        this.flushTimer.unref();
+    }
+    flushNow() {
+        if (this.flushing)
+            return;
+        if (this.flushTimer)
+            clearTimeout(this.flushTimer);
+        this.flushTimer = undefined;
+        this.flushing = true;
+        try {
+            while (this.pending.length > 0) {
+                const batch = this.pending;
+                this.pending = [];
+                try {
+                    this.store.transaction(() => {
+                        for (const operation of batch) {
+                            try {
+                                operation.write();
+                            }
+                            catch (error) {
+                                this.reportError(error, operation.onError);
+                            }
+                        }
+                    });
+                }
+                catch (error) {
+                    for (const operation of batch)
+                        this.reportError(error, operation.onError);
+                }
+            }
+        }
+        finally {
+            this.flushing = false;
+            if (!this.closed && this.pending.length > 0)
+                this.scheduleFlush();
+        }
+    }
+    reportError(error, operationHandler) {
+        try {
+            operationHandler?.(error);
+        }
+        catch {
+            // Telemetry error reporting must not affect runtime work.
+        }
+        if (operationHandler === this.options.onError)
+            return;
+        try {
+            this.options.onError?.(error);
+        }
+        catch {
+            // Telemetry error reporting must not affect runtime work.
+        }
+    }
+}
+function nonNegativeFinite(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function positiveInteger(value, fallback) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : fallback;
+}