@lov3kaizen/agentsea-debugger 0.5.1

package/dist/recording/index.js

@@ -0,0 +1,1207 @@
+import { EventEmitter } from 'eventemitter3';
+import { nanoid } from 'nanoid';
+
+// src/recording/Recorder.ts
+function generateId(prefix = "") {
+  const id = nanoid(12);
+  return prefix ? `${prefix}_${id}` : id;
+}
+function now() {
+  return Date.now();
+}
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof Map) {
+    const clonedMap = /* @__PURE__ */ new Map();
+    obj.forEach((value, key) => {
+      clonedMap.set(deepClone(key), deepClone(value));
+    });
+    return clonedMap;
+  }
+  if (obj instanceof Set) {
+    const clonedSet = /* @__PURE__ */ new Set();
+    obj.forEach((value) => {
+      clonedSet.add(deepClone(value));
+    });
+    return clonedSet;
+  }
+  const clonedObj = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      clonedObj[key] = deepClone(
+        obj[key]
+      );
+    }
+  }
+  return clonedObj;
+}
+function safeStringify(obj, indent = 0) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(
+    obj,
+    (key, value) => {
+      if (typeof value === "object" && value !== null) {
+        if (seen.has(value)) {
+          return "[Circular]";
+        }
+        seen.add(value);
+      }
+      if (value instanceof Error) {
+        return {
+          name: value.name,
+          message: value.message,
+          stack: value.stack
+        };
+      }
+      if (value instanceof Map) {
+        return Object.fromEntries(value);
+      }
+      if (value instanceof Set) {
+        return Array.from(value);
+      }
+      if (typeof value === "function") {
+        return `[Function: ${value.name || "anonymous"}]`;
+      }
+      if (typeof value === "bigint") {
+        return value.toString();
+      }
+      return value;
+    },
+    indent
+  );
+}
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return `${ms}ms`;
+  }
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  }
+  return `${seconds}s`;
+}
+function estimateSize(obj) {
+  return safeStringify(obj).length * 2;
+}
+
+// src/utils/diff.ts
+function diff(lhs, rhs, path = []) {
+  const differences = [];
+  if (lhs === rhs) {
+    return differences;
+  }
+  if (lhs === null || lhs === void 0) {
+    if (rhs !== null && rhs !== void 0) {
+      differences.push({ path, kind: "N", rhs });
+    }
+    return differences;
+  }
+  if (rhs === null || rhs === void 0) {
+    differences.push({ path, kind: "D", lhs });
+    return differences;
+  }
+  const lhsType = typeof lhs;
+  const rhsType = typeof rhs;
+  if (lhsType !== rhsType) {
+    differences.push({ path, kind: "E", lhs, rhs });
+    return differences;
+  }
+  if (lhsType !== "object") {
+    if (lhs !== rhs) {
+      differences.push({ path, kind: "E", lhs, rhs });
+    }
+    return differences;
+  }
+  if (Array.isArray(lhs) && Array.isArray(rhs)) {
+    const maxLen = Math.max(lhs.length, rhs.length);
+    for (let i = 0; i < maxLen; i++) {
+      if (i >= lhs.length) {
+        differences.push({
+          path,
+          kind: "A",
+          index: i,
+          item: { path: [...path, String(i)], kind: "N", rhs: rhs[i] }
+        });
+      } else if (i >= rhs.length) {
+        differences.push({
+          path,
+          kind: "A",
+          index: i,
+          item: { path: [...path, String(i)], kind: "D", lhs: lhs[i] }
+        });
+      } else {
+        const itemDiffs = diff(lhs[i], rhs[i], [...path, String(i)]);
+        differences.push(...itemDiffs);
+      }
+    }
+    return differences;
+  }
+  if (typeof lhs === "object" && typeof rhs === "object") {
+    const lhsObj = lhs;
+    const rhsObj = rhs;
+    const allKeys = /* @__PURE__ */ new Set([...Object.keys(lhsObj), ...Object.keys(rhsObj)]);
+    for (const key of allKeys) {
+      const keyPath = [...path, key];
+      if (!(key in lhsObj)) {
+        differences.push({ path: keyPath, kind: "N", rhs: rhsObj[key] });
+      } else if (!(key in rhsObj)) {
+        differences.push({ path: keyPath, kind: "D", lhs: lhsObj[key] });
+      } else {
+        const propDiffs = diff(lhsObj[key], rhsObj[key], keyPath);
+        differences.push(...propDiffs);
+      }
+    }
+  }
+  return differences;
+}
+
+// src/recording/Snapshot.ts
+var DEFAULT_OPTIONS = {
+  maxSnapshots: 100,
+  useDiffs: true,
+  compressionLevel: 0
+};
+var SnapshotManager = class {
+  snapshots = /* @__PURE__ */ new Map();
+  snapshotOrder = [];
+  options;
+  fullSnapshotInterval = 10;
+  constructor(options) {
+    this.options = {
+      ...DEFAULT_OPTIONS,
+      ...options
+    };
+  }
+  /**
+   * Create a snapshot
+   */
+  create(state, stepIndex) {
+    const id = generateId("snap");
+    const timestamp = now();
+    const shouldBeFull = !this.options.useDiffs || this.snapshotOrder.length === 0 || this.snapshotOrder.length % this.fullSnapshotInterval === 0;
+    let snapshot;
+    if (shouldBeFull) {
+      snapshot = {
+        id,
+        timestamp,
+        stepIndex,
+        state: deepClone(state),
+        size: estimateSize(state),
+        isFull: true
+      };
+    } else {
+      const previousId = this.snapshotOrder[this.snapshotOrder.length - 1];
+      const previous = this.snapshots.get(previousId);
+      if (previous) {
+        const stateDiff = diff(previous.state, state);
+        snapshot = {
+          id,
+          timestamp,
+          stepIndex,
+          state: deepClone(state),
+          size: estimateSize(state),
+          isFull: false,
+          diff: stateDiff,
+          previousId
+        };
+      } else {
+        snapshot = {
+          id,
+          timestamp,
+          stepIndex,
+          state: deepClone(state),
+          size: estimateSize(state),
+          isFull: true
+        };
+      }
+    }
+    this.snapshots.set(id, snapshot);
+    this.snapshotOrder.push(id);
+    this.enforceLimit();
+    return snapshot;
+  }
+  /**
+   * Get a snapshot by ID
+   */
+  get(id) {
+    return this.snapshots.get(id);
+  }
+  /**
+   * Get all snapshots
+   */
+  getAll() {
+    return this.snapshotOrder.map((id) => this.snapshots.get(id));
+  }
+  /**
+   * Get snapshot at or before a step
+   */
+  getAtStep(stepIndex) {
+    let closestSnapshot;
+    for (const id of this.snapshotOrder) {
+      const snapshot = this.snapshots.get(id);
+      if (snapshot && snapshot.stepIndex <= stepIndex) {
+        closestSnapshot = snapshot;
+      } else {
+        break;
+      }
+    }
+    return closestSnapshot;
+  }
+  /**
+   * Get snapshot after a step
+   */
+  getAfterStep(stepIndex) {
+    for (const id of this.snapshotOrder) {
+      const snapshot = this.snapshots.get(id);
+      if (snapshot && snapshot.stepIndex > stepIndex) {
+        return snapshot;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get snapshots in a range
+   */
+  getInRange(startStep, endStep) {
+    return this.getAll().filter(
+      (snap) => snap.stepIndex >= startStep && snap.stepIndex <= endStep
+    );
+  }
+  /**
+   * Restore state from a snapshot
+   */
+  restore(id) {
+    const snapshot = this.snapshots.get(id);
+    if (!snapshot) {
+      return void 0;
+    }
+    return deepClone(snapshot.state);
+  }
+  /**
+   * Get the latest snapshot
+   */
+  getLatest() {
+    if (this.snapshotOrder.length === 0) {
+      return void 0;
+    }
+    const latestId = this.snapshotOrder[this.snapshotOrder.length - 1];
+    return this.snapshots.get(latestId);
+  }
+  /**
+   * Get the first snapshot
+   */
+  getFirst() {
+    if (this.snapshotOrder.length === 0) {
+      return void 0;
+    }
+    const firstId = this.snapshotOrder[0];
+    return this.snapshots.get(firstId);
+  }
+  /**
+   * Delete a snapshot
+   */
+  delete(id) {
+    const existed = this.snapshots.delete(id);
+    if (existed) {
+      this.snapshotOrder = this.snapshotOrder.filter((i) => i !== id);
+    }
+    return existed;
+  }
+  /**
+   * Clear all snapshots
+   */
+  clear() {
+    this.snapshots.clear();
+    this.snapshotOrder = [];
+  }
+  /**
+   * Get snapshot count
+   */
+  get count() {
+    return this.snapshots.size;
+  }
+  /**
+   * Get total size of all snapshots
+   */
+  getTotalSize() {
+    let total = 0;
+    for (const snapshot of this.snapshots.values()) {
+      total += snapshot.size ?? 0;
+    }
+    return total;
+  }
+  /**
+   * Compact snapshots by merging diffs
+   */
+  compact() {
+    const fullSnapshots = this.getAll().filter(
+      (snap) => snap.isFull
+    );
+    this.clear();
+    for (const snapshot of fullSnapshots) {
+      this.snapshots.set(snapshot.id, snapshot);
+      this.snapshotOrder.push(snapshot.id);
+    }
+  }
+  /**
+   * Compare two snapshots
+   */
+  compare(id1, id2) {
+    const snap1 = this.snapshots.get(id1);
+    const snap2 = this.snapshots.get(id2);
+    if (!snap1 || !snap2) {
+      return void 0;
+    }
+    return diff(snap1.state, snap2.state);
+  }
+  /**
+   * Export snapshots
+   */
+  export() {
+    return this.getAll().map((snap) => ({
+      id: snap.id,
+      timestamp: snap.timestamp,
+      stepIndex: snap.stepIndex,
+      state: snap.state,
+      size: snap.size
+    }));
+  }
+  /**
+   * Import snapshots
+   */
+  import(snapshots) {
+    this.clear();
+    for (const snapshot of snapshots) {
+      const incremental = {
+        ...snapshot,
+        isFull: true
+      };
+      this.snapshots.set(snapshot.id, incremental);
+      this.snapshotOrder.push(snapshot.id);
+    }
+  }
+  /**
+   * Enforce max snapshots limit
+   */
+  enforceLimit() {
+    while (this.snapshotOrder.length > this.options.maxSnapshots) {
+      const oldestId = this.snapshotOrder.shift();
+      if (oldestId) {
+        this.snapshots.delete(oldestId);
+      }
+    }
+  }
+};
+function createSnapshotManager(options) {
+  return new SnapshotManager(options);
+}
+
+// src/recording/Checkpoint.ts
+var CheckpointManager = class {
+  checkpoints = /* @__PURE__ */ new Map();
+  checkpointOrder = [];
+  /**
+   * Create a checkpoint
+   */
+  create(options) {
+    const checkpoint = {
+      id: generateId("cp"),
+      recordingId: options.recordingId,
+      name: options.name,
+      description: options.description,
+      stepIndex: options.stepIndex,
+      timestamp: now(),
+      state: deepClone(options.state),
+      automatic: options.automatic ?? false
+    };
+    this.checkpoints.set(checkpoint.id, checkpoint);
+    this.checkpointOrder.push(checkpoint.id);
+    return checkpoint;
+  }
+  /**
+   * Get a checkpoint by ID
+   */
+  get(id) {
+    return this.checkpoints.get(id);
+  }
+  /**
+   * Get checkpoint by name
+   */
+  getByName(name) {
+    for (const checkpoint of this.checkpoints.values()) {
+      if (checkpoint.name === name) {
+        return checkpoint;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get all checkpoints
+   */
+  getAll() {
+    return this.checkpointOrder.map((id) => this.checkpoints.get(id));
+  }
+  /**
+   * Get checkpoints matching filter
+   */
+  filter(options) {
+    return this.getAll().filter((cp) => {
+      if (options.namePattern) {
+        if (typeof options.namePattern === "string") {
+          if (!cp.name.includes(options.namePattern)) {
+            return false;
+          }
+        } else if (!options.namePattern.test(cp.name)) {
+          return false;
+        }
+      }
+      if (options.stepRange) {
+        if (options.stepRange.min !== void 0 && cp.stepIndex < options.stepRange.min) {
+          return false;
+        }
+        if (options.stepRange.max !== void 0 && cp.stepIndex > options.stepRange.max) {
+          return false;
+        }
+      }
+      if (options.timeRange) {
+        if (options.timeRange.after !== void 0 && cp.timestamp < options.timeRange.after) {
+          return false;
+        }
+        if (options.timeRange.before !== void 0 && cp.timestamp > options.timeRange.before) {
+          return false;
+        }
+      }
+      if (options.automatic !== void 0 && cp.automatic !== options.automatic) {
+        return false;
+      }
+      return true;
+    });
+  }
+  /**
+   * Get checkpoint at or before a step
+   */
+  getAtStep(stepIndex) {
+    let closestCheckpoint;
+    for (const id of this.checkpointOrder) {
+      const checkpoint = this.checkpoints.get(id);
+      if (checkpoint && checkpoint.stepIndex <= stepIndex) {
+        closestCheckpoint = checkpoint;
+      } else {
+        break;
+      }
+    }
+    return closestCheckpoint;
+  }
+  /**
+   * Get checkpoint after a step
+   */
+  getAfterStep(stepIndex) {
+    for (const id of this.checkpointOrder) {
+      const checkpoint = this.checkpoints.get(id);
+      if (checkpoint && checkpoint.stepIndex > stepIndex) {
+        return checkpoint;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get checkpoints in step range
+   */
+  getInRange(startStep, endStep) {
+    return this.getAll().filter(
+      (cp) => cp.stepIndex >= startStep && cp.stepIndex <= endStep
+    );
+  }
+  /**
+   * Get state from checkpoint
+   */
+  getState(id) {
+    const checkpoint = this.checkpoints.get(id);
+    if (!checkpoint) {
+      return void 0;
+    }
+    return deepClone(checkpoint.state);
+  }
+  /**
+   * Update checkpoint
+   */
+  update(id, updates) {
+    const checkpoint = this.checkpoints.get(id);
+    if (!checkpoint) {
+      return false;
+    }
+    if (updates.name !== void 0) {
+      checkpoint.name = updates.name;
+    }
+    if (updates.description !== void 0) {
+      checkpoint.description = updates.description;
+    }
+    return true;
+  }
+  /**
+   * Delete a checkpoint
+   */
+  delete(id) {
+    const existed = this.checkpoints.delete(id);
+    if (existed) {
+      this.checkpointOrder = this.checkpointOrder.filter((i) => i !== id);
+    }
+    return existed;
+  }
+  /**
+   * Clear all checkpoints
+   */
+  clear() {
+    this.checkpoints.clear();
+    this.checkpointOrder = [];
+  }
+  /**
+   * Get checkpoint count
+   */
+  get count() {
+    return this.checkpoints.size;
+  }
+  /**
+   * Get the latest checkpoint
+   */
+  getLatest() {
+    if (this.checkpointOrder.length === 0) {
+      return void 0;
+    }
+    const latestId = this.checkpointOrder[this.checkpointOrder.length - 1];
+    return this.checkpoints.get(latestId);
+  }
+  /**
+   * Get the first checkpoint
+   */
+  getFirst() {
+    if (this.checkpointOrder.length === 0) {
+      return void 0;
+    }
+    const firstId = this.checkpointOrder[0];
+    return this.checkpoints.get(firstId);
+  }
+  /**
+   * Get manual checkpoints only
+   */
+  getManual() {
+    return this.filter({ automatic: false });
+  }
+  /**
+   * Get automatic checkpoints only
+   */
+  getAutomatic() {
+    return this.filter({ automatic: true });
+  }
+  /**
+   * Export checkpoints
+   */
+  export() {
+    return this.getAll().map((cp) => ({
+      id: cp.id,
+      recordingId: cp.recordingId,
+      name: cp.name,
+      description: cp.description,
+      stepIndex: cp.stepIndex,
+      timestamp: cp.timestamp,
+      state: cp.state,
+      automatic: cp.automatic
+    }));
+  }
+  /**
+   * Import checkpoints
+   */
+  import(checkpoints) {
+    this.clear();
+    for (const checkpoint of checkpoints) {
+      this.checkpoints.set(checkpoint.id, deepClone(checkpoint));
+      this.checkpointOrder.push(checkpoint.id);
+    }
+  }
+};
+function createCheckpointManager() {
+  return new CheckpointManager();
+}
+
+// src/recording/Timeline.ts
+var Timeline = class {
+  events = /* @__PURE__ */ new Map();
+  eventOrder = [];
+  markers = /* @__PURE__ */ new Map();
+  segments = /* @__PURE__ */ new Map();
+  /**
+   * Add an event to the timeline
+   */
+  addEvent(options) {
+    const event = {
+      id: options.id ?? generateId("evt"),
+      type: options.type,
+      timestamp: options.timestamp ?? now(),
+      stepIndex: options.stepIndex,
+      summary: options.description ?? "",
+      description: options.description,
+      durationMs: options.durationMs,
+      metadata: options.metadata
+    };
+    this.events.set(event.id, event);
+    this.eventOrder.push(event.id);
+    return event;
+  }
+  /**
+   * Get an event by ID
+   */
+  getEvent(id) {
+    return this.events.get(id);
+  }
+  /**
+   * Get all events
+   */
+  getEvents() {
+    return this.eventOrder.map((id) => this.events.get(id));
+  }
+  /**
+   * Get events matching filter
+   */
+  filterEvents(options) {
+    return this.getEvents().filter((event) => {
+      if (options.types && !options.types.includes(event.type)) {
+        return false;
+      }
+      if (options.stepRange) {
+        if (options.stepRange.min !== void 0 && event.stepIndex < options.stepRange.min) {
+          return false;
+        }
+        if (options.stepRange.max !== void 0 && event.stepIndex > options.stepRange.max) {
+          return false;
+        }
+      }
+      if (options.timeRange) {
+        if (options.timeRange.after !== void 0 && event.timestamp < options.timeRange.after) {
+          return false;
+        }
+        if (options.timeRange.before !== void 0 && event.timestamp > options.timeRange.before) {
+          return false;
+        }
+      }
+      if (options.search) {
+        const searchLower = options.search.toLowerCase();
+        const description = event.description ?? event.summary ?? "";
+        if (!description.toLowerCase().includes(searchLower)) {
+          return false;
+        }
+      }
+      return true;
+    });
+  }
+  /**
+   * Get events in step range
+   */
+  getEventsInRange(startStep, endStep) {
+    return this.filterEvents({
+      stepRange: { min: startStep, max: endStep }
+    });
+  }
+  /**
+   * Get events by type
+   */
+  getEventsByType(type) {
+    return this.filterEvents({ types: [type] });
+  }
+  /**
+   * Get event at step
+   */
+  getEventAtStep(stepIndex) {
+    return this.getEvents().find((e) => e.stepIndex === stepIndex);
+  }
+  /**
+   * Add a marker
+   */
+  addMarker(options) {
+    const marker = {
+      id: generateId("mark"),
+      name: options.name,
+      timestamp: options.timestamp ?? now(),
+      stepIndex: options.stepIndex,
+      color: options.color,
+      description: options.description
+    };
+    this.markers.set(marker.id, marker);
+    return marker;
+  }
+  /**
+   * Get all markers
+   */
+  getMarkers() {
+    return Array.from(this.markers.values());
+  }
+  /**
+   * Get marker at step
+   */
+  getMarkerAtStep(stepIndex) {
+    for (const marker of this.markers.values()) {
+      if (marker.stepIndex === stepIndex) {
+        return marker;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Remove a marker
+   */
+  removeMarker(id) {
+    return this.markers.delete(id);
+  }
+  /**
+   * Add a segment
+   */
+  addSegment(options) {
+    const segment = {
+      id: generateId("seg"),
+      ...options
+    };
+    this.segments.set(segment.id, segment);
+    return segment;
+  }
+  /**
+   * Get all segments
+   */
+  getSegments() {
+    return Array.from(this.segments.values());
+  }
+  /**
+   * Get segment containing step
+   */
+  getSegmentForStep(stepIndex) {
+    for (const segment of this.segments.values()) {
+      if (stepIndex >= segment.startStep && stepIndex <= segment.endStep) {
+        return segment;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Remove a segment
+   */
+  removeSegment(id) {
+    return this.segments.delete(id);
+  }
+  /**
+   * Get timeline statistics
+   */
+  getStats() {
+    const events = this.getEvents();
+    const eventsByType = {};
+    let totalDuration = 0;
+    for (const event of events) {
+      eventsByType[event.type] = (eventsByType[event.type] ?? 0) + 1;
+      if (event.durationMs) {
+        totalDuration += event.durationMs;
+      }
+    }
+    return {
+      totalEvents: events.length,
+      eventsByType,
+      totalDurationMs: totalDuration,
+      avgEventDurationMs: events.length > 0 ? totalDuration / events.length : 0,
+      firstEventTime: events.length > 0 ? events[0].timestamp : void 0,
+      lastEventTime: events.length > 0 ? events[events.length - 1].timestamp : void 0
+    };
+  }
+  /**
+   * Get duration between two steps
+   */
+  getDurationBetween(startStep, endStep) {
+    const startEvent = this.getEventAtStep(startStep);
+    const endEvent = this.getEventAtStep(endStep);
+    if (!startEvent || !endEvent) {
+      return 0;
+    }
+    return endEvent.timestamp - startEvent.timestamp;
+  }
+  /**
+   * Format timeline as text
+   */
+  format() {
+    const lines = [];
+    const events = this.getEvents();
+    for (const event of events) {
+      const duration = event.durationMs ? ` (${formatDuration(event.durationMs)})` : "";
+      lines.push(
+        `[${event.stepIndex}] ${event.type}: ${event.description}${duration}`
+      );
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Clear the timeline
+   */
+  clear() {
+    this.events.clear();
+    this.eventOrder = [];
+    this.markers.clear();
+    this.segments.clear();
+  }
+  /**
+   * Get event count
+   */
+  get count() {
+    return this.events.size;
+  }
+  /**
+   * Export timeline data
+   */
+  export() {
+    return {
+      events: this.getEvents(),
+      markers: this.getMarkers(),
+      segments: this.getSegments()
+    };
+  }
+  /**
+   * Import timeline data
+   */
+  import(data) {
+    this.clear();
+    if (data.events) {
+      for (const event of data.events) {
+        this.events.set(event.id, event);
+        this.eventOrder.push(event.id);
+      }
+    }
+    if (data.markers) {
+      for (const marker of data.markers) {
+        this.markers.set(marker.id, marker);
+      }
+    }
+    if (data.segments) {
+      for (const segment of data.segments) {
+        this.segments.set(segment.id, segment);
+      }
+    }
+  }
+};
+function createTimeline() {
+  return new Timeline();
+}
+
+// src/recording/Recorder.ts
+var DEFAULT_CONFIG = {
+  includePrompts: true,
+  includeResponses: true,
+  includeToolCalls: true,
+  includeMemory: true,
+  includeMetadata: true,
+  compression: false,
+  maxSizeBytes: 100 * 1024 * 1024,
+  // 100MB
+  autoSnapshot: false,
+  snapshotInterval: 0,
+  maxRecordings: 1e3,
+  retentionDays: 30,
+  checkpointInterval: 0,
+  includeEmbeddings: false,
+  storage: void 0
+};
+var Recorder = class extends EventEmitter {
+  config;
+  state = "idle";
+  recordingId;
+  agentId;
+  agentName;
+  steps = [];
+  startedAt = 0;
+  initialState;
+  currentState;
+  snapshots;
+  checkpoints;
+  timeline;
+  storage;
+  estimatedSize = 0;
+  constructor(config, storage) {
+    super();
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+    this.storage = storage;
+    this.snapshots = new SnapshotManager();
+    this.checkpoints = new CheckpointManager();
+    this.timeline = new Timeline();
+  }
+  /**
+   * Start recording
+   */
+  start(agentId, initialState, agentName) {
+    if (this.state !== "idle") {
+      throw new Error(`Cannot start recording in state: ${this.state}`);
+    }
+    this.recordingId = generateId("rec");
+    this.agentId = agentId;
+    this.agentName = agentName ?? initialState.agentName;
+    this.initialState = deepClone(initialState);
+    this.currentState = deepClone(initialState);
+    this.steps = [];
+    this.startedAt = now();
+    this.estimatedSize = 0;
+    this.state = "recording";
+    this.snapshots = new SnapshotManager();
+    this.checkpoints = new CheckpointManager();
+    this.timeline = new Timeline();
+    this.snapshots.create(initialState, 0);
+    this.emit("recording:started", this.recordingId);
+    return this.recordingId;
+  }
+  /**
+   * Stop recording
+   */
+  stop() {
+    if (this.state !== "recording" && this.state !== "paused") {
+      throw new Error(`Cannot stop recording in state: ${this.state}`);
+    }
+    const recording = this.buildRecording();
+    this.state = "stopped";
+    this.emit("recording:stopped", recording);
+    return recording;
+  }
+  /**
+   * Pause recording
+   */
+  pause() {
+    if (this.state !== "recording") {
+      return;
+    }
+    this.state = "paused";
+    this.emit("recording:paused");
+  }
+  /**
+   * Resume recording
+   */
+  resume() {
+    if (this.state !== "paused") {
+      return;
+    }
+    this.state = "recording";
+    this.emit("recording:resumed");
+  }
+  /**
+   * Record a step
+   */
+  recordStep(step, state) {
+    if (this.state !== "recording") {
+      return false;
+    }
+    const stepSize = estimateSize(step);
+    if (this.estimatedSize + stepSize > this.config.maxSizeBytes) {
+      this.emit("error", new Error("Recording size limit exceeded"));
+      return false;
+    }
+    const filteredStep = this.filterStep(step);
+    if (!filteredStep) {
+      return false;
+    }
+    this.steps.push(filteredStep);
+    this.currentState = deepClone(state);
+    this.estimatedSize += stepSize;
+    this.timeline.addEvent({
+      id: generateId("evt"),
+      type: filteredStep.type,
+      timestamp: filteredStep.timestamp,
+      stepIndex: filteredStep.index,
+      description: this.getStepDescription(filteredStep)
+    });
+    if (this.config.autoSnapshot && this.config.snapshotInterval > 0 && this.steps.length % this.config.snapshotInterval === 0) {
+      const snapshot = this.snapshots.create(state, filteredStep.index);
+      this.emit("snapshot:created", snapshot);
+    }
+    this.emit("step:recorded", filteredStep);
+    return true;
+  }
+  /**
+   * Create a checkpoint
+   */
+  createCheckpoint(name, description) {
+    if (this.state !== "recording" && this.state !== "paused") {
+      return void 0;
+    }
+    if (!this.recordingId || !this.currentState) {
+      return void 0;
+    }
+    const stepIndex = this.steps.length > 0 ? this.steps[this.steps.length - 1].index : -1;
+    const checkpoint = this.checkpoints.create({
+      recordingId: this.recordingId,
+      name,
+      description,
+      stepIndex,
+      state: this.currentState
+    });
+    this.snapshots.create(this.currentState, stepIndex);
+    this.emit("checkpoint:created", checkpoint);
+    return checkpoint;
+  }
+  /**
+   * Get current recording state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Get recording ID
+   */
+  getRecordingId() {
+    return this.recordingId;
+  }
+  /**
+   * Get steps count
+   */
+  getStepsCount() {
+    return this.steps.length;
+  }
+  /**
+   * Get estimated size
+   */
+  getEstimatedSize() {
+    return this.estimatedSize;
+  }
+  /**
+   * Get timeline
+   */
+  getTimeline() {
+    return this.timeline;
+  }
+  /**
+   * Get snapshots
+   */
+  getSnapshots() {
+    return this.snapshots.getAll();
+  }
+  /**
+   * Get checkpoints
+   */
+  getCheckpoints() {
+    return this.checkpoints.getAll();
+  }
+  /**
+   * Save recording to storage
+   */
+  async save() {
+    if (!this.storage) {
+      throw new Error("No storage adapter configured");
+    }
+    const recording = this.buildRecording();
+    await this.storage.save(recording);
+  }
+  /**
+   * Filter step based on configuration
+   */
+  filterStep(step) {
+    const filtered = { ...step };
+    if (!this.config.includePrompts && step.type === "prompt") {
+      return null;
+    }
+    if (!this.config.includeResponses && step.type === "response") {
+      return null;
+    }
+    if (!this.config.includeToolCalls && (step.type === "tool-call" || step.type === "tool-result")) {
+      return null;
+    }
+    if (!this.config.includeMetadata) {
+      delete filtered.metadata;
+    }
+    return filtered;
+  }
+  /**
+   * Get step description for timeline
+   */
+  getStepDescription(step) {
+    switch (step.type) {
+      case "input":
+        return "User input received";
+      case "prompt":
+        return "Prompt sent to model";
+      case "response":
+        return "Response received from model";
+      case "tool-call":
+        return `Tool called: ${step.toolCall?.name ?? "unknown"}`;
+      case "tool-result":
+        return `Tool result: ${step.toolCall?.success ? "success" : "failed"}`;
+      case "decision":
+        return `Decision made: ${step.decision?.chosen.description ?? "unknown"}`;
+      case "error":
+        return `Error: ${step.error?.message ?? "unknown"}`;
+      default:
+        return `Step: ${step.type}`;
+    }
+  }
+  /**
+   * Build the recording object
+   */
+  buildRecording() {
+    const endedAt = now();
+    const toolCalls = this.steps.filter((s) => s.toolCall).map((s) => s.toolCall);
+    const decisions = this.steps.filter((s) => s.decision).map((s) => s.decision);
+    const tokenUsage = this.steps.reduce(
+      (acc, step) => {
+        if (step.tokenUsage) {
+          acc.prompt += step.tokenUsage.prompt;
+          acc.completion += step.tokenUsage.completion;
+          acc.total += step.tokenUsage.total;
+        }
+        return acc;
+      },
+      { prompt: 0, completion: 0, total: 0 }
+    );
+    const hasErrors = this.steps.some((s) => s.error);
+    return {
+      id: this.recordingId,
+      agentId: this.agentId,
+      agentName: this.agentName ?? "Unknown",
+      status: hasErrors ? "failed" : "completed",
+      startedAt: this.startedAt,
+      endedAt,
+      durationMs: endedAt - this.startedAt,
+      steps: this.steps,
+      toolCalls,
+      decisions,
+      checkpoints: this.checkpoints.getAll(),
+      initialState: this.initialState,
+      finalState: this.currentState,
+      tokenUsage,
+      version: "1.0.0",
+      metadata: this.config.includeMetadata ? this.buildMetadata() : void 0
+    };
+  }
+  /**
+   * Build recording metadata
+   */
+  buildMetadata() {
+    return {
+      totalSteps: this.steps.length,
+      totalToolCalls: this.steps.filter((s) => s.type === "tool-call").length,
+      totalDecisions: this.steps.filter((s) => s.type === "decision").length,
+      hasErrors: this.steps.some((s) => s.error),
+      compressionUsed: this.config.compression,
+      recordingVersion: "1.0.0",
+      tags: []
+    };
+  }
+};
+function createRecorder(config, storage) {
+  return new Recorder(config, storage);
+}
+
+export { CheckpointManager, Recorder, SnapshotManager, Timeline, createCheckpointManager, createRecorder, createSnapshotManager, createTimeline };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map