@lov3kaizen/agentsea-debugger 0.5.1

package/dist/index-1W27DYJt.d.ts

@@ -0,0 +1,366 @@
+import { B as BreakpointType, c as BreakpointCondition, b as Breakpoint, d as BreakpointContext, E as ExecutionStep, A as AgentState, I as InspectorResult, T as ToolCall, e as Decision, M as MemorySnapshot, D as DebugSessionState, C as Checkpoint, k as StepAction, j as DebugSession, m as Recording, a as DebuggerConfig, h as TokenUsage, S as StepType, t as RecordingStorageAdapter } from './recording.types-Ck7pbikw.js';
+import { EventEmitter } from 'eventemitter3';
+import { R as Recorder } from './Recorder-Dc9qR2V2.js';
+import { b as ReplaySession } from './replay.types-C9hJizI-.js';
+import { a as DecisionTree, f as FlowGraph } from './visualization.types-dWjGE037.js';
+import { f as FailureAnalysis, F as FailureAnalyzer, i as WhatIfScenario, k as ScenarioResult, W as WhatIfEngine } from './index-DRrKPSo9.js';
+import { R as ReplayEngine } from './ReplayEngine-Dyyqy5bw.js';
+
+interface BreakpointManagerEvents {
+    'breakpoint:added': (breakpoint: Breakpoint) => void;
+    'breakpoint:removed': (breakpointId: string) => void;
+    'breakpoint:hit': (breakpoint: Breakpoint, context: BreakpointContext) => void;
+    'breakpoint:toggled': (breakpoint: Breakpoint) => void;
+}
+interface BreakpointOptions {
+    type: BreakpointType;
+    condition?: BreakpointCondition;
+    step?: number;
+    toolName?: string;
+    description?: string;
+    enabled?: boolean;
+}
+declare class BreakpointManager extends EventEmitter<BreakpointManagerEvents> {
+    private breakpoints;
+    add(options: BreakpointOptions): Breakpoint;
+    remove(id: string): boolean;
+    get(id: string): Breakpoint | undefined;
+    getAll(): Breakpoint[];
+    getEnabled(): Breakpoint[];
+    toggle(id: string): boolean;
+    enable(id: string): boolean;
+    disable(id: string): boolean;
+    clear(): void;
+    check(step: ExecutionStep, state: AgentState): Breakpoint | null;
+    private shouldTrigger;
+    private buildContext;
+    get count(): number;
+    get enabledCount(): number;
+}
+declare function createBreakpointManager(): BreakpointManager;
+declare const BreakpointHelpers: {
+    atStep(step: number, description?: string): BreakpointOptions;
+    onToolCall(description?: string): BreakpointOptions;
+    onTool(toolName: string, description?: string): BreakpointOptions;
+    onError(description?: string): BreakpointOptions;
+    onDecision(condition?: BreakpointCondition): BreakpointOptions;
+    onLowConfidence(threshold?: number): BreakpointOptions;
+    onMemoryChange(description?: string): BreakpointOptions;
+    custom(condition: BreakpointCondition, description?: string): BreakpointOptions;
+};
+
+interface InspectorConfig {
+    maxDepth?: number;
+    maxStringLength?: number;
+    includeFullMemory?: boolean;
+}
+interface VariableWatch {
+    id: string;
+    path: string;
+    value: unknown;
+    previousValue?: unknown;
+    changed: boolean;
+}
+declare class Inspector {
+    private steps;
+    private currentStepIndex;
+    private state;
+    private watches;
+    private config;
+    constructor(steps: ExecutionStep[], state: AgentState, config?: InspectorConfig);
+    update(steps: ExecutionStep[], state: AgentState, stepIndex?: number): void;
+    getCurrentStepIndex(): number;
+    setCurrentStepIndex(index: number): void;
+    inspect(): InspectorResult;
+    getCurrentStep(): ExecutionStep | null;
+    getStep(index: number): ExecutionStep | undefined;
+    getSteps(): ExecutionStep[];
+    getStepsUpToCurrent(): ExecutionStep[];
+    getToolCalls(): ToolCall[];
+    getToolCallsByName(name: string): ToolCall[];
+    getDecisions(): Decision[];
+    getMemorySnapshot(): MemorySnapshot;
+    getVariables(): Record<string, unknown>;
+    getVariable(path: string): unknown;
+    getCallStack(): string[];
+    watch(path: string): VariableWatch;
+    unwatch(path: string): boolean;
+    getWatches(): VariableWatch[];
+    private updateWatches;
+    getChangedWatches(): VariableWatch[];
+    searchSteps(query: string, options?: {
+        caseSensitive?: boolean;
+        types?: string[];
+    }): ExecutionStep[];
+    getStepSummary(step: ExecutionStep): string;
+    private summarizeObject;
+    export(): Record<string, unknown>;
+}
+declare function createInspector(steps: ExecutionStep[], state: AgentState, config?: InspectorConfig): Inspector;
+
+interface SessionEvents {
+    'state:changed': (state: DebugSessionState) => void;
+    'step:executed': (step: ExecutionStep) => void;
+    'step:paused': (step: ExecutionStep, breakpoint?: Breakpoint) => void;
+    'breakpoint:hit': (breakpoint: Breakpoint, step: ExecutionStep) => void;
+    'checkpoint:created': (checkpoint: Checkpoint) => void;
+    error: (error: Error) => void;
+}
+interface SessionConfig {
+    agentId: string;
+    checkpointInterval?: number;
+    maxSteps?: number;
+}
+declare class DebugSessionManager extends EventEmitter<SessionEvents> {
+    private session;
+    private steps;
+    private state;
+    private breakpoints;
+    private checkpoints;
+    private config;
+    private pauseResolver?;
+    private stepAction;
+    constructor(config: SessionConfig);
+    get id(): string;
+    get sessionState(): DebugSessionState;
+    start(): void;
+    stop(): void;
+    pause(): void;
+    continue(): void;
+    stepOver(): void;
+    stepInto(): void;
+    stepOut(): void;
+    addStep(step: ExecutionStep, agentState: AgentState): boolean;
+    waitForContinue(): Promise<StepAction>;
+    setBreakpoint(options: BreakpointOptions): Breakpoint;
+    removeBreakpoint(id: string): boolean;
+    getBreakpoints(): Breakpoint[];
+    createCheckpoint(options: {
+        name: string;
+        description?: string;
+        automatic?: boolean;
+    }): Checkpoint;
+    getCheckpoint(id: string): Checkpoint | undefined;
+    getCheckpoints(): Checkpoint[];
+    restoreCheckpoint(id: string): boolean;
+    inspect(): Inspector;
+    getState(): AgentState;
+    getSteps(): ExecutionStep[];
+    getSession(): DebugSession;
+    complete(): void;
+    error(err: Error): void;
+    toRecording(): Recording;
+    private createInitialState;
+}
+declare function createDebugSession(config: SessionConfig): DebugSessionManager;
+
+interface DebuggerEvents {
+    'session:started': (sessionId: string) => void;
+    'session:ended': (sessionId: string, recording: Recording) => void;
+    step: (step: ExecutionStep) => void;
+    'breakpoint:hit': (breakpoint: Breakpoint, step: ExecutionStep) => void;
+    paused: (reason: string) => void;
+    resumed: () => void;
+    error: (error: Error) => void;
+}
+interface DebuggableAgent {
+    id: string;
+    name: string;
+    model: string;
+    getState?: () => AgentState;
+    onStep?: (callback: (step: ExecutionStep) => void) => void;
+}
+interface StepBuilder {
+    input(data: unknown): ExecutionStep;
+    prompt(content: string): ExecutionStep;
+    response(content: string, usage?: TokenUsage): ExecutionStep;
+    toolCall(tool: ToolCall): ExecutionStep;
+    toolResult(tool: ToolCall, success: boolean): ExecutionStep;
+    decision(decision: Decision): ExecutionStep;
+    error(error: Error): ExecutionStep;
+    custom(type: StepType, data: unknown): ExecutionStep;
+}
+declare class Debugger extends EventEmitter<DebuggerEvents> {
+    private config;
+    private sessions;
+    private currentSession?;
+    private attachedAgent?;
+    private stepIndex;
+    private globalBreakpoints;
+    constructor(config?: Partial<DebuggerConfig>);
+    attach(agent: DebuggableAgent): void;
+    detach(): void;
+    startSession(options?: Partial<SessionConfig>): DebugSessionManager;
+    endSession(): Recording | undefined;
+    getSession(): DebugSessionManager | undefined;
+    getSessionById(id: string): DebugSessionManager | undefined;
+    setBreakpoint(options: BreakpointOptions): Breakpoint | undefined;
+    clearBreakpoints(): void;
+    continue(): void;
+    stepOver(): void;
+    stepInto(): void;
+    stepOut(): void;
+    pause(): void;
+    stop(): void;
+    createCheckpoint(options: {
+        name: string;
+        description?: string;
+    }): Checkpoint | undefined;
+    listCheckpoints(): Checkpoint[];
+    restoreCheckpoint(id: string): boolean;
+    inspect(): Inspector | undefined;
+    recordStep(step: Partial<ExecutionStep>, state?: AgentState): boolean;
+    steps(): StepBuilder;
+    private createStep;
+    private createDefaultState;
+    getConfig(): Readonly<DebuggerConfig>;
+    static get Breakpoints(): typeof BreakpointHelpers;
+}
+declare function createDebugger(config?: Partial<DebuggerConfig>): Debugger;
+
+interface DebugMiddlewareOptions {
+    enabled?: boolean;
+    recordEnabled?: boolean;
+    debugger?: Debugger;
+    recorder?: Recorder;
+    autoStart?: boolean;
+    includePrompts?: boolean;
+    includeResponses?: boolean;
+}
+interface AgentMessage {
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: string;
+    toolCalls?: Array<{
+        id: string;
+        name: string;
+        arguments: Record<string, unknown>;
+    }>;
+    toolCallId?: string;
+}
+interface ExecutionContext {
+    agentId: string;
+    agentName: string;
+    model: string;
+    messages: AgentMessage[];
+    tools: string[];
+    memory?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+}
+declare class DebugMiddleware {
+    private options;
+    private debugger;
+    private recorder;
+    private stepIndex;
+    private currentTiming?;
+    private isSessionActive;
+    constructor(options?: DebugMiddlewareOptions);
+    startSession(context: ExecutionContext): void;
+    endSession(): void;
+    onInput(input: unknown, context?: ExecutionContext): void;
+    onPrompt(prompt: string | AgentMessage[], context?: ExecutionContext): void;
+    onResponse(response: string, usage?: TokenUsage, context?: ExecutionContext): void;
+    onToolCall(tool: {
+        id?: string;
+        name: string;
+        arguments: Record<string, unknown>;
+    }, context?: ExecutionContext): void;
+    onToolResult(tool: {
+        id: string;
+        name: string;
+        result: unknown;
+        success: boolean;
+    }, context?: ExecutionContext): void;
+    onDecision(decision: Decision, context?: ExecutionContext): void;
+    onError(error: Error, context?: ExecutionContext): void;
+    onMemoryWrite(data: Record<string, unknown>, context?: ExecutionContext): void;
+    onMemoryRead(query: string | Record<string, unknown>, result: unknown, context?: ExecutionContext): void;
+    createCheckpoint(name: string, description?: string): void;
+    getDebugger(): Debugger;
+    getRecorder(): Recorder;
+    isActive(): boolean;
+    createHandler(): {
+        beforeExecute: (context: ExecutionContext) => Promise<void>;
+        afterExecute: (context: ExecutionContext) => Promise<void>;
+        onStep: (type: StepType, data: Record<string, unknown>, context: ExecutionContext) => void;
+        onError: (error: Error, context: ExecutionContext) => void;
+    };
+    private createStep;
+    private recordStep;
+    private startTiming;
+    private finishCurrentStep;
+    private contextToState;
+    private createDefaultState;
+}
+declare function createDebugMiddleware(options?: DebugMiddlewareOptions): DebugMiddleware;
+
+interface AgentDebuggerEvents extends DebuggerEvents {
+    'recording:saved': (recording: Recording) => void;
+    'replay:started': (session: ReplaySession) => void;
+    'replay:completed': (session: ReplaySession) => void;
+    'analysis:completed': (analysis: FailureAnalysis) => void;
+}
+interface AgentDebuggerOptions {
+    storage?: RecordingStorageAdapter;
+    autoSave?: boolean;
+    recordingEnabled?: boolean;
+    breakpointsEnabled?: boolean;
+}
+declare class AgentDebugger extends EventEmitter<AgentDebuggerEvents> {
+    private debugger;
+    private recorder;
+    private replayEngine;
+    private failureAnalyzer;
+    private whatIfEngine;
+    private middleware;
+    private storage;
+    private options;
+    private recordings;
+    private currentRecording?;
+    constructor(options?: AgentDebuggerOptions);
+    private setupEventForwarding;
+    private handleRecordingComplete;
+    attach(agent: DebuggableAgent): void;
+    detach(): void;
+    getMiddleware(): DebugMiddleware;
+    startSession(context: ExecutionContext): void;
+    endSession(): Recording | undefined;
+    breakOnTool(toolName?: string): Breakpoint | undefined;
+    breakOnError(): Breakpoint | undefined;
+    breakOnDecision(): Breakpoint | undefined;
+    breakAtStep(step: number): Breakpoint | undefined;
+    setBreakpoint(options: Parameters<Debugger['setBreakpoint']>[0]): Breakpoint | undefined;
+    clearBreakpoints(): void;
+    continue(): void;
+    stepOver(): void;
+    stepInto(): void;
+    stepOut(): void;
+    pause(): void;
+    stop(): void;
+    createCheckpoint(name: string, description?: string): Checkpoint | undefined;
+    listCheckpoints(): Checkpoint[];
+    restoreCheckpoint(id: string): boolean;
+    getRecording(): Recording | undefined;
+    loadRecording(id: string): Promise<Recording | undefined>;
+    listRecordings(): Promise<Array<{
+        id: string;
+        agentId: string;
+        agentName: string;
+        status: string;
+        startedAt: number;
+    }>>;
+    replay(recording: Recording, options?: Parameters<ReplayEngine['start']>[1]): ReplaySession;
+    getReplayEngine(): ReplayEngine;
+    analyzeFailure(recording: Recording): FailureAnalysis;
+    getFailureAnalyzer(): FailureAnalyzer;
+    createWhatIfScenario(recording: Recording, modifications: WhatIfScenario['modifications'], name?: string): WhatIfScenario;
+    runWhatIfScenario(scenarioId: string, recording: Recording): Promise<ScenarioResult>;
+    getWhatIfEngine(): WhatIfEngine;
+    buildDecisionTree(recording: Recording): DecisionTree;
+    buildFlowGraph(recording: Recording): FlowGraph;
+    inspect(): Inspector | undefined;
+    getDebugger(): Debugger;
+    getStorage(): RecordingStorageAdapter;
+}
+declare function createAgentDebugger(options?: AgentDebuggerOptions): AgentDebugger;
+
+export { type AgentMessage as A, BreakpointManager as B, Debugger as D, type ExecutionContext as E, Inspector as I, type StepBuilder as S, type VariableWatch as V, type DebuggerEvents as a, type DebuggableAgent as b, createDebugger as c, DebugSessionManager as d, createDebugSession as e, type SessionEvents as f, type SessionConfig as g, createBreakpointManager as h, BreakpointHelpers as i, type BreakpointManagerEvents as j, type BreakpointOptions as k, createInspector as l, type InspectorConfig as m, DebugMiddleware as n, createDebugMiddleware as o, type DebugMiddlewareOptions as p, AgentDebugger as q, createAgentDebugger as r, type AgentDebuggerEvents as s, type AgentDebuggerOptions as t };

