agent-inspect 1.3.0 → 1.5.0

package/packages/core/dist/index.d.ts

@@ -1,156 +1,128 @@
+import { T as TraceEvent, R as RunSummary, a as TraceMetadata, b as TraceMetadataStatus, S as StepType, c as StepStatus, d as TraceCorrelationMetadata, e as RedactionProfile, I as InspectRunOptions, f as StepOptions, O as ObserveOptions } from './types-Bkt7LS01.js';
+export { A as ActiveStepContext, E as ErrorInfo, g as ExecutionContext, h as Run, i as RunCompletedEvent, j as RunStartedEvent, k as RunStatus, l as Step, m as StepCompletedEvent, n as StepMetadata, o as StepStartedEvent, p as TokenMetadata, q as TraceEventBase, r as TraceSchemaVersion, s as isStepStatus, t as isStepType, u as isTraceEvent } from './types-Bkt7LS01.js';
+export { A as AttributionConfidence, E as EventSource, I as InspectEvent, a as InspectKind, b as InspectNode, c as InspectRunTree, L as LogEventMapping, d as LogIngestConfig, R as RedactionRule, e as RedactionStrategy } from './log-config-BzGmDYum.js';
+import { PersistedInspectEvent } from './persisted.js';
+export { InspectEventToPersistedOptions, PersistedEventSource, PersistedEventSourceType, PersistedEventStatus, PersistedInspectError, PersistedSchemaVersion, PersistedToInspectEventOptions, PersistedToTraceEventOptions, PersistedTokenUsage, PersistedTraceContext, PersistedTreeBridgeOptions, TraceEventToPersistedOptions, inspectEventToPersistedInspectEvent, inspectEventsToPersistedInspectEvents, isPersistedInspectEvent, persistedInspectEventToInspectEvent, persistedInspectEventToTraceEvents, persistedInspectEventsToInspectEvents, persistedInspectEventsToRunTrees, persistedInspectEventsToTraceEvents, traceEventToPersistedInspectEvent, traceEventsToPersistedInspectEvents, traceEventsToPersistedRunTrees } from './persisted.js';
+export { DEFAULT_LOG_INGEST_CONFIG, DEFAULT_REDACT_KEYS, EventNormalizer, JsonLogParser, LiveLogAccumulator, LiveLogAccumulatorOptions, LiveLogUpdate, Log4jsParser, LogSourceFormat, LogToTreeResult, NormalizeOptions, ParseLogLineOptions, ParseLogsOptions, ParseResult, ParserWarning, ParserWarningCode, RawLogRecord, Redactor, RedactorOptions, RenderTreeOptions, TreeBuilder, TreeBuilderOptions, loadLogIngestConfig, matchMapping, mergeLogIngestConfig, parseLogLine, parseLogsToTrees, renderRunTree, renderRunTrees, wildcardMatch } from './logs.js';
+export { DEFAULT_MAX_EVENT_BYTES, DEFAULT_MAX_METADATA_VALUE_LENGTH, DEFAULT_MAX_PREVIEW_LENGTH, DEFAULT_TRACE_DIR_NAME, FALLBACK_TRACE_DIR, MAX_NAME_LENGTH, MAX_TERMINAL_DEPTH, MAX_TERMINAL_NAME_LENGTH, RUNS_DIR_NAME, ResolvedRedactionProfile, TERMINAL_INDENT, TraceSafetyOptions, createRunId, createStepId, ensureTraceDir, formatDuration, formatError, formatTerminalName, formatTimestamp, getCurrentContext, getCurrentCorrelationMetadata, getCurrentDepth, getCurrentRunId, getCurrentRunName, getCurrentStepId, getDefaultTraceDir, getIndent, getParentStepId, getTraceDirFromContext, getTraceFilePath, getTraceSafetyFromContext, hasActiveContext, isSilentContext, prepareMetadataForDisk, prepareTraceEventForDisk, printError, printFailedAt, printRunComplete, printRunStart, printStepComplete, printStepStart, renderErrorLine, renderRunSummary, renderStepLine, resolveRedactionProfile, resolveTraceSafetyOptions, runWithContext, runWithStepContext, truncateName, warn } from './advanced.js';
 import { Stats } from 'node:fs';
-
-type AttributionConfidence = "explicit" | "correlated" | "heuristic" | "unknown";
-type InspectKind = "RUN" | "AGENT" | "LLM" | "TOOL" | "CHAIN" | "RETRIEVER" | "DECISION" | "RESULT" | "ERROR" | "LOGIC" | "LOG";
-interface EventSource {
-    type: "manual" | "json-log" | "log4js" | "pino" | "winston" | "adapter";
-    file?: string;
-    line?: number;
-}
-interface InspectEvent {
-    eventId: string;
-    runId: string;
-    parentId?: string;
-    name: string;
-    kind: InspectKind;
-    timestamp: number;
-    status?: "running" | "ok" | "error";
-    durationMs?: number;
-    attributes?: Record<string, unknown>;
-    confidence: AttributionConfidence;
-    source: EventSource;
-}
-interface InspectNode {
-    event: InspectEvent;
-    children: InspectNode[];
-    depth: number;
-}
-interface InspectRunTree {
-    runId: string;
-    name?: string;
-    status?: "running" | "ok" | "error";
-    startedAt?: number;
-    endedAt?: number;
-    durationMs?: number;
-    children: InspectNode[];
-    metadata: {
-        totalEvents: number;
-        confidenceBreakdown: Record<AttributionConfidence, number>;
-        kinds: Record<InspectKind, number>;
-    };
-}
-
-interface LogEventMapping {
-    kind?: InspectKind;
-    name?: string;
-    parent?: string;
-    status?: "running" | "ok" | "error";
-    startsRun?: boolean;
-    endsRun?: boolean;
-    startsStep?: boolean;
-    endsStep?: boolean;
-}
-type RedactionStrategy = "full" | "prefix" | "hash";
-type RedactionRule = string | {
-    key: string;
-    strategy: RedactionStrategy;
-    keep?: number;
-};
-interface LogIngestConfig {
-    runIdKeys: string[];
-    eventKey: string;
-    timestampKey?: string;
-    messageKey?: string;
-    levelKey?: string;
-    parentIdKey?: string;
-    durationKey?: string;
-    statusKey?: string;
-    mappings?: Record<string, LogEventMapping>;
-    redact?: RedactionRule[];
-    heuristicWindowMs?: number;
-}
+export { DiffKind, DiffOptions, DiffPath, DiffPathSegment, DiffSeverity, RenderDiffOptions, RunComparable, RunDiffItem, RunDiffResult, RunDiffSummary, StepComparable, diffRuns, diffTraceEvents, manualTraceEventsToComparableRun, renderRunDiff } from './diff.js';
+export { EXPORT_PAYLOAD_VERSION, ExportFormat, ExportOptions, ExportResult, ExportValidationResult, OpenInferenceExport, OpenInferenceSpan, TraceExporter, compactAttributes, escapeHtml, escapeMarkdown, exportHtml, exportMarkdown, exportOpenInference, exportOtlpJson, exportRunTree, flattenTree, manualTraceEventsToRunTree, mergeExportDefaults, redactRunTreeForExport, safeString, stableJson, summarizeTree, validateExport, validateExportContent } from './exporters.js';
 
 /**
- * Discriminator for what kind of work a {@link Step} represents.
- * `"decision"` captures agent branching/choices; other values cover runs, LLM calls, tools, and user-defined steps.
+ * Strict MVP validation before writing JSONL. Rejects empty ids, non-finite times, and malformed payloads.
  */
