@pasko70/pibo 1.9.9 → 1.9.11

package/dist/debug/telemetry.js

@@ -0,0 +1,649 @@
+import { DatabaseSync } from "node:sqlite";
+import { TelemetryStaleDetector } from "../core/telemetry-staleness.js";
+import { TelemetryStore as PiboTelemetryStore } from "../data/telemetry.js";
+import { formatRows, openReadOnlyDebugDatabase } from "./sql.js";
+const DEFAULT_TELEMETRY_CLI_LIMIT = 20;
+const MAX_TELEMETRY_CLI_LIMIT = 200;
+const TELEMETRY_RETENTION_CLASSES = ["live", "diagnostic", "provider_event", "payload_preview", "incident"];
+export function inspectTelemetrySessions(store, options = {}) {
+    const limit = parseTelemetryLimit(options.limit);
+    return withTelemetryStore(store, (telemetry) => {
+        const readLimit = options.active || options.stale ? MAX_TELEMETRY_CLI_LIMIT : limit;
+        const rows = telemetry.listSessions({ limit: readLimit })
+            .filter((row) => !options.active || row.status === "queued" || row.status === "running")
+            .filter((row) => !options.stale || row.isStale)
+            .slice(0, limit);
+        return {
+            available: true,
+            command: "sessions",
+            filters: { active: options.active === true, stale: options.stale === true },
+            limit,
+            rowCount: rows.length,
+            truncated: rows.length >= limit,
+            rows,
+            nextCommands: [
+                "pibo debug telemetry session <pibo-session-id>",
+                "pibo debug telemetry stale",
+            ],
+        };
+    });
+}
+export function inspectTelemetrySession(store, piboSessionId, options = {}) {
+    const limit = parseTelemetryLimit(options.limit);
+    return withTelemetryStore(store, (telemetry) => {
+        const detail = telemetry.getSessionTelemetry(piboSessionId, { limit });
+        if (!detail)
+            return notFound(`No telemetry found for Pibo Session ${piboSessionId}.`, piboSessionId);
+        return {
+            available: true,
+            command: "session",
+            piboSessionId,
+            limit,
+            truncated: {
+                recentTurns: detail.recentTurns.length >= limit,
+                providerRequests: detail.providerRequests.length >= limit,
+                toolCalls: detail.toolCalls.length >= limit,
+            },
+            detail,
+            nextCommands: detail.nextCommands,
+        };
+    });
+}
+export function inspectTelemetryTurn(store, turnIdOrEventId, options = {}) {
+    const limit = parseTelemetryLimit(options.limit);
+    return withTelemetryStore(store, (telemetry) => {
+        const timeline = telemetry.getTurnTimeline(turnIdOrEventId, { limit });
+        if (!timeline)
+            return notFound(`No telemetry found for turn or event ${turnIdOrEventId}.`, undefined, turnIdOrEventId);
+        const openPhases = timeline.phases.filter((phase) => phase.status === "open").length;
+        const missingTerminalEvent = timeline.turn.status === "running" && !timeline.phases.some((phase) => phase.name === "finish" && phase.status === "ok");
+        return {
+            available: true,
+            command: "turn",
+            turnIdOrEventId,
+            limit,
+            includeEventRefs: options.events === true,
+            truncated: {
+                phases: timeline.phases.length >= limit,
+                providerRequests: timeline.providerRequests.length >= limit,
+                toolCalls: timeline.toolCalls.length >= limit,
+            },
+            timeline,
+            openPhases,
+            missingTerminalEvent,
+            nextCommands: timeline.nextCommands,
+        };
+    });
+}
+export function inspectTelemetryProvider(store, providerRequestId) {
+    return withTelemetryStore(store, (telemetry) => {
+        const request = telemetry.getProviderRequest(providerRequestId);
+        if (!request)
+            return notFound(`No telemetry found for provider request ${providerRequestId}.`);
+        return {
+            available: true,
+            command: "provider",
+            providerRequestId,
+            request,
+            eventTypeRows: providerEventTypeRows(request),
+            nextCommands: providerNextCommands(request),
+        };
+    });
+}
+export function inspectTelemetryProviderEvents(store, providerRequestId, options = {}) {
+    const limit = parseTelemetryLimit(options.limit);
+    const afterSequence = parseTelemetryCursor(options.after);
+    return withTelemetryStore(store, (telemetry) => {
+        const request = telemetry.getProviderRequest(providerRequestId);
+        if (!request)
+            return notFound(`No telemetry found for provider request ${providerRequestId}.`);
+        const requestedFields = normalizeSafeFields(options.fields);
+        const page = telemetry.listProviderEventsPage(providerRequestId, { limit, afterSequence });
+        const rows = page.rows.map((row) => ({
+            ...row,
+            selectedSafeFields: selectSafeFields(row.safeFields, requestedFields),
+        }));
+        return {
+            available: true,
+            command: "provider events",
+            providerRequestId,
+            limit,
+            afterSequence,
+            requestedFields,
+            page,
+            rows,
+            nextCommands: providerNextCommands(request, page.nextAfterSequence),
+        };
+    });
+}
+export function inspectTelemetryProviderPayload(store, providerRequestId, payloadRef) {
+    return withTelemetryStore(store, (telemetry) => {
+        const request = telemetry.getProviderRequest(providerRequestId);
+        if (!request)
+            return notFound(`No telemetry found for provider request ${providerRequestId}.`);
+        return {
+            available: true,
+            command: "provider payload",
+            providerRequestId,
+            payloadRef,
+            preview: telemetry.getPayloadPreview(payloadRef),
+            nextCommands: providerNextCommands(request),
+        };
+    });
+}
+export function inspectTelemetryTool(store, toolCallId) {
+    return withTelemetryStore(store, (telemetry) => {
+        const tool = telemetry.getToolCall(toolCallId);
+        if (!tool)
+            return notFound(`No telemetry found for tool call ${toolCallId}.`);
+        return {
+            available: true,
+            command: "tool",
+            toolCallId,
+            tool,
+            noExecutionStart: !tool.executionStartedAt,
+            nextCommands: toolNextCommands(tool),
+        };
+    });
+}
+export function inspectTelemetryStale(store, options = {}) {
+    const limit = parseTelemetryLimit(options.limit);
+    const thresholdOverrideMs = parseTelemetryThresholdMs(options.thresholdMs);
+    return withTelemetryStore(store, (telemetry) => {
+        const detector = new TelemetryStaleDetector(telemetry);
+        const rows = detector.listStaleWork({ limit, thresholdMs: thresholdOverrideMs });
+        return {
+            available: true,
+            command: "stale",
+            limit,
+            thresholdOverrideMs,
+            rowCount: rows.length,
+            rows,
+            nextCommands: ["pibo debug telemetry sessions --active", "pibo debug telemetry session <pibo-session-id>"],
+        };
+    });
+}
+export function inspectTelemetryStats(store, options = {}) {
+    const retentionClass = options.retention ? parseTelemetryRetentionClass(options.retention) : undefined;
+    return withTelemetryStore(store, (telemetry) => {
+        const stats = telemetry.getStats();
+        const filteredStats = retentionClass
+            ? {
+                rows: stats.rows.filter((row) => row.retentionClass === retentionClass),
+                totalRows: stats.rows.filter((row) => row.retentionClass === retentionClass).reduce((sum, row) => sum + row.rowCount, 0),
+                totalBytes: stats.rows.filter((row) => row.retentionClass === retentionClass).reduce((sum, row) => sum + row.byteCount, 0),
+            }
+            : stats;
+        return {
+            available: true,
+            command: "stats",
+            retentionClass,
+            stats: filteredStats,
+            nextCommands: ["pibo debug telemetry prune --retention diagnostic --before <iso-date>", "pibo debug telemetry sessions --active"],
+        };
+    });
+}
+export function inspectTelemetryPrune(store, options = {}) {
+    if (!options.retention)
+        throw new Error("pibo debug telemetry prune requires --retention <class>");
+    if (!options.before)
+        throw new Error("pibo debug telemetry prune requires --before <iso-date>");
+    const retentionClass = parseTelemetryRetentionClass(options.retention);
+    const before = parseTelemetryBefore(options.before);
+    return withTelemetryStore(store, (telemetry) => {
+        const result = telemetry.prune({ retentionClass, before, apply: options.apply === true });
+        return {
+            available: true,
+            command: "prune",
+            retentionClass,
+            before,
+            dryRun: options.apply !== true,
+            result,
+            nextCommands: ["pibo debug telemetry stats", "pibo debug telemetry sessions --active"],
+        };
+    }, { readOnly: false });
+}
+export function formatTelemetrySessions(result) {
+    if (!result.available)
+        return formatUnavailable(result);
+    const rows = result.rows.map((row) => ({
+        piboSessionId: row.piboSessionId,
+        status: row.status,
+        activeTurnId: row.activeTurnId,
+        activePhase: formatPhaseRef(row.activePhase),
+        queueDepth: row.queueDepth,
+        lastProgressAt: row.lastProgressAt,
+        staleForMs: row.staleForMs,
+        isStale: row.isStale,
+        next: row.nextCommands[0],
+    }));
+    return [
+        "pibo debug telemetry sessions",
+        `filters\tactive=${result.filters.active}\tstale=${result.filters.stale}\tlimit=${result.limit}`,
+        formatRows(rows),
+        `truncated\t${result.truncated}`,
+        "Next:",
+        ...result.nextCommands.map((command) => `  ${command}`),
+    ].join("\n");
+}
+export function formatTelemetrySession(result) {
+    if (!result.available)
+        return formatUnavailable(result);
+    const detail = result.detail;
+    const activeTurn = detail.activeTurn;
+    const activePhase = detail.activePhase;
+    const providerRequestId = firstId(detail.providerRequests, "providerRequestId");
+    const toolCallId = firstId(detail.toolCalls, "toolCallId");
+    return [
+        `pibo debug telemetry session ${result.piboSessionId}`,
+        `status\t${activeTurn?.status ?? "idle"}`,
+        `queueDepth\t${activeTurn?.queueDepth ?? "-"}`,
+        `activeTurn\t${activeTurn?.turnId ?? "-"}`,
+        `activePhase\t${formatPhaseRef(activePhase)}`,
+        `lastProgressAt\t${activePhase?.lastProgressAt ?? activeTurn?.lastProgressAt ?? "-"}`,
+        `staleForMs\t${formatAgeMs(activePhase?.lastProgressAt ?? activeTurn?.lastProgressAt)}`,
+        `providerRequestId\t${providerRequestId ?? "-"}`,
+        `toolCallId\t${toolCallId ?? "-"}`,
+        "recent_turns:",
+        formatRows(detail.recentTurns.map(compactTurnRow)),
+        "providers:",
+        formatRows(detail.providerRequests.map(compactProviderRow)),
+        "tools:",
+        formatRows(detail.toolCalls.map(compactToolRow)),
+        `truncated\trecentTurns=${result.truncated.recentTurns}\tproviderRequests=${result.truncated.providerRequests}\ttoolCalls=${result.truncated.toolCalls}`,
+        "Next:",
+        ...(result.nextCommands.length > 0 ? result.nextCommands.map((command) => `  ${command}`) : ["  pibo debug telemetry sessions"]),
+    ].join("\n");
+}
+export function formatTelemetryTurn(result) {
+    if (!result.available)
+        return formatUnavailable(result);
+    const timeline = result.timeline;
+    const phaseRows = timeline.phases.map((phase) => compactPhaseRow(phase, result.includeEventRefs));
+    return [
+        `pibo debug telemetry turn ${timeline.turn.turnId}`,
+        `session\t${timeline.turn.piboSessionId}`,
+        `status\t${timeline.turn.status}`,
+        `currentPhase\t${timeline.turn.currentPhase ?? "-"}`,
+        `openPhases\t${result.openPhases}`,
+        `missingTerminalEvent\t${result.missingTerminalEvent}`,
+        "phases:",
+        formatRows(phaseRows),
+        "providers:",
+        formatRows(timeline.providerRequests.map(compactProviderRow)),
+        "tools:",
+        formatRows(timeline.toolCalls.map(compactToolRow)),
+        `truncated\tphases=${result.truncated.phases}\tproviderRequests=${result.truncated.providerRequests}\ttoolCalls=${result.truncated.toolCalls}`,
+        "Next:",
+        ...(result.nextCommands.length > 0 ? result.nextCommands.map((command) => `  ${command}`) : [`  pibo debug telemetry session ${timeline.turn.piboSessionId}`]),
+    ].join("\n");
+}
+export function formatTelemetryProvider(result) {
+    if (!result.available)
+        return formatUnavailable(result);
+    const request = result.request;
+    return [
+        `pibo debug telemetry provider ${result.providerRequestId}`,
+        `session\t${request.piboSessionId}`,
+        `turn\t${request.turnId}`,
+        `phase\t${request.phaseId ?? "-"}`,
+        `status\t${request.status}`,
+        `provider\t${request.provider}`,
+        `api\t${request.api}`,
+        `model\t${request.model}`,
+        `transport\t${request.transport}`,
+        `serviceTier\t${request.serviceTier ?? "-"}`,
+        `httpStatus\t${request.httpStatus ?? "-"}`,
+        `startedAt\t${request.startedAt}`,
+        `responseHeadersAt\t${request.responseHeadersAt ?? "-"}`,
+        `firstByteAt\t${request.firstByteAt ?? "-"}`,
+        `lastRawEventAt\t${request.lastRawEventAt ?? "-"}`,
+        `lastNormalizedEventAt\t${request.lastNormalizedEventAt ?? "-"}`,
+        `completedAt\t${request.completedAt ?? "-"}`,
+        `upstreamResponseId\t${request.upstreamResponseId ?? "-"}`,
+        `captureMode\t${request.captureMode}`,
+        `rawEventCount\t${request.rawEventCount}`,
+        `normalizedEventCount\t${request.normalizedEventCount}`,
+        `parseErrorCount\t${request.parseErrorCount}`,
+        `unknownEventCount\t${request.unknownEventCount}`,
+        `bytesReceived\t${request.bytesReceived ?? 0}`,
+        "event_types:",
+        formatRows(result.eventTypeRows),
+        "Next:",
+        ...result.nextCommands.map((command) => `  ${command}`),
+    ].join("\n");
+}
+export function formatTelemetryProviderEvents(result) {
+    if (!result.available)
+        return formatUnavailable(result);
+    return [
+        `pibo debug telemetry provider ${result.providerRequestId} events`,
+        `limit\t${result.limit}`,
+        `afterSequence\t${result.afterSequence}`,
+        `storageMode\t${result.page.storageMode}`,
+        `hasMore\t${result.page.hasMore}`,
+        `nextAfterSequence\t${result.page.nextAfterSequence ?? "-"}`,
+        `fields\t${result.requestedFields.length > 0 ? result.requestedFields.join(",") : "all-safe"}`,
+        formatRows(result.rows.map(compactProviderEventRow)),
+        `truncated\t${result.page.truncated}`,
+        "Next:",
+        ...result.nextCommands.map((command) => `  ${command}`),
+    ].join("\n");
+}
+export function formatTelemetryProviderPayload(result) {
+    if (!result.available)
+        return formatUnavailable(result);
+    return [
+        `pibo debug telemetry provider ${result.providerRequestId} payload ${result.payloadRef}`,
+        `status\t${result.preview.status}`,
+        `reason\t${result.preview.reason}`,
+        `captureMode\t${result.preview.captureMode}`,
+        result.preview.message,
+        "Next:",
+        ...result.nextCommands.map((command) => `  ${command}`),
+    ].join("\n");
+}
+export function formatTelemetryTool(result) {
+    if (!result.available)
+        return formatUnavailable(result);
+    const tool = result.tool;
+    return [
+        `pibo debug telemetry tool ${result.toolCallId}`,
+        `session\t${tool.piboSessionId}`,
+        `turn\t${tool.turnId}`,
+        `providerRequestId\t${tool.providerRequestId ?? "-"}`,
+        `toolName\t${tool.toolName}`,
+        `status\t${tool.status}`,
+        `argsBytes\t${tool.argsBytes}`,
+        `parseStatus\t${tool.parseStatus}`,
+        `safeArgKeys\t${tool.safeArgKeys.length > 0 ? tool.safeArgKeys.join(",") : "-"}`,
+        `argsStartedAt\t${tool.argsStartedAt ?? "-"}`,
+        `firstDeltaAt\t${tool.firstDeltaAt ?? "-"}`,
+        `lastDeltaAt\t${tool.lastDeltaAt ?? "-"}`,
+        `argsCompletedAt\t${tool.argsCompletedAt ?? "-"}`,
+        `executionStartedAt\t${tool.executionStartedAt ?? "-"}`,
+        `executionEndedAt\t${tool.executionEndedAt ?? "-"}`,
+        `durationMs\t${tool.durationMs ?? "-"}`,
+        `noExecutionStart\t${result.noExecutionStart}`,
+        `runId\t${tool.runId ?? "-"}`,
+        `errorCategory\t${tool.errorCategory ?? "-"}`,
+        `errorMessage\t${tool.errorMessage ?? "-"}`,
+        `eventId\t${tool.eventId ?? "-"}`,
+        `eventStreamId\t${tool.eventStreamId ?? "-"}`,
+        `payloadRef\t${tool.payloadRef ?? "-"}`,
+        "Next:",
+        ...result.nextCommands.map((command) => `  ${command}`),
+    ].join("\n");
+}
+export function formatTelemetryStale(result) {
+    if (!result.available)
+        return formatUnavailable(result);
+    return [
+        "pibo debug telemetry stale",
+        `limit\t${result.limit}`,
+        `thresholdOverrideMs\t${result.thresholdOverrideMs ?? "-"}`,
+        formatRows(result.rows.map(compactStaleRow)),
+        "Next:",
+        ...result.nextCommands.map((command) => `  ${command}`),
+    ].join("\n");
+}
+export function formatTelemetryStats(result) {
+    if (!result.available)
+        return formatUnavailable(result);
+    return [
+        "pibo debug telemetry stats",
+        `retentionClass\t${result.retentionClass ?? "all"}`,
+        `totalRows\t${result.stats.totalRows}`,
+        `totalBytes\t${result.stats.totalBytes}`,
+        formatRows(result.stats.rows),
+        "Next:",
+        ...result.nextCommands.map((command) => `  ${command}`),
+    ].join("\n");
+}
+export function formatTelemetryPrune(result) {
+    if (!result.available)
+        return formatUnavailable(result);
+    return [
+        "pibo debug telemetry prune",
+        `retentionClass\t${result.retentionClass}`,
+        `before\t${result.before}`,
+        `dryRun\t${result.dryRun}`,
+        formatRows([result.result]),
+        "Next:",
+        ...result.nextCommands.map((command) => `  ${command}`),
+    ].join("\n");
+}
+function withTelemetryStore(store, action, options = {}) {
+    if (!store.exists) {
+        return {
+            available: false,
+            reason: "store_missing",
+            message: `Debug store "${store.name}" not found at ${store.path}`,
+            nextCommands: ["pibo debug db stores"],
+        };
+    }
+    const db = options.readOnly === false ? openWritableDebugDatabase(store) : openReadOnlyDebugDatabase(store);
+    try {
+        const tables = db.prepare("SELECT name FROM sqlite_schema WHERE type = 'table' AND name LIKE 'telemetry_%'").all();
+        if (tables.length === 0) {
+            return {
+                available: false,
+                reason: "tables_missing",
+                message: "Telemetry tables are not present in pibo.sqlite; no telemetry is available for this store.",
+                nextCommands: ["pibo debug db schema pibo-data"],
+            };
+        }
+        return action(new PiboTelemetryStore(db));
+    }
+    finally {
+        db.close();
+    }
+}
+function openWritableDebugDatabase(store) {
+    if (!store.exists)
+        throw new Error(`Debug store "${store.name}" not found at ${store.path}`);
+    const db = new DatabaseSync(store.path);
+    db.exec("PRAGMA busy_timeout = 5000");
+    return db;
+}
+function parseTelemetryLimit(value) {
+    if (value === undefined)
+        return DEFAULT_TELEMETRY_CLI_LIMIT;
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1)
+        throw new Error("Limit must be a positive integer");
+    return Math.min(parsed, MAX_TELEMETRY_CLI_LIMIT);
+}
+function parseTelemetryThresholdMs(value) {
+    if (value === undefined)
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1)
+        throw new Error("--threshold-ms must be a positive integer");
+    return parsed;
+}
+function parseTelemetryRetentionClass(value) {
+    if (TELEMETRY_RETENTION_CLASSES.includes(value))
+        return value;
+    throw new Error(`Unknown telemetry retention class "${value}". Use one of: ${TELEMETRY_RETENTION_CLASSES.join(", ")}`);
+}
+function parseTelemetryBefore(value) {
+    if (!Number.isFinite(Date.parse(value)))
+        throw new Error("--before must be a valid ISO date/time");
+    return value;
+}
+function notFound(message, piboSessionId, turnId) {
+    return {
+        available: false,
+        reason: "not_found",
+        message,
+        nextCommands: [
+            piboSessionId ? `pibo debug session ${piboSessionId}` : undefined,
+            turnId ? "pibo debug telemetry sessions" : undefined,
+            "pibo debug events <pibo-session-id> --limit 20",
+        ].filter((command) => typeof command === "string"),
+    };
+}
+function formatUnavailable(result) {
+    return [
+        result.message,
+        "Next:",
+        ...result.nextCommands.map((command) => `  ${command}`),
+    ].join("\n");
+}
+function compactTurnRow(turn) {
+    return {
+        turnId: turn.turnId,
+        status: turn.status,
+        currentPhase: turn.currentPhase,
+        queuedAt: turn.queuedAt,
+        startedAt: turn.startedAt,
+        completedAt: turn.completedAt,
+        lastProgressAt: turn.lastProgressAt,
+        queueDepth: turn.queueDepth,
+        next: `pibo debug telemetry turn ${turn.turnId}`,
+    };
+}
+function compactPhaseRow(phase, includeEventRefs) {
+    return {
+        phaseId: phase.phaseId,
+        name: phase.name,
+        status: phase.status,
+        startedAt: phase.startedAt,
+        endedAt: phase.endedAt ?? "open",
+        durationMs: phase.durationMs,
+        lastProgressAt: phase.lastProgressAt,
+        staleForMs: formatAgeMs(phase.lastProgressAt ?? phase.startedAt),
+        providerRequestId: phase.providerRequestId,
+        toolCallId: phase.toolCallId,
+        ...(includeEventRefs ? { eventId: phase.eventId, eventStreamId: phase.eventStreamId, payloadRef: phase.payloadRef } : {}),
+    };
+}
+function compactProviderRow(provider) {
+    return {
+        providerRequestId: provider.providerRequestId,
+        status: provider.status,
+        provider: provider.provider,
+        api: provider.api,
+        model: provider.model,
+        firstByteAt: provider.firstByteAt,
+        lastRawEventAt: provider.lastRawEventAt,
+        lastNormalizedEventAt: provider.lastNormalizedEventAt,
+        rawEventCount: provider.rawEventCount,
+        parseErrorCount: provider.parseErrorCount,
+        unknownEventCount: provider.unknownEventCount,
+        next: `pibo debug telemetry provider ${provider.providerRequestId}`,
+    };
+}
+function compactProviderEventRow(event) {
+    return {
+        sequence: event.sequence,
+        rawEventId: event.rawEventId,
+        receivedAt: event.receivedAt,
+        eventType: event.eventType,
+        byteSize: event.byteSize,
+        parseStatus: event.parseStatus,
+        normalizedType: event.normalizedType,
+        itemId: event.itemId,
+        toolCallId: event.toolCallId,
+        eventId: event.eventId,
+        eventStreamId: event.eventStreamId,
+        payloadPreviewRef: event.payloadPreviewRef,
+        safeFields: formatSafeFields(event.selectedSafeFields),
+    };
+}
+function compactStaleRow(item) {
+    return {
+        piboSessionId: item.piboSessionId,
+        turnId: item.turnId,
+        activePhase: item.activePhase ?? item.phase,
+        staleForMs: item.staleForMs,
+        lastProgressAt: item.lastProgressAt,
+        queueDepth: item.queueDepth,
+        appliedThresholdMs: item.appliedThresholdMs,
+        thresholdSource: item.thresholdSource,
+        thresholdKey: item.thresholdKey,
+        provider: item.provider,
+        model: item.model,
+        profile: item.profile,
+        next: item.nextCommands[0],
+    };
+}
+function compactToolRow(tool) {
+    return {
+        toolCallId: tool.toolCallId,
+        status: tool.status,
+        toolName: tool.toolName,
+        argsBytes: tool.argsBytes,
+        parseStatus: tool.parseStatus,
+        argsCompletedAt: tool.argsCompletedAt,
+        executionStartedAt: tool.executionStartedAt,
+        executionEndedAt: tool.executionEndedAt,
+        next: `pibo debug telemetry tool ${tool.toolCallId}`,
+    };
+}
+function formatPhaseRef(phase) {
+    return phase ? `${phase.name}:${phase.status}` : "-";
+}
+function formatAgeMs(timestamp) {
+    if (!timestamp)
+        return "-";
+    const parsed = Date.parse(timestamp);
+    if (!Number.isFinite(parsed))
+        return "-";
+    return Math.max(0, Date.now() - parsed);
+}
+function firstId(items, key) {
+    return items.length > 0 ? items[0]?.[key] : undefined;
+}
+function parseTelemetryCursor(value) {
+    if (value === undefined)
+        return -1;
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0)
+        throw new Error("--after must be a non-negative provider event sequence");
+    return parsed;
+}
+const SAFE_FIELD_NAME_PATTERN = /^[A-Za-z0-9_.:-]{1,128}$/;
+function normalizeSafeFields(fields) {
+    return [...new Set((fields ?? []).filter((field) => SAFE_FIELD_NAME_PATTERN.test(field)))];
+}
+function selectSafeFields(value, requestedFields) {
+    const selected = {};
+    const entries = requestedFields.length > 0
+        ? requestedFields.map((field) => [field, value[field]])
+        : Object.entries(value).slice(0, 20);
+    for (const [key, raw] of entries) {
+        if (typeof raw === "string" || typeof raw === "number" || typeof raw === "boolean" || raw === null)
+            selected[key] = raw;
+    }
+    return selected;
+}
+function formatSafeFields(value) {
+    const entries = Object.entries(value);
+    if (entries.length === 0)
+        return "-";
+    return entries.map(([key, raw]) => `${key}=${String(raw)}`).join(",");
+}
+function providerEventTypeRows(provider) {
+    return Object.entries(provider.eventTypeCounts)
+        .filter((entry) => typeof entry[1] === "number")
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([eventType, count]) => ({ eventType, count }));
+}
+function providerNextCommands(provider, nextAfterSequence) {
+    return [
+        `pibo debug telemetry turn ${provider.turnId}`,
+        `pibo debug telemetry provider ${provider.providerRequestId} events --limit 20`,
+        typeof nextAfterSequence === "number" ? `pibo debug telemetry provider ${provider.providerRequestId} events --after ${nextAfterSequence} --limit 20` : undefined,
+        `pibo debug telemetry session ${provider.piboSessionId}`,
+    ].filter((command) => typeof command === "string");
+}
+function toolNextCommands(tool) {
+    return [
+        `pibo debug telemetry turn ${tool.turnId}`,
+        tool.providerRequestId ? `pibo debug telemetry provider ${tool.providerRequestId}` : undefined,
+        tool.providerRequestId ? `pibo debug telemetry provider ${tool.providerRequestId} events --limit 20` : undefined,
+        `pibo debug telemetry session ${tool.piboSessionId}`,
+    ].filter((command) => typeof command === "string");
+}