package/dist/index-DRrKPSo9.d.ts

@@ -0,0 +1,233 @@
+import { EventEmitter } from 'eventemitter3';
+import { A as AgentState, E as ExecutionStep, m as Recording, S as StepType } from './recording.types-Ck7pbikw.js';
+import { d as ReplayModification, g as ReplayDifference } from './replay.types-C9hJizI-.js';
+
+interface FailureAnalysis {
+    id: string;
+    recordingId: string;
+    analyzedAt: number;
+    rootCause: string;
+    contributingFactors: ContributingFactor[];
+    recommendations: Recommendation[];
+    errorStepIndex?: number;
+    errorMessage?: string;
+    stackTrace?: string;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    confidence: number;
+}
+interface ContributingFactor {
+    id: string;
+    type: string;
+    description: string;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    stepIndices: number[];
+    evidence?: Record<string, unknown>;
+}
+interface Recommendation {
+    id: string;
+    priority: number;
+    title: string;
+    description: string;
+    relatedFactors: string[];
+}
+interface WhatIfScenario {
+    id: string;
+    name: string;
+    description?: string;
+    baseRecordingId: string;
+    modifications: ReplayModification[];
+    status: ScenarioStatus;
+    createdAt: number;
+}
+type ScenarioStatus = 'pending' | 'running' | 'completed' | 'failed';
+interface ScenarioResult {
+    scenarioId: string;
+    success: boolean;
+    originalRecordingId: string;
+    modifiedSteps: number;
+    differences: ReplayDifference[];
+    divergencePoint?: number;
+    finalState: AgentState;
+    executedAt: number;
+    durationMs: number;
+}
+interface ScenarioComparison {
+    scenarioId: string;
+    scenarioName: string;
+    originalRecordingId: string;
+    outcomeChanged: boolean;
+    divergencePoint?: number;
+    divergencePercentage: number;
+    differences: ReplayDifference[];
+    summary: string;
+}
+interface PerformanceProfile {
+    recordingId: string;
+    totalDurationMs: number;
+    llmTimeMs: number;
+    toolTimeMs: number;
+    overheadMs: number;
+    tokens: {
+        total: number;
+        perSecond: number;
+        costUSD: number;
+    };
+    bottlenecks: Bottleneck[];
+    stepPerformance: StepPerformance[];
+}
+interface Bottleneck {
+    stepIndex: number;
+    type: 'slow-tool' | 'slow-llm' | 'large-context' | 'retry';
+    description: string;
+    durationMs: number;
+    percentage: number;
+    suggestion?: string;
+}
+interface StepPerformance {
+    stepIndex: number;
+    type: string;
+    durationMs: number;
+    tokensUsed: number;
+    isBottleneck: boolean;
+}
+type FactorCategory = 'tool-failure' | 'context-issue' | 'decision-error' | 'resource-limit' | 'external-dependency' | 'configuration' | 'unknown';
+interface SimilarFailure {
+    recordingId: string;
+    similarity: number;
+    matchingFactors: string[];
+    timestamp: number;
+}
+interface ComparisonMetric {
+    name: string;
+    original: number;
+    modified: number;
+    delta: number;
+    deltaPercent: number;
+    improved: boolean;
+}
+type InputVariationType = 'text-change' | 'context-addition' | 'context-removal' | 'tool-result-change' | 'state-modification';
+interface InputVariation {
+    id: string;
+    type: InputVariationType;
+    stepIndex: number;
+    original: unknown;
+    modified: unknown;
+    description?: string;
+}
+interface PathAnalysis {
+    recordingId: string;
+    totalPaths: number;
+    criticalPoints: number[];
+    alternatives: AlternativePathAnalysis[];
+    optimalPath?: string;
+}
+interface AlternativePathAnalysis {
+    id: string;
+    decisionPoint: number;
+    alternativeOption: string;
+    predictedOutcome: string;
+    confidence: number;
+    costDelta?: number;
+}
+
+interface WhatIfEngineEvents {
+    'scenario:created': (scenario: WhatIfScenario) => void;
+    'scenario:started': (scenarioId: string) => void;
+    'scenario:completed': (result: ScenarioResult) => void;
+    'scenario:failed': (scenarioId: string, error: Error) => void;
+    'comparison:completed': (comparison: ScenarioComparison) => void;
+    error: (error: Error) => void;
+}
+interface ScenarioOptions {
+    name: string;
+    description?: string;
+    recordingId: string;
+    modifications: ReplayModification[];
+    executeTools?: boolean;
+    executeLLM?: boolean;
+    onToolCall?: (step: ExecutionStep) => Promise<unknown>;
+    onLLMCall?: (step: ExecutionStep) => Promise<string>;
+}
+interface BatchScenarioOptions {
+    recordingId: string;
+    variations: Array<{
+        name: string;
+        modifications: ReplayModification[];
+    }>;
+    parallel?: boolean;
+}
+declare class WhatIfEngine extends EventEmitter<WhatIfEngineEvents> {
+    private scenarios;
+    private results;
+    private replayEngine;
+    private stateRestorer;
+    constructor();
+    createScenario(options: ScenarioOptions): WhatIfScenario;
+    runScenario(scenarioId: string, recording: Recording, options?: {
+        executeTools?: boolean;
+        executeLLM?: boolean;
+        onToolCall?: (step: ExecutionStep) => Promise<unknown>;
+        onLLMCall?: (step: ExecutionStep) => Promise<string>;
+    }): Promise<ScenarioResult>;
+    private waitForReplayCompletion;
+    runBatch(options: BatchScenarioOptions, recording: Recording): Promise<ScenarioResult[]>;
+    compare(original: Recording, result: ScenarioResult): ScenarioComparison;
+    private generateComparisonSummary;
+    createFromDecision(recording: Recording, stepIndex: number, alternativeChoice: string): WhatIfScenario;
+    createFromToolResult(recording: Recording, stepIndex: number, alternativeResult: unknown): WhatIfScenario;
+    createFromSkip(recording: Recording, stepIndices: number[], name?: string): WhatIfScenario;
+    getScenario(id: string): WhatIfScenario | undefined;
+    getScenarios(): WhatIfScenario[];
+    getScenariosForRecording(recordingId: string): WhatIfScenario[];
+    getResult(scenarioId: string): ScenarioResult | undefined;
+    getResults(): ScenarioResult[];
+    deleteScenario(id: string): boolean;
+    clear(): void;
+}
+declare function createWhatIfEngine(): WhatIfEngine;
+
+interface AnalysisOptions {
+    includeDetailedSteps?: boolean;
+    includeMemoryAnalysis?: boolean;
+    includeTimingAnalysis?: boolean;
+    customPatterns?: FailurePattern[];
+}
+interface FailurePattern {
+    id: string;
+    name: string;
+    description: string;
+    matcher: (recording: Recording, steps: ExecutionStep[]) => boolean;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    recommendations: string[];
+}
+interface StepAnalysis {
+    stepIndex: number;
+    type: StepType;
+    suspicious: boolean;
+    reasons: string[];
+    relatedSteps: number[];
+}
+declare class FailureAnalyzer {
+    private patterns;
+    private options;
+    constructor(options?: AnalysisOptions);
+    analyze(recording: Recording): FailureAnalysis;
+    private findContributingFactors;
+    private findPatternSteps;
+    private gatherEvidence;
+    private determineRootCause;
+    private generateRecommendations;
+    private getPriorityFromSeverity;
+    private findErrorStep;
+    private getErrorMessage;
+    private getStackTrace;
+    private calculateOverallSeverity;
+    private calculateConfidence;
+    analyzeSteps(steps: ExecutionStep[]): StepAnalysis[];
+    addPattern(pattern: FailurePattern): void;
+    removePattern(patternId: string): boolean;
+    getPatterns(): FailurePattern[];
+}
+declare function createFailureAnalyzer(options?: AnalysisOptions): FailureAnalyzer;
+
+export { type AnalysisOptions as A, type BatchScenarioOptions as B, type ContributingFactor as C, FailureAnalyzer as F, type InputVariation as I, type PerformanceProfile as P, type Recommendation as R, type ScenarioOptions as S, WhatIfEngine as W, type WhatIfEngineEvents as a, createFailureAnalyzer as b, createWhatIfEngine as c, type FailurePattern as d, type StepAnalysis as e, type FailureAnalysis as f, type FactorCategory as g, type SimilarFailure as h, type WhatIfScenario as i, type ScenarioStatus as j, type ScenarioResult as k, type ScenarioComparison as l, type ComparisonMetric as m, type InputVariationType as n, type Bottleneck as o, type StepPerformance as p, type PathAnalysis as q, type AlternativePathAnalysis as r };

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+export { A as AgentState, b as Breakpoint, c as BreakpointCondition, d as BreakpointContext, B as BreakpointType, C as Checkpoint, j as DebugSession, D as DebugSessionState, a as DebuggerConfig, e as Decision, f as DecisionOption, i as ErrorInfo, E as ExecutionStep, I as InspectorResult, M as MemorySnapshot, g as Message, s as RecorderConfig, m as Recording, R as RecordingConfig, u as RecordingListOptions, v as RecordingListResult, o as RecordingMetadata, n as RecordingOutcome, l as RecordingStatus, t as RecordingStorageAdapter, w as RecordingSummary, p as Snapshot, k as StepAction, S as StepType, x as StorageStats, q as TimelineEvent, r as TimelineEventType, h as TokenUsage, T as ToolCall } from './recording.types-Ck7pbikw.js';
+export { h as ReplayComparison, c as ReplayConfig, g as ReplayDifference, d as ReplayModification, e as ReplayModificationType, f as ReplayResult, b as ReplaySession, a as ReplaySpeed, R as ReplayState, S as StateRestoreOptions, i as StateRestoreResult } from './replay.types-C9hJizI-.js';
+export { A as AlternativePath, a as DecisionTree, D as DecisionTreeNode, E as ExportFormat, e as FlowEdgeStyle, f as FlowGraph, d as FlowGraphEdge, F as FlowGraphNode, c as FlowNodeStyle, b as FlowNodeType, M as MermaidOptions, g as StateTimeline, S as StateTimelineEntry, h as ToolCallTree, T as ToolCallTreeNode } from './visualization.types-dWjGE037.js';
+export { r as AlternativePathAnalysis, A as AnalysisOptions, B as BatchScenarioOptions, o as Bottleneck, m as ComparisonMetric, C as ContributingFactor, g as FactorCategory, f as FailureAnalysis, F as FailureAnalyzer, d as FailurePattern, I as InputVariation, n as InputVariationType, q as PathAnalysis, P as PerformanceProfile, R as Recommendation, l as ScenarioComparison, S as ScenarioOptions, k as ScenarioResult, j as ScenarioStatus, h as SimilarFailure, e as StepAnalysis, p as StepPerformance, W as WhatIfEngine, a as WhatIfEngineEvents, i as WhatIfScenario, b as createFailureAnalyzer, c as createWhatIfEngine } from './index-DRrKPSo9.js';
+export { q as AgentDebugger, s as AgentDebuggerEvents, t as AgentDebuggerOptions, A as AgentMessage, i as BreakpointHelpers, B as BreakpointManager, j as BreakpointManagerEvents, k as BreakpointOptions, n as DebugMiddleware, p as DebugMiddlewareOptions, d as DebugSessionManager, b as DebuggableAgent, D as Debugger, a as DebuggerEvents, E as ExecutionContext, I as Inspector, m as InspectorConfig, g as SessionConfig, f as SessionEvents, S as StepBuilder, V as VariableWatch, r as createAgentDebugger, h as createBreakpointManager, o as createDebugMiddleware, e as createDebugSession, c as createDebugger, l as createInspector } from './index-1W27DYJt.js';
+export { R as Recorder, a as RecorderEvents, T as Timeline, d as TimelineEventOptions, g as TimelineFilterOptions, e as TimelineMarker, f as TimelineSegment, h as TimelineStats, c as createRecorder, b as createTimeline } from './Recorder-Dc9qR2V2.js';
+export { CheckpointCreateOptions, CheckpointFilterOptions, CheckpointManager, IncrementalSnapshot, SnapshotManager, SnapshotOptions, createCheckpointManager, createSnapshotManager } from './recording/index.js';
+export { R as ReplayEngine, a as ReplayEngineEvents, b as ReplayOptions, c as createReplayEngine } from './ReplayEngine-Dyyqy5bw.js';
+export { PlaybackState, ReplayController, ReplayControllerEvents, RestoreOptions, StateRestorer, StateValidation, createReplayController, createStateRestorer } from './replay/index.js';
+export { DecisionTreeBuilder, EdgeStyle, FlowGraphBuilder, GraphBuildOptions, LayoutOptions, NodeOptions, NodeStyle, TreeBuildOptions, createDecisionTreeBuilder, createFlowGraphBuilder } from './visualization/index.js';
+export { FileStorage, FileStorageOptions, FileSystem, MemoryStorage, MemoryStorageOptions, RecordingMeta, createFileStorage, createMemoryStorage } from './storage/index.js';
+export { D as Difference, a as applyPatch, d as diff, g as getAtPath, i as isEqual, b as setAtPath, s as summarizeDiff, t as toReplayDifferences } from './diff-CLShBdWe.js';
+import 'eventemitter3';
+
+declare function generateId(prefix?: string): string;
+declare function now(): number;
+declare function duration(start: number, end?: number): number;
+declare function deepClone<T>(obj: T): T;
+declare function safeStringify(obj: unknown, indent?: number): string;
+declare function safeParse<T>(json: string, defaultValue?: T): T | undefined;
+declare function formatDuration(ms: number): string;
+declare function formatBytes(bytes: number): string;
+declare function truncate(str: string, maxLength: number, suffix?: string): string;
+declare function debounce<T extends (...args: unknown[]) => unknown>(fn: T, delay: number): (...args: Parameters<T>) => void;
+declare function sleep(ms: number): Promise<void>;
+declare function retry<T>(fn: () => Promise<T>, maxAttempts?: number, baseDelayMs?: number): Promise<T>;
+declare function estimateSize(obj: unknown): number;
+
+export { debounce, deepClone, duration, estimateSize, formatBytes, formatDuration, generateId, now, retry, safeParse, safeStringify, sleep, truncate };