-type StepType = "run" | "llm" | "tool" | "decision" | "logic" | "state" | "custom";
-/** Lifecycle state of a single {@link Step}. */
-type StepStatus = "running" | "success" | "error";
-/** Lifecycle state of an entire {@link Run}. */
-type RunStatus = "running" | "success" | "error";
-/** Structured error attached to a run or step when status is `"error"`. */
-interface ErrorInfo {
-    message: string;
-    stack?: string;
-}
+declare function validateEvent(event: unknown): event is TraceEvent;
+/** Serializes a trace line as compact JSON without a trailing newline. */
+declare function serializeEvent(event: TraceEvent): string;
 /**
- * Optional token counts for a step (e.g. LLM usage).
- * Reserved for future roadmap; MVP does not compute or persist token usage.
+ * Creates (or truncates) an empty JSONL file for a run. Uses {@link ensureTraceDir} then {@link getTraceFilePath}.
+ * On failure, retries once under {@link FALLBACK_TRACE_DIR}.
  */
-interface TokenMetadata {
-    input?: number;
-    output?: number;
+declare function initializeTraceFile(runId: string, traceDir: string): Promise<string | undefined>;
+declare function writeTraceEvent(event: TraceEvent, traceDir: string): Promise<void>;
+/**
+ * Reads raw JSONL file contents for a run, or `undefined` if missing or unreadable.
+ */
+declare function readTraceFile(runId: string, traceDir: string): Promise<string | undefined>;
+/**
+ * Parses JSONL into validated {@link TraceEvent} rows (v0.1 native or v0.2 normalized).
+ * Invalid lines are skipped with a warning.
+ */
+declare function readTraceEvents(runId: string, traceDir: string): Promise<TraceEvent[]>;
+/**
+ * Lists `.jsonl` file names in `traceDir`, newest by mtime first (name sort as tie-breaker).
+ */
+declare function listTraceFiles(traceDir: string): Promise<string[]>;
+/** Maps a `.jsonl` file name to its run id (basename only; no traversal). */
+declare function getRunIdFromTraceFileName(fileName: string): string | undefined;
+
+type TraceJsonlFormat = "0.1" | "0.2" | "mixed" | "empty";
+interface ParseTraceJsonlResult {
+    format: TraceJsonlFormat;
+    events: TraceEvent[];
+    persisted: PersistedInspectEvent[];
 }
-/** Arbitrary structured fields for a step; safe extensions use string keys. */
-interface StepMetadata {
-    model?: string;
-    toolName?: string;
-    tokens?: TokenMetadata;
-    retryCount?: number;
-    [key: string]: unknown;
+interface ParseTraceJsonlOptions {
+    validate?: (value: unknown) => value is TraceEvent;
 }
 /**
- * One traced agent run (root of an execution tree).
- * MVP intentionally omits `input` / `output` on the run to limit PII, secrets, and serialization risk.
+ * Parses JSONL content into normalized v0.1 {@link TraceEvent} rows.
+ * Accepts homogenous v0.1 or v0.2 files; mixed files are converted with a warning.
  */
-interface Run {
-    id: string;
-    name: string;
-    status: RunStatus;
-    startTime: number;
-    endTime?: number;
-    durationMs?: number;
-    error?: ErrorInfo;
-    metadata?: Record<string, unknown>;
-}
+declare function parseTraceJsonl(raw: string, options?: ParseTraceJsonlOptions): ParseTraceJsonlResult;
 /**
- * One node in the execution tree under a {@link Run}.
- * MVP intentionally omits `input` / `output`; capture/redaction may come in a later version.
+ * Returns a user-facing message when a trace file uses an unsupported schema version.
  */
-interface Step {
-    id: string;
-    runId: string;
-    parentId?: string;
+declare function unknownTraceFormatMessage(): string;
+
+interface TraceDirectoryOptions {
+    dir?: string;
+}
+declare function resolveTraceDir(options?: TraceDirectoryOptions): string;
+declare class TraceDirectory {
+    #private;
+    constructor(options?: TraceDirectoryOptions);
+    getPath(filename?: string): string;
+    list(): Promise<string[]>;
+    getFileStats(filename: string): Promise<Stats>;
+}
+
+declare function extractMetadata(filePath: string, _quickScan?: boolean): Promise<TraceMetadata>;
+declare function buildRunSummary(events: TraceEvent[]): RunSummary;
+
+interface TraceFilterOptions {
+    status?: TraceMetadataStatus;
+    name?: string;
+    since?: string;
+    limit?: number;
+}
+declare function filterTraces(traces: TraceMetadata[], options: TraceFilterOptions): TraceMetadata[];
+
+type TimelineFocus = "all" | "slow";
+interface TimelineEntry {
+    stepId: string;
     name: string;
     type: StepType;
     status: StepStatus;
-    startTime: number;
-    endTime?: number;
+    depth: number;
+    startedAt: number;
+    offsetMs: number;
     durationMs?: number;
-    error?: ErrorInfo;
-    metadata?: StepMetadata;
+    isError: boolean;
+    slow?: boolean;
+    streaming?: {
+        chunkCount?: number;
+        streamDurationMs?: number;
+        streamedCharCount?: number;
+    };
 }
-/** Version of the JSONL trace line schema consumed by AgentInspect tooling. */
-type TraceSchemaVersion = "0.1";
-/**
- * Status for lightweight trace metadata extraction.
- * `"unknown"` means the file contained valid events but a run status could not be determined safely.
- */
-type TraceMetadataStatus = "success" | "error" | "running" | "unknown";
-interface TraceMetadata {
+interface RunTimeline {
     runId: string;
     name?: string;
     status: TraceMetadataStatus;
     startedAt?: number;
     endedAt?: number;
     durationMs?: number;
-    eventCount: number;
-    filePath: string;
-    fileSize: number;
-    createdAt: Date;
+    correlation?: {
+        correlationId?: string;
+        requestId?: string;
+        decisionId?: string;
+        groupId?: string;
+    };
+    entries: TimelineEntry[];
+}
+interface TimelineOptions {
+    focus?: TimelineFocus;
+    slowTopN?: number;
 }
-interface RunSummary {
+declare function buildRunTimeline(events: TraceEvent[], options?: TimelineOptions): RunTimeline;
+interface RenderTimelineOptions {
+    focus?: TimelineFocus;
+}
+declare function renderTimeline(timeline: RunTimeline, options?: RenderTimelineOptions): string;
+
+interface RunWhatSummary {
     runId: string;
     name?: string;
     status: TraceMetadataStatus;
@@ -170,574 +142,126 @@ interface RunSummary {
         input: number;
         output: number;
     };
-}
-/** Fields shared by every persisted trace event line. */
-interface TraceEventBase {
-    schemaVersion: TraceSchemaVersion;
-    event: string;
-    timestamp: number;
-}
-/** Emitted when a run begins. */
-interface RunStartedEvent extends TraceEventBase {
-    event: "run_started";
-    runId: string;
-    name: string;
-    startTime: number;
-    metadata?: Record<string, unknown>;
-}
-/** Emitted when a run finishes successfully or with an error. */
-interface RunCompletedEvent extends TraceEventBase {
-    event: "run_completed";
-    runId: string;
-    status: "success" | "error";
-    endTime: number;
-    durationMs: number;
-    error?: ErrorInfo;
-}
-/** Emitted when a step begins (including nested steps under `parentId`). */
-interface StepStartedEvent extends TraceEventBase {
-    event: "step_started";
-    runId: string;
-    stepId: string;
-    parentId?: string;
-    name: string;
-    type: StepType;
-    startTime: number;
-    metadata?: StepMetadata;
+    correlation?: TraceCorrelationMetadata;
+    failedStepNames: string[];
+    runErrorMessage?: string;
 }
 /**
- * Emitted when a step finishes (success or failure).
- * Failures use `status: "error"` and optional {@link ErrorInfo}; there is no separate `step_failed` event in MVP.
+ * Build a concise inspection summary for `what` / report workflows.
+ * Read-only over in-memory v0.1 {@link TraceEvent} rows.
  */
-interface StepCompletedEvent extends TraceEventBase {
-    event: "step_completed";
-    runId: string;
-    stepId: string;
-    status: "success" | "error";
-    endTime: number;
-    durationMs: number;
-    error?: ErrorInfo;
-}
-/** Discriminated union of all MVP trace events written as JSONL lines. */
-type TraceEvent = RunStartedEvent | RunCompletedEvent | StepStartedEvent | StepCompletedEvent;
-/** Named redaction presets for trace writing and share-safe exports (v1.3.0+). */
-type RedactionProfile = "local" | "share" | "strict";
-/** Optional correlation fields for grouping and cross-run tracing (v1.3.0+). */
-interface TraceCorrelationMetadata {
-    correlationId?: string;
-    requestId?: string;
-    decisionId?: string;
-    groupId?: string;
-}
-/** Options for `inspectRun()` and `maybeInspectRun()`. */
-interface InspectRunOptions extends TraceCorrelationMetadata {
-    traceDir?: string;
-    silent?: boolean;
-    metadata?: Record<string, unknown>;
-    /**
-     * When `false`, runs `fn` with no trace file, no execution context, and no terminal output.
-     * Omitted or `true` preserves default tracing behavior.
-     */
-    enabled?: boolean;
-    /**
-     * Redact sensitive metadata keys before writing JSONL. Default `true` (conservative keys).
-     * Pass `false` to persist metadata as-is (explicit opt-out).
-     */
-    redact?: boolean | {
-        rules?: RedactionRule[];
-    };
-    /**
-     * Redaction preset for trace metadata. Default `local` (same keys as default redaction).
-     * `share` and `strict` add extra key-based redaction and tighter string bounds.
-     * Ignored when `redact: false`.
-     */
-    redactionProfile?: RedactionProfile;
-    /** Max UTF-8 bytes for a serialized trace event line. Default 65536. */
-    maxEventBytes?: number;
-    /** Max length for string metadata values (non-preview keys). Default 2000. */
-    maxMetadataValueLength?: number;
-    /** Max length for preview-like metadata keys (contains `preview`). Default 500. */
-    maxPreviewLength?: number;
-}
-/** Options passed when opening a logical step (implemented in a later step). */
-interface StepOptions {
-    type?: StepType;
-    metadata?: StepMetadata;
+declare function buildRunWhatSummary(events: TraceEvent[]): RunWhatSummary;
+interface RenderWhatOptions {
+    /** Include correlation ids when present (default true). */
+    correlation?: boolean;
 }
-/** Options for `observe()` — same surface as {@link InspectRunOptions} in MVP. */
-type ObserveOptions = InspectRunOptions;
 /**
- * Resolved settings for the active run while tracing is enabled.
- * Populated by runtime code in a later step; defined here for `context.ts`.
+ * Render a human-readable `what` summary (plain text, no ANSI).
  */
-interface ExecutionContext {
-    runId: string;
-    runName: string;
-    traceDir: string;
-    silent: boolean;
-    metadata?: Record<string, unknown>;
+declare function renderRunWhat(summary: RunWhatSummary, options?: RenderWhatOptions): string;
+
+type ReportFormat = "markdown" | "html";
+interface ReportOptions {
+    format: ReportFormat;
+    includeAttributes?: boolean;
+    includeErrors?: boolean;
+    redactionProfile?: RedactionProfile;
+    /** Include correlation ids in the what section (default true). */
+    correlation?: boolean;
 }
-/** Stack position of the step currently executing (used by future context tracking). */
-interface ActiveStepContext {
-    stepId: string;
-    parentId?: string;
-    depth: number;
+interface ReportResult {
+    format: ReportFormat;
+    content: string;
+    contentType: string;
+    fileExtension: string;
 }
-/** Returns true if `value` is one of the MVP {@link StepType} literals. */
-declare function isStepType(value: unknown): value is StepType;
-/** Returns true if `value` is one of the MVP {@link StepStatus} literals. */
-declare function isStepStatus(value: unknown): value is StepStatus;
 /**
- * Narrowing guard for a {@link TraceEvent} object with required MVP fields.
- * Does not deeply validate optional `metadata` shapes.
+ * Build a local inspection report (markdown or HTML) from v0.1 trace events.
+ * Composes `what`, timeline, and execution-tree sections.
  */
-declare function isTraceEvent(value: unknown): value is TraceEvent;
+declare function buildRunReport(events: TraceEvent[], options: ReportOptions): ReportResult;
 
-type PersistedSchemaVersion = "0.2";
-type PersistedEventSourceType = "manual" | "json-log" | "log4js" | "adapter" | "ai-sdk" | "otel";
-interface PersistedEventSource {
-    type: PersistedEventSourceType;
-    name?: string;
-    version?: string;
-}
-type PersistedEventStatus = "running" | "ok" | "error" | "unknown";
-interface PersistedInspectError {
-    name?: string;
-    message: string;
-    code?: string;
-}
-interface PersistedTokenUsage {
-    input?: number;
-    output?: number;
-    total?: number;
-}
-interface PersistedTraceContext {
-    traceId?: string;
-    spanId?: string;
-    parentSpanId?: string;
+interface DurationStats {
+    minMs?: number;
+    maxMs?: number;
+    avgMs?: number;
+    p50Ms?: number;
+    p95Ms?: number;
 }
-interface PersistedInspectEvent {
-    schemaVersion: PersistedSchemaVersion;
-    eventId: string;
+interface TraceStatsRankedRun {
     runId: string;
-    parentId?: string;
-    kind: InspectKind;
-    name: string;
-    status?: PersistedEventStatus;
-    timestamp: string;
-    startedAt?: string;
-    endedAt?: string;
+    name?: string;
     durationMs?: number;
-    confidence: AttributionConfidence;
-    source: PersistedEventSource;
-    attributes?: Record<string, unknown>;
-    inputSummary?: unknown;
-    outputSummary?: unknown;
-    error?: PersistedInspectError;
-    tokenUsage?: PersistedTokenUsage;
-    trace?: PersistedTraceContext;
-}
-/**
- * Runtime guard for a v0.2 {@link PersistedInspectEvent} JSON object.
- *
- * Timestamp fields (`timestamp`, `startedAt`, `endedAt`) are validated as
- * non-empty strings only — stricter ISO-8601 parsing may be added later.
- */
-declare function isPersistedInspectEvent(value: unknown): value is PersistedInspectEvent;
-
-interface TraceEventToPersistedOptions {
-    /**
-     * Stable index within the source event list.
-     * Used only to make synthetic eventId deterministic when v0.1 has no eventId.
-     */
-    eventIndex?: number;
-    /**
-     * Optional source name override.
-     * Default: "trace-event"
-     */
-    sourceName?: string;
-    /**
-     * Optional source version override.
-     * Default: "0.1"
-     */
-    sourceVersion?: string;
+    status: string;
 }
-/**
- * Maps one v0.1 {@link TraceEvent} to a v0.2 {@link PersistedInspectEvent}.
- * Does not mutate `event`.
- */
-declare function traceEventToPersistedInspectEvent(event: TraceEvent, options?: TraceEventToPersistedOptions): PersistedInspectEvent;
-/**
- * Maps a v0.1 trace event list to persisted v0.2 events (one output per input).
- */
-declare function traceEventsToPersistedInspectEvents(events: readonly TraceEvent[], options?: Omit<TraceEventToPersistedOptions, "eventIndex">): PersistedInspectEvent[];
-
-interface InspectEventToPersistedOptions {
-    /**
-     * Optional source name override.
-     * If omitted, derived from event.source.type.
-     */
-    sourceName?: string;
-    /**
-     * Optional source version override.
-     */
-    sourceVersion?: string;
-    /**
-     * Stable index for deterministic fallback IDs if needed.
-     */
-    eventIndex?: number;
-}
-/**
- * Maps one in-memory {@link InspectEvent} to a v0.2 {@link PersistedInspectEvent}.
- * Does not mutate `event`.
- */
-declare function inspectEventToPersistedInspectEvent(event: InspectEvent, options?: InspectEventToPersistedOptions): PersistedInspectEvent;
-/**
- * Maps in-memory {@link InspectEvent} rows to persisted v0.2 events.
- */
-declare function inspectEventsToPersistedInspectEvents(events: readonly InspectEvent[], options?: Omit<InspectEventToPersistedOptions, "eventIndex">): PersistedInspectEvent[];
-
-interface PersistedToInspectEventOptions {
-    /**
-     * If true, invalid persisted events are skipped by batch conversion.
-     * If false or omitted, invalid events throw.
-     */
-    skipInvalid?: boolean;
-}
-/**
- * Maps one v0.2 {@link PersistedInspectEvent} to in-memory {@link InspectEvent}.
- * Throws if `event` fails {@link isPersistedInspectEvent}.
- */
-declare function persistedInspectEventToInspectEvent(event: PersistedInspectEvent): InspectEvent;
-/**
- * Maps persisted v0.2 events to in-memory {@link InspectEvent} rows.
- */
-declare function persistedInspectEventsToInspectEvents(events: readonly PersistedInspectEvent[], options?: PersistedToInspectEventOptions): InspectEvent[];
-
-interface PersistedTreeBridgeOptions {
-    /**
-     * If true, invalid persisted events are skipped.
-     * If false or omitted, invalid persisted events throw.
-     */
-    skipInvalid?: boolean;
-}
-/**
- * Builds {@link InspectRunTree} rows from v0.2 {@link PersistedInspectEvent} input.
- * Uses {@link TreeBuilder} as the canonical tree builder. Does not mutate `events`.
- */
-declare function persistedInspectEventsToRunTrees(events: readonly PersistedInspectEvent[], options?: PersistedTreeBridgeOptions): InspectRunTree[];
-/**
- * Builds {@link InspectRunTree} rows from legacy v0.1 {@link TraceEvent} input
- * via the persisted-event model. Does not mutate `events`.
- */
-declare function traceEventsToPersistedRunTrees(events: readonly TraceEvent[]): InspectRunTree[];
-
-type ParserWarningCode = "MALFORMED_JSON" | "MISSING_RUN_ID" | "MISSING_EVENT" | "MISSING_TIMESTAMP" | "UNSUPPORTED_LOG4JS_PAYLOAD" | "CONFIG_ERROR" | "UNKNOWN";
-interface ParserWarning {
-    code: ParserWarningCode;
-    message: string;
-    file?: string;
-    line?: number;
-    raw?: string;
-}
-interface ParseResult<T> {
-    records: T[];
-    warnings: ParserWarning[];
-}
-
-declare const DEFAULT_LOG_INGEST_CONFIG: LogIngestConfig;
-declare function mergeLogIngestConfig(base: LogIngestConfig, override: Partial<LogIngestConfig>): LogIngestConfig;
-declare function loadLogIngestConfig(configPath?: string): Promise<LogIngestConfig>;
-
-interface RawLogRecord {
-    raw: Record<string, unknown>;
-    file?: string;
-    line: number;
-    sourceType: "json-log" | "log4js";
-}
-
-declare class JsonLogParser {
-    parseLines(lines: string[], filePath?: string): ParseResult<RawLogRecord>;
-    parseFile(filePath: string): Promise<ParseResult<RawLogRecord>>;
-}
-
-declare class Log4jsParser {
-    parseLines(lines: string[], filePath?: string): ParseResult<RawLogRecord>;
-    parseFile(filePath: string): Promise<ParseResult<RawLogRecord>>;
-}
-
-declare function wildcardMatch(pattern: string, value: string): boolean;
-declare function matchMapping(eventName: string, mappings?: Record<string, LogEventMapping>): LogEventMapping | undefined;
-
-declare const DEFAULT_REDACT_KEYS: readonly ["authorization", "cookie", "token", "apiKey", "password", "secret", "email"];
-interface RedactorOptions {
-    rules?: RedactionRule[];
-    /** Additional exact keys (case-insensitive) to redact in addition to defaults. */
-    extraKeys?: readonly string[];
-}
-declare class Redactor {
-    #private;
-    constructor(options?: RedactorOptions);
-    redactValue(key: string, value: unknown): unknown;
-    redactRecord(record: Record<string, unknown>): Record<string, unknown>;
-}
-
-interface NormalizeOptions {
-    config: LogIngestConfig;
-    sourceFile?: string;
-}
-declare class EventNormalizer {
-    #private;
-    constructor(options: NormalizeOptions);
-    normalize(record: RawLogRecord): InspectEvent | ParserWarning;
-    normalizeAll(records: RawLogRecord[]): ParseResult<InspectEvent>;
-}
-
-interface TreeBuilderOptions {
-    config?: LogIngestConfig;
-}
-declare class TreeBuilder {
-    constructor(options?: TreeBuilderOptions);
-    build(events: InspectEvent[]): InspectRunTree[];
-}
-
-interface RenderTreeOptions {
-    verbose?: boolean;
-    showConfidence?: "always" | "non-explicit" | "never";
-    showMetadata?: boolean;
-    color?: boolean;
-    maxAttributeLength?: number;
-    summary?: boolean;
-}
-declare function renderRunTree(tree: InspectRunTree, options?: RenderTreeOptions): string;
-declare function renderRunTrees(trees: InspectRunTree[], options?: RenderTreeOptions): string;
-
-type LogSourceFormat = "json" | "log4js" | "auto";
-interface ParseLogLineOptions {
-    format?: LogSourceFormat;
-    file?: string;
-    line?: number;
-}
-declare function parseLogLine(line: string, options?: ParseLogLineOptions): ParseResult<RawLogRecord>;
-
-interface LiveLogUpdate {
-    events: InspectEvent[];
-    trees: InspectRunTree[];
-    warnings: ParserWarning[];
-}
-interface LiveLogAccumulatorOptions {
-    config: LogIngestConfig;
-    format?: LogSourceFormat;
-    file?: string;
-}
-declare class LiveLogAccumulator {
-    #private;
-    constructor(options: LiveLogAccumulatorOptions);
-    pushLine(line: string, lineNumber?: number): LiveLogUpdate;
-    getEvents(): InspectEvent[];
-    getTrees(): InspectRunTree[];
-    getWarnings(): ParserWarning[];
-    reset(): void;
-}
-
-interface ParseLogsOptions {
-    format?: "json" | "log4js" | "auto";
-    config?: LogIngestConfig;
-    configPath?: string;
-    runIdKeys?: string[];
-    eventKey?: string;
-    timestampKey?: string;
-    messageKey?: string;
-    levelKey?: string;
-    parentIdKey?: string;
-    durationKey?: string;
-    statusKey?: string;
-    warnings?: "none" | "summary" | "all";
-}
-interface LogToTreeResult {
-    events: InspectEvent[];
-    trees: InspectRunTree[];
-    warnings: ParserWarning[];
-}
-/**
- * @experimental Compatibility-oriented API for parsing structured logs into normalized run trees.
- * Subject to refinement before a future stability declaration.
- */
-declare function parseLogsToTrees(filePath: string, options?: ParseLogsOptions): Promise<LogToTreeResult>;
-
-/** Default folder under the user home for AgentInspect data. */
-declare const DEFAULT_TRACE_DIR_NAME = ".agent-inspect";
-/** Subfolder where JSONL run traces are stored. */
-declare const RUNS_DIR_NAME = "runs";
-/** Writable trace root when the default home path cannot be used. */
-declare const FALLBACK_TRACE_DIR: string;
-/** Maximum display length for run/step names before truncation. */
-declare const MAX_NAME_LENGTH = 100;
-/** Returns `run_` + a 10-character nanoid segment. */
-declare function createRunId(): string;
-/** Returns `step_` + a 10-character nanoid segment. */
-declare function createStepId(): string;
-/** Formats a duration for CLI display (v0.2 rules). */
-declare function formatDuration(ms: number): string;
-/**
- * Formats a Unix timestamp (ms) as local `YYYY-MM-DD HH:mm:ss`.
- * Invalid values yield `"Invalid date"` (no throw).
- */
-declare function formatTimestamp(timestamp: number): string;
-/**
- * Default directory for trace files: `~/DEFAULT_TRACE_DIR_NAME/RUNS_DIR_NAME`.
- * Falls back to {@link FALLBACK_TRACE_DIR} when home cannot be resolved.
- */
-declare function getDefaultTraceDir(): string;
-/**
- * Full path to the JSONL trace file for a run.
- * `runId` is passed through `path.basename` to avoid traversal; empty ids become `run_unknown`.
- */
-declare function getTraceFilePath(runId: string, traceDir?: string): string;
-/**
- * Ensures a trace directory exists (recursive). Tries {@link FALLBACK_TRACE_DIR} on failure.
- * Returns the directory path that callers should prefer: primary, fallback, or original if both mkdir attempts fail.
- * Emits concise `[AgentInspect]` warnings on failure; never throws.
- */
-declare function ensureTraceDir(traceDir: string): Promise<string>;
-/**
- * Normalizes any thrown/caught value into {@link ErrorInfo}.
- * Never throws (circular structures and non-JSON values fall back to a generic message).
- */
-declare function formatError(error: unknown): ErrorInfo;
-/**
- * Truncates a display name to `maxLength`, appending `"..."` when shortened.
- * Empty or non-string input becomes `"unnamed"`.
- */
-declare function truncateName(name: string, maxLength?: number): string;
-/**
- * Instrumentation-only warning to stderr. Not a general-purpose logger.
- * Optional `error` is summarized via {@link formatError} (message only).
- */
-declare function warn(message: string, error?: unknown): void;
-
-interface ResolvedRedactionProfile {
-    profile: RedactionProfile;
-    extraKeys: readonly string[];
-    maxMetadataValueLengthCap?: number;
-    maxPreviewLengthCap?: number;
-}
-/** Resolves named profile behavior (keys + metadata string caps). */
-declare function resolveRedactionProfile(profile?: RedactionProfile): ResolvedRedactionProfile;
-
-/** Default max length for string metadata values (non-preview keys). */
-declare const DEFAULT_MAX_METADATA_VALUE_LENGTH = 2000;
-/** Default max length for preview-like metadata keys (contains `preview`, case-insensitive). */
-declare const DEFAULT_MAX_PREVIEW_LENGTH = 500;
-/** Default max serialized JSONL line size in bytes (UTF-8). */
-declare const DEFAULT_MAX_EVENT_BYTES = 65536;
-/** Resolved trace safety settings used at write time. */
-interface TraceSafetyOptions {
-    redactEnabled: boolean;
-    redactionRules?: RedactionRule[];
-    redactionProfile: RedactionProfile;
-    profileExtraKeys: readonly string[];
-    maxMetadataValueLength: number;
-    maxPreviewLength: number;
-    maxEventBytes: number;
-}
-
-/** Resolves {@link InspectRunOptions} trace safety fields with safe defaults. */
-declare function resolveTraceSafetyOptions(options?: Pick<InspectRunOptions, "redact" | "redactionProfile" | "maxEventBytes" | "maxMetadataValueLength" | "maxPreviewLength">): TraceSafetyOptions;
-/** Redacts (when enabled) and truncates metadata values for disk persistence. */
-declare function prepareMetadataForDisk(metadata: Record<string, unknown> | StepMetadata, opts: TraceSafetyOptions): Record<string, unknown>;
-/**
- * Applies redaction, metadata truncation, and final serialized size bounds.
- * Never throws; returns a schema-valid event or a minimally truncated variant.
- */
-declare function prepareTraceEventForDisk(event: TraceEvent, opts: TraceSafetyOptions): TraceEvent;
-
-/** Returns the active run context, without internal step fields. */
-declare function getCurrentContext(): ExecutionContext | undefined;
-/** Active `runId` when inside `runWithContext`, else `undefined`. */
-declare function getCurrentRunId(): string | undefined;
-/**
- * Correlation metadata for the active run (`correlationId`, `requestId`, `decisionId`, `groupId`).
- * `undefined` outside `inspectRun` / `maybeInspectRun` or when no correlation fields were set.
- */
-declare function getCurrentCorrelationMetadata(): TraceCorrelationMetadata | undefined;
-/** Active `runName` when inside `runWithContext`, else `undefined`. */
-declare function getCurrentRunName(): string | undefined;
-/**
- * Active step id in this async scope (parent for nested `step()` calls).
- * `undefined` at run root or outside any run.
- */
-declare function getCurrentStepId(): string | undefined;
-/** Alias of {@link getCurrentStepId} for readability in step instrumentation. */
-declare function getParentStepId(): string | undefined;
-/**
- * Nesting depth: `0` at run root, increments by one per nested `runWithStepContext`.
- * Returns `0` outside any run.
- */
-declare function getCurrentDepth(): number;
-declare function hasActiveContext(): boolean;
-declare function getTraceDirFromContext(): string | undefined;
-declare function isSilentContext(): boolean;
-/** Resolved trace safety settings for the active run (redaction + size bounds). */
-declare function getTraceSafetyFromContext(): TraceSafetyOptions | undefined;
-/**
- * Runs `fn` with a fresh AgentInspect run context (depth 0, no active step).
- * Propagates sync/async results and rejections; does not swallow user errors.
- */
-declare function runWithContext<T>(context: ExecutionContext, fn: () => Promise<T> | T, traceSafety?: TraceSafetyOptions): Promise<T>;
-/**
- * Runs `fn` with `stepId` as the active step (incremented depth).
- * If no run is active, runs `fn` without altering async context.
- */
-declare function runWithStepContext<T>(stepId: string, fn: () => Promise<T> | T): Promise<T>;
-
-/**
- * Strict MVP validation before writing JSONL. Rejects empty ids, non-finite times, and malformed payloads.
- */
-declare function validateEvent(event: unknown): event is TraceEvent;
-/** Serializes a trace line as compact JSON without a trailing newline. */
-declare function serializeEvent(event: TraceEvent): string;
-/**
- * Creates (or truncates) an empty JSONL file for a run. Uses {@link ensureTraceDir} then {@link getTraceFilePath}.
- * On failure, retries once under {@link FALLBACK_TRACE_DIR}.
- */
-declare function initializeTraceFile(runId: string, traceDir: string): Promise<string | undefined>;
-declare function writeTraceEvent(event: TraceEvent, traceDir: string): Promise<void>;
-/**
- * Reads raw JSONL file contents for a run, or `undefined` if missing or unreadable.
- */
-declare function readTraceFile(runId: string, traceDir: string): Promise<string | undefined>;
-/** Parses JSONL into validated {@link TraceEvent} rows; invalid lines are skipped with a warning. */
-declare function readTraceEvents(runId: string, traceDir: string): Promise<TraceEvent[]>;
-/**
- * Lists `.jsonl` file names in `traceDir`, newest by mtime first (name sort as tie-breaker).
- */
-declare function listTraceFiles(traceDir: string): Promise<string[]>;
-/** Maps a `.jsonl` file name to its run id (basename only; no traversal). */
-declare function getRunIdFromTraceFileName(fileName: string): string | undefined;
-
-interface TraceDirectoryOptions {
-    dir?: string;
+interface TraceStatsRankedStep {
+    runId: string;
+    stepName: string;
+    stepType: string;
+    durationMs: number;
 }
-declare function resolveTraceDir(options?: TraceDirectoryOptions): string;
-declare class TraceDirectory {
-    #private;
-    constructor(options?: TraceDirectoryOptions);
-    getPath(filename?: string): string;
-    list(): Promise<string[]>;
-    getFileStats(filename: string): Promise<Stats>;
+interface TraceStats {
+    traceDir: string;
+    since?: string;
+    correlationId?: string;
+    groupId?: string;
+    totalRuns: number;
+    successCount: number;
+    errorCount: number;
+    runningCount: number;
+    unknownCount: number;
+    errorRate: number;
+    duration: DurationStats;
+    totalSteps: number;
+    avgStepsPerRun: number;
+    totalLlmSteps: number;
+    totalToolSteps: number;
+    totalErrorSteps: number;
+    slowestRuns: TraceStatsRankedRun[];
+    slowestSteps: TraceStatsRankedStep[];
+}
+interface TraceStatsOptions {
+    traceDir: string;
+    since?: string;
+    correlationId?: string;
+    groupId?: string;
+    slowRunLimit?: number;
+    slowStepLimit?: number;
 }
+declare function buildTraceStats(metas: TraceMetadata[], options: TraceStatsOptions): Promise<TraceStats>;
+declare function renderTraceStats(stats: TraceStats): string;
 
-declare function extractMetadata(filePath: string, _quickScan?: boolean): Promise<TraceMetadata>;
-declare function buildRunSummary(events: TraceEvent[]): RunSummary;
-
-interface TraceFilterOptions {
-    status?: TraceMetadataStatus;
-    name?: string;
+interface TraceSearchOptions {
+    traceDir: string;
     since?: string;
+    status?: "success" | "error" | "running" | "unknown";
+    kind?: string;
+    type?: string;
+    name?: string;
+    tool?: string;
+    duration?: string;
     limit?: number;
 }
-declare function filterTraces(traces: TraceMetadata[], options: TraceFilterOptions): TraceMetadata[];
+interface TraceSearchResult {
+    runId: string;
+    runName?: string;
+    runStatus: string;
+    stepId?: string;
+    stepName?: string;
+    stepType?: string;
+    timestamp?: number;
+    durationMs?: number;
+    matchReason: string;
+    matchedFields: string[];
+    filePath: string;
+}
+interface ParsedDurationFilter {
+    op: ">" | ">=" | "<" | "<=";
+    ms: number;
+}
+declare function parseDurationFilter(expr: string): ParsedDurationFilter;
+declare function searchTraces(metas: TraceMetadata[], options: TraceSearchOptions): Promise<TraceSearchResult[]>;
+declare function loadTraceMetadataList(_traceDir: string, fileNames: string[], getPath: (fileName: string) => string): Promise<TraceMetadata[]>;
 
 /**
  * Safety check for cleanup workflows: returns true only when the file appears to be an AgentInspect trace.
@@ -753,112 +277,6 @@ declare function isAgentInspectTrace(filePath: string): Promise<boolean>;
  */
 declare function parseDuration(duration: string): number;
 
-type DiffSeverity = "info" | "warning" | "error";
-type DiffKind = "run-status" | "structure" | "step-added" | "step-removed" | "step-status" | "step-type" | "duration" | "error" | "metadata" | "output" | "first-divergence";
-interface DiffPathSegment {
-    index: number;
-    name: string;
-    stepId?: string;
-}
-interface DiffPath {
-    path: DiffPathSegment[];
-}
-interface RunDiffItem {
-    kind: DiffKind;
-    severity: DiffSeverity;
-    message: string;
-    path?: DiffPath;
-    left?: unknown;
-    right?: unknown;
-}
-interface StepComparable {
-    id: string;
-    name: string;
-    type?: string;
-    status?: string;
-    durationMs?: number;
-    error?: string;
-    metadata?: Record<string, unknown>;
-    outputPreview?: unknown;
-    children: StepComparable[];
-}
-interface RunComparable {
-    runId: string;
-    name?: string;
-    status?: string;
-    durationMs?: number;
-    steps: StepComparable[];
-}
-interface RunDiffSummary {
-    leftRunId: string;
-    rightRunId: string;
-    totalDifferences: number;
-    errors: number;
-    warnings: number;
-    info: number;
-    firstDivergence?: RunDiffItem;
-}
-interface RunDiffResult {
-    summary: RunDiffSummary;
-    differences: RunDiffItem[];
-}
-interface DiffOptions {
-    ignoreDuration?: boolean;
-    durationThresholdMs?: number;
-    focus?: "all" | "errors" | "structure" | "outputs";
-    check?: "all" | "structure" | "outputs" | "errors" | "timing";
-}
-interface RenderDiffOptions {
-    json?: boolean;
-    verbose?: boolean;
-    color?: boolean;
-}
-
-/**
- * Normalize v0.1 manual JSONL events into a comparable run tree.
- * Does not mutate input events.
- */
-declare function manualTraceEventsToComparableRun(events: TraceEvent[]): RunComparable;
-
-declare function diffRuns(left: RunComparable, right: RunComparable, options?: DiffOptions): RunDiffResult;
-
-declare function renderRunDiff(result: RunDiffResult, options?: RenderDiffOptions): string;
-
-/**
- * @experimental Compare two v0.1 manual traces as normalized trees (read-only).
- * Subject to refinement before a future stability declaration.
- */
-declare function diffTraceEvents(leftEvents: TraceEvent[], rightEvents: TraceEvent[], options?: DiffOptions): RunDiffResult;
-
-/** Two spaces per nesting level in terminal output. */
-declare const TERMINAL_INDENT = "  ";
-/** Max display length for names in terminal output. */
-declare const MAX_TERMINAL_NAME_LENGTH = 80;
-/** Max nesting depth used for indentation (prevents huge indents). */
-declare const MAX_TERMINAL_DEPTH = 10;
-/** Indentation string for a nesting depth (capped, never negative). */
-declare function getIndent(depth: number): string;
-/** Truncates a display name for terminal use; invalid input becomes `"unnamed"`. */
-declare function formatTerminalName(name: string): string;
-/** Renders a single step line (colored); does not consult silent mode. */
-declare function renderStepLine(name: string, durationMs: number | undefined, status: StepStatus, depth?: number): string;
-/** Renders an error summary line (no stack in MVP). */
-declare function renderErrorLine(error: ErrorInfo, depth?: number): string;
-/** Plain-text run summary lines (no chalk) for stable testing and CLI reuse. */
-declare function renderRunSummary(durationMs: number, status: RunStatus, traceFilePath?: string): string[];
-/** Prints run header with icon and dim run id. */
-declare function printRunStart(runId: string, name: string): void;
-/** Prints a running step line. */
-declare function printStepStart(name: string, depth?: number): void;
-/** Prints a completed step line with duration and status icon. */
-declare function printStepComplete(name: string, durationMs: number, status: StepStatus, depth?: number): void;
-/** Prints a structured error line (message only, no stack). */
-declare function printError(error: ErrorInfo, depth?: number): void;
-/** Prints run completion summary and optional trace path. */
-declare function printRunComplete(_name: string, _runId: string, durationMs: number, status: RunStatus, traceFilePath?: string): void;
-/** Prints which step failed. */
-declare function printFailedAt(stepName: string): void;
-
 /**
  * Stable v1.0 API for local manual run tracing.
  *
@@ -908,113 +326,4 @@ declare const step: StepFunction;
  */
 declare function observe<T>(agent: T, options?: ObserveOptions): T;
 
-/**
- * v0.7 local export formats. No sinks — string output only.
- */
-
-type ExportFormat = "markdown" | "html" | "openinference" | "otlp-json";
-interface ExportOptions {
-    format: ExportFormat;
-    includeMetadata?: boolean;
-    includeAttributes?: boolean;
-    includeErrors?: boolean;
-    pretty?: boolean;
-    redacted?: boolean;
-    maxAttributeLength?: number;
-    /**
-     * Redaction preset for exported copies. Default `local`.
-     * `share` and `strict` apply stronger key-based redaction before rendering.
-     */
-    redactionProfile?: RedactionProfile;
-}
-interface ExportResult {
-    format: ExportFormat;
-    content: string;
-    contentType: string;
-    fileExtension: string;
-    warnings: string[];
-}
-interface ExportValidationResult {
-    ok: boolean;
-    format: ExportFormat;
-    errors: string[];
-    warnings: string[];
-}
-interface TraceExporter {
-    name: string;
-    format: ExportFormat;
-    export(tree: InspectRunTree, options?: Partial<ExportOptions>): ExportResult;
-    validate?(content: string): ExportValidationResult;
-}
-/** Library version string embedded in JSON exports (human-readable, not semver guarantee for formats). */
-declare const EXPORT_PAYLOAD_VERSION = "0.1.2";
-
-declare function safeString(value: unknown, maxLength?: number): string;
-/** Escape markdown table pipes and normalize line breaks for safe inline text. */
-declare function escapeMarkdown(value: string): string;
-declare function escapeHtml(value: string): string;
-declare function stableJson(value: unknown, pretty?: boolean): string;
-declare function compactAttributes(attrs: Record<string, unknown> | undefined, options?: {
-    maxLength?: number;
-    redacted?: boolean;
-}): Record<string, unknown>;
-declare function summarizeTree(tree: InspectRunTree): Record<string, unknown>;
-/** Depth-first pre-order flatten (matches typical tree display). */
-declare function flattenTree(tree: InspectRunTree): InspectNode[];
-
-/**
- * Build an {@link InspectRunTree} from v0.1 JSONL {@link TraceEvent} rows (manual tracing).
- * Does not mutate the input array or event objects.
- */
-declare function manualTraceEventsToRunTree(events: TraceEvent[]): InspectRunTree;
-
-declare function exportMarkdown(tree: InspectRunTree, options?: Partial<ExportOptions>): ExportResult;
-
-declare function exportHtml(tree: InspectRunTree, options?: Partial<ExportOptions>): ExportResult;
-
-interface OpenInferenceSpan {
-    trace_id: string;
-    span_id: string;
-    parent_span_id?: string;
-    name: string;
-    start_time_unix_nano: number;
-    end_time_unix_nano?: number;
-    attributes: Record<string, unknown>;
-    status?: {
-        code: "OK" | "ERROR" | "UNSET";
-        message?: string;
-    };
-}
-interface OpenInferenceExport {
-    exporter: "agent-inspect";
-    format: "openinference";
-    compatibility: "openinference-compatible";
-    version: string;
-    trace_id: string;
-    spans: OpenInferenceSpan[];
-    warnings: string[];
-}
-declare function exportOpenInference(tree: InspectRunTree, options?: Partial<ExportOptions>): ExportResult;
-
-declare function exportOtlpJson(tree: InspectRunTree, options?: Partial<ExportOptions>): ExportResult;
-
-declare function validateExportContent(format: ExportFormat, content: string): ExportValidationResult;
-
-interface RedactRunTreeForExportOptions {
-    redactionProfile?: RedactionProfile;
-}
-/**
- * Returns a deep copy of `tree` with profile-based redaction applied to event attributes.
- * Does not mutate the input tree.
- */
-declare function redactRunTreeForExport(tree: InspectRunTree, options?: RedactRunTreeForExportOptions): InspectRunTree;
-
-declare function mergeExportDefaults(options: ExportOptions): ExportOptions;
-/**
- * @experimental Compatibility-oriented export API. Exports are local-only and do not upload anywhere.
- * Subject to refinement before a future stability declaration.
- */
-declare function exportRunTree(tree: InspectRunTree, options: ExportOptions): ExportResult;
-declare function validateExport(result: ExportResult): ExportValidationResult;
-
-export { type ActiveStepContext, type AttributionConfidence, DEFAULT_LOG_INGEST_CONFIG, DEFAULT_MAX_EVENT_BYTES, DEFAULT_MAX_METADATA_VALUE_LENGTH, DEFAULT_MAX_PREVIEW_LENGTH, DEFAULT_REDACT_KEYS, DEFAULT_TRACE_DIR_NAME, type DiffKind, type DiffOptions, type DiffPath, type DiffPathSegment, type DiffSeverity, EXPORT_PAYLOAD_VERSION, type ErrorInfo, EventNormalizer, type EventSource, type ExecutionContext, type ExportFormat, type ExportOptions, type ExportResult, type ExportValidationResult, FALLBACK_TRACE_DIR, type InspectEvent, type InspectEventToPersistedOptions, type InspectKind, type InspectNode, type InspectRunOptions, type InspectRunTree, JsonLogParser, LiveLogAccumulator, type LiveLogAccumulatorOptions, type LiveLogUpdate, Log4jsParser, type LogEventMapping, type LogIngestConfig, type LogSourceFormat, type LogToTreeResult, MAX_NAME_LENGTH, MAX_TERMINAL_DEPTH, MAX_TERMINAL_NAME_LENGTH, type NormalizeOptions, type ObserveOptions, type OpenInferenceExport, type OpenInferenceSpan, type ParseLogLineOptions, type ParseLogsOptions, type ParseResult, type ParserWarning, type ParserWarningCode, type PersistedEventSource, type PersistedEventSourceType, type PersistedEventStatus, type PersistedInspectError, type PersistedInspectEvent, type PersistedSchemaVersion, type PersistedToInspectEventOptions, type PersistedTokenUsage, type PersistedTraceContext, type PersistedTreeBridgeOptions, RUNS_DIR_NAME, type RawLogRecord, type RedactionProfile, type RedactionRule, type RedactionStrategy, Redactor, type RedactorOptions, type RenderDiffOptions, type RenderTreeOptions, type ResolvedRedactionProfile, type Run, type RunComparable, type RunCompletedEvent, type RunDiffItem, type RunDiffResult, type RunDiffSummary, type RunStartedEvent, type RunStatus, type RunSummary, type Step, type StepComparable, type StepCompletedEvent, type StepMetadata, type StepOptions, type StepStartedEvent, type StepStatus, type StepType, TERMINAL_INDENT, type TokenMetadata, type TraceCorrelationMetadata, TraceDirectory, type TraceDirectoryOptions, type TraceEvent, type TraceEventBase, type TraceEventToPersistedOptions, type TraceExporter, type TraceFilterOptions, type TraceMetadata, type TraceMetadataStatus, type TraceSafetyOptions, type TraceSchemaVersion, TreeBuilder, type TreeBuilderOptions, buildRunSummary, compactAttributes, createRunId, createStepId, diffRuns, diffTraceEvents, ensureTraceDir, escapeHtml, escapeMarkdown, exportHtml, exportMarkdown, exportOpenInference, exportOtlpJson, exportRunTree, extractMetadata, filterTraces, flattenTree, formatDuration, formatError, formatTerminalName, formatTimestamp, getCurrentContext, getCurrentCorrelationMetadata, getCurrentDepth, getCurrentRunId, getCurrentRunName, getCurrentStepId, getDefaultTraceDir, getIndent, getParentStepId, getRunIdFromTraceFileName, getTraceDirFromContext, getTraceFilePath, getTraceSafetyFromContext, hasActiveContext, initializeTraceFile, inspectEventToPersistedInspectEvent, inspectEventsToPersistedInspectEvents, inspectRun, isAgentInspectEnabled, isAgentInspectTrace, isPersistedInspectEvent, isSilentContext, isStepStatus, isStepType, isTraceEvent, listTraceFiles, loadLogIngestConfig, manualTraceEventsToComparableRun, manualTraceEventsToRunTree, matchMapping, maybeInspectRun, mergeExportDefaults, mergeLogIngestConfig, observe, parseDuration, parseLogLine, parseLogsToTrees, persistedInspectEventToInspectEvent, persistedInspectEventsToInspectEvents, persistedInspectEventsToRunTrees, prepareMetadataForDisk, prepareTraceEventForDisk, printError, printFailedAt, printRunComplete, printRunStart, printStepComplete, printStepStart, readTraceEvents, readTraceFile, redactRunTreeForExport, renderErrorLine, renderRunDiff, renderRunSummary, renderRunTree, renderRunTrees, renderStepLine, resolveRedactionProfile, resolveTraceDir, resolveTraceSafetyOptions, runWithContext, runWithStepContext, safeString, serializeEvent, stableJson, step, summarizeTree, traceEventToPersistedInspectEvent, traceEventsToPersistedInspectEvents, traceEventsToPersistedRunTrees, truncateName, validateEvent, validateExport, validateExportContent, warn, wildcardMatch, writeTraceEvent };
+export { type DurationStats, InspectRunOptions, ObserveOptions, type ParseTraceJsonlOptions, type ParseTraceJsonlResult, type ParsedDurationFilter, PersistedInspectEvent, RedactionProfile, type RenderTimelineOptions, type RenderWhatOptions, type ReportFormat, type ReportOptions, type ReportResult, RunSummary, type RunTimeline, type RunWhatSummary, StepOptions, StepStatus, StepType, type TimelineEntry, type TimelineFocus, type TimelineOptions, TraceCorrelationMetadata, TraceDirectory, type TraceDirectoryOptions, TraceEvent, type TraceFilterOptions, type TraceJsonlFormat, TraceMetadata, TraceMetadataStatus, type TraceSearchOptions, type TraceSearchResult, type TraceStats, type TraceStatsOptions, type TraceStatsRankedRun, type TraceStatsRankedStep, buildRunReport, buildRunSummary, buildRunTimeline, buildRunWhatSummary, buildTraceStats, extractMetadata, filterTraces, getRunIdFromTraceFileName, initializeTraceFile, inspectRun, isAgentInspectEnabled, isAgentInspectTrace, listTraceFiles, loadTraceMetadataList, maybeInspectRun, observe, parseDuration, parseDurationFilter, parseTraceJsonl, readTraceEvents, readTraceFile, renderRunWhat, renderTimeline, renderTraceStats, resolveTraceDir, searchTraces, serializeEvent, step, unknownTraceFormatMessage, validateEvent, writeTraceEvent };