@lov3kaizen/agentsea-debugger 0.5.1

package/dist/replay/index.js

@@ -0,0 +1,1112 @@
+import { EventEmitter } from 'eventemitter3';
+import { nanoid } from 'nanoid';
+
+// src/replay/ReplayEngine.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 sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// 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;
+}
+function toReplayDifferences(diffs, stepIndex) {
+  return diffs.map((d) => ({
+    stepIndex,
+    path: d.path.join("."),
+    original: d.lhs,
+    replayed: d.rhs,
+    type: d.kind === "N" ? "added" : d.kind === "D" ? "removed" : "changed"
+  }));
+}
+function applyPatches(target, patches) {
+  let result = target;
+  for (const patch of patches) {
+    result = applyPatch(result, patch);
+  }
+  return result;
+}
+function applyPatch(target, patch) {
+  const result = JSON.parse(JSON.stringify(target));
+  if (patch.path.length === 0) {
+    return patch.rhs;
+  }
+  let current = result;
+  for (let i = 0; i < patch.path.length - 1; i++) {
+    const key = patch.path[i];
+    if (!(key in current)) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  const lastKey = patch.path[patch.path.length - 1];
+  switch (patch.kind) {
+    case "N":
+    case "E":
+      current[lastKey] = patch.rhs;
+      break;
+    case "D":
+      delete current[lastKey];
+      break;
+    case "A":
+      if (Array.isArray(current[lastKey]) && patch.item) {
+        const arr = current[lastKey];
+        if (patch.item.kind === "N") {
+          arr.splice(patch.index, 0, patch.item.rhs);
+        } else if (patch.item.kind === "D") {
+          arr.splice(patch.index, 1);
+        } else if (patch.item.kind === "E") {
+          arr[patch.index] = patch.item.rhs;
+        }
+      }
+      break;
+  }
+  return result;
+}
+
+// src/replay/StateRestorer.ts
+var DEFAULT_OPTIONS = {
+  includeMemory: true,
+  includeContext: true,
+  includeMessages: true,
+  includeTools: true
+};
+var StateRestorer = class {
+  options;
+  stateCache = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = {
+      ...DEFAULT_OPTIONS,
+      ...options
+    };
+  }
+  /**
+   * Restore state at a specific step
+   */
+  restore(recording, stepIndex) {
+    const cacheKey = recording.id;
+    const recordingCache = this.stateCache.get(cacheKey);
+    if (recordingCache?.has(stepIndex)) {
+      return deepClone(recordingCache.get(stepIndex));
+    }
+    if (stepIndex < 0) {
+      const state2 = deepClone(recording.initialState);
+      if (!recordingCache) {
+        this.stateCache.set(cacheKey, /* @__PURE__ */ new Map());
+      }
+      this.stateCache.get(cacheKey).set(stepIndex, deepClone(state2));
+      return state2;
+    }
+    let state;
+    let startStep;
+    const checkpoint = this.findClosestCheckpoint(recording, stepIndex);
+    if (checkpoint) {
+      if (checkpoint.stepIndex === stepIndex) {
+        state = deepClone(recording.initialState);
+        startStep = 0;
+      } else {
+        state = deepClone(recording.initialState);
+        startStep = 0;
+      }
+    } else {
+      state = deepClone(recording.initialState);
+      startStep = 0;
+    }
+    for (let i = startStep; i <= stepIndex && i < recording.steps.length; i++) {
+      state = this.applyStep(state, recording.steps[i]);
+    }
+    if (!recordingCache) {
+      this.stateCache.set(cacheKey, /* @__PURE__ */ new Map());
+    }
+    this.stateCache.get(cacheKey).set(stepIndex, deepClone(state));
+    return state;
+  }
+  /**
+   * Restore state from a checkpoint
+   */
+  restoreFromCheckpoint(checkpoint) {
+    return deepClone(checkpoint.state);
+  }
+  /**
+   * Apply a step to state
+   */
+  applyStep(state, step) {
+    const newState = deepClone(state);
+    switch (step.type) {
+      case "input":
+        if (this.options.includeMessages) {
+          newState.messages.push({
+            role: "user",
+            content: String(step.input)
+          });
+        }
+        break;
+      case "prompt":
+        break;
+      case "response":
+        if (this.options.includeMessages) {
+          newState.messages.push({
+            role: "assistant",
+            content: String(step.output)
+          });
+        }
+        break;
+      case "tool-call":
+        if (this.options.includeMessages && step.toolCall) {
+          newState.messages.push({
+            role: "assistant",
+            content: `[Calling tool: ${step.toolCall.name}]`,
+            toolCalls: [
+              {
+                id: step.toolCall.id,
+                name: step.toolCall.name,
+                arguments: step.toolCall.arguments
+              }
+            ]
+          });
+        }
+        break;
+      case "tool-result":
+        if (this.options.includeMessages && step.toolCall) {
+          newState.messages.push({
+            role: "tool",
+            content: String(step.toolCall.result ?? ""),
+            toolCallId: step.toolCall.id
+          });
+        }
+        break;
+      case "memory-write":
+        if (this.options.includeMemory && step.output) {
+          this.applyMemoryChange(
+            newState,
+            step.output
+          );
+        }
+        break;
+      case "memory-read":
+        break;
+      case "decision":
+        if (this.options.includeContext && step.decision) {
+          newState.context["lastDecision"] = {
+            options: step.decision.options.map((o) => o.description),
+            chosen: step.decision.chosen.description,
+            confidence: step.decision.confidence
+          };
+        }
+        break;
+      case "handoff":
+      case "delegation":
+        if (this.options.includeContext && step.output) {
+          const output = step.output;
+          newState.context["delegatedTo"] = output.agentId ?? output.agentName;
+        }
+        break;
+      case "error":
+        newState.context["lastError"] = step.error;
+        break;
+    }
+    return newState;
+  }
+  /**
+   * Apply memory changes to state
+   */
+  applyMemoryChange(state, changes) {
+    for (const [key, value] of Object.entries(changes)) {
+      if (key === "working") {
+        state.memory.working = {
+          ...state.memory.working,
+          ...value
+        };
+      } else if (key === "shortTerm" && Array.isArray(value)) {
+        state.memory.shortTerm = [...state.memory.shortTerm ?? [], ...value];
+      } else if (key === "longTermSummary" && typeof value === "string") {
+        state.memory.longTermSummary = value;
+      } else if (key === "size" && typeof value === "number") {
+        state.memory.size = value;
+      }
+    }
+  }
+  /**
+   * Find closest checkpoint before or at step
+   */
+  findClosestCheckpoint(recording, stepIndex) {
+    let closest;
+    for (const checkpoint of recording.checkpoints) {
+      if (checkpoint.stepIndex <= stepIndex) {
+        if (!closest || checkpoint.stepIndex > closest.stepIndex) {
+          closest = checkpoint;
+        }
+      }
+    }
+    return closest;
+  }
+  /**
+   * Apply a diff patch to state
+   */
+  applyPatch(state, differences) {
+    return applyPatches(state, differences);
+  }
+  /**
+   * Validate restored state
+   */
+  validate(state) {
+    const errors = [];
+    const warnings = [];
+    if (!state.agentId) {
+      errors.push("Missing agentId");
+    }
+    if (!state.agentName) {
+      warnings.push("Missing agentName");
+    }
+    if (!state.model) {
+      warnings.push("Missing model");
+    }
+    if (!state.memory) {
+      errors.push("Missing memory object");
+    } else {
+      if (typeof state.memory.size !== "number") {
+        warnings.push("Memory size should be a number");
+      }
+    }
+    if (!Array.isArray(state.messages)) {
+      errors.push("Messages should be an array");
+    } else {
+      for (let i = 0; i < state.messages.length; i++) {
+        const msg = state.messages[i];
+        if (!msg.role) {
+          errors.push(`Message ${i} missing role`);
+        }
+        if (msg.content === void 0 && !msg.toolCalls) {
+          warnings.push(`Message ${i} has no content or tool calls`);
+        }
+        if (typeof msg.content === "string" && msg.content.trim() === "") {
+          warnings.push(`Message ${i} has empty content`);
+        }
+      }
+    }
+    if (!state.context || typeof state.context !== "object") {
+      warnings.push("Context should be an object");
+    }
+    if (!Array.isArray(state.tools)) {
+      warnings.push("Tools should be an array");
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Merge two states
+   */
+  merge(base, overlay) {
+    const merged = deepClone(base);
+    if (overlay.agentId) {
+      merged.agentId = overlay.agentId;
+    }
+    if (overlay.agentName) {
+      merged.agentName = overlay.agentName;
+    }
+    if (overlay.model) {
+      merged.model = overlay.model;
+    }
+    if (overlay.memory) {
+      merged.memory = {
+        ...merged.memory,
+        ...overlay.memory
+      };
+    }
+    if (overlay.context) {
+      merged.context = {
+        ...merged.context,
+        ...overlay.context
+      };
+    }
+    if (overlay.tools) {
+      merged.tools = [...overlay.tools];
+    }
+    if (overlay.messages) {
+      merged.messages = [...overlay.messages];
+    }
+    return merged;
+  }
+  /**
+   * Create a minimal state
+   */
+  createMinimalState(agentId, agentName, model) {
+    return {
+      agentId,
+      agentName,
+      model,
+      memory: {
+        size: 0
+      },
+      context: {},
+      tools: [],
+      messages: []
+    };
+  }
+  /**
+   * Clear state cache
+   */
+  clearCache() {
+    this.stateCache.clear();
+  }
+  /**
+   * Clear cache for specific recording
+   */
+  clearRecordingCache(recordingId) {
+    this.stateCache.delete(recordingId);
+  }
+  /**
+   * Get cache size
+   */
+  getCacheSize() {
+    let size = 0;
+    for (const cache of this.stateCache.values()) {
+      size += cache.size;
+    }
+    return size;
+  }
+};
+function createStateRestorer(options) {
+  return new StateRestorer(options);
+}
+var ReplayController = class extends EventEmitter {
+  recording;
+  session;
+  config;
+  playbackState;
+  stateHistory = /* @__PURE__ */ new Map();
+  checkpointMap = /* @__PURE__ */ new Map();
+  constructor(recording, session, config) {
+    super();
+    this.recording = recording;
+    this.session = session;
+    this.config = config;
+    this.playbackState = {
+      currentStep: session.currentStep,
+      state: deepClone(recording.initialState),
+      isPaused: false
+    };
+    this.stateHistory.set(-1, deepClone(recording.initialState));
+    for (const checkpoint of recording.checkpoints) {
+      this.checkpointMap.set(checkpoint.id, checkpoint);
+    }
+  }
+  /**
+   * Step forward one step
+   */
+  stepForward() {
+    const nextStep = this.playbackState.currentStep + 1;
+    if (nextStep >= this.recording.steps.length) {
+      return void 0;
+    }
+    const step = this.recording.steps[nextStep];
+    const newState = this.applyStep(this.playbackState.state, step);
+    this.stateHistory.set(nextStep, deepClone(newState));
+    this.playbackState.currentStep = nextStep;
+    this.playbackState.state = newState;
+    this.session.currentStep = nextStep;
+    this.emit("step:replayed", step, newState);
+    this.checkPauseConditions(step);
+    return step;
+  }
+  /**
+   * Step backward one step
+   */
+  stepBackward() {
+    if (this.playbackState.currentStep < 0) {
+      return void 0;
+    }
+    const prevStep = this.playbackState.currentStep - 1;
+    let state = this.stateHistory.get(prevStep);
+    if (!state) {
+      state = this.rebuildStateAt(prevStep);
+      this.stateHistory.set(prevStep, deepClone(state));
+    }
+    this.playbackState.currentStep = prevStep;
+    this.playbackState.state = deepClone(state);
+    this.session.currentStep = Math.max(0, prevStep);
+    const stepIndex = prevStep - 1;
+    if (stepIndex >= 0 && stepIndex < this.recording.steps.length) {
+      const step = this.recording.steps[stepIndex];
+      this.emit("step:replayed", step, this.playbackState.state);
+      return step;
+    }
+    return void 0;
+  }
+  /**
+   * Jump to a specific step
+   */
+  jumpToStep(stepIndex) {
+    if (stepIndex < -1 || stepIndex >= this.recording.steps.length) {
+      return void 0;
+    }
+    let state = this.stateHistory.get(stepIndex);
+    if (!state) {
+      state = this.rebuildStateAt(stepIndex);
+      this.stateHistory.set(stepIndex, deepClone(state));
+    }
+    this.playbackState.currentStep = stepIndex;
+    this.playbackState.state = deepClone(state);
+    this.session.currentStep = Math.max(0, stepIndex);
+    if (stepIndex >= 0) {
+      const step = this.recording.steps[stepIndex];
+      this.emit("step:replayed", step, this.playbackState.state);
+      return step;
+    }
+    return void 0;
+  }
+  /**
+   * Jump to a checkpoint
+   */
+  jumpToCheckpoint(checkpointId) {
+    const checkpoint = this.checkpointMap.get(checkpointId);
+    if (!checkpoint) {
+      return false;
+    }
+    this.playbackState.currentStep = checkpoint.stepIndex;
+    this.playbackState.state = deepClone(checkpoint.state);
+    this.session.currentStep = checkpoint.stepIndex;
+    this.stateHistory.set(checkpoint.stepIndex, deepClone(checkpoint.state));
+    this.emit("checkpoint:reached", checkpoint);
+    if (checkpoint.stepIndex >= 0 && checkpoint.stepIndex < this.recording.steps.length) {
+      const step = this.recording.steps[checkpoint.stepIndex];
+      this.emit("step:replayed", step, this.playbackState.state);
+    }
+    return true;
+  }
+  /**
+   * Get next checkpoint
+   */
+  getNextCheckpoint() {
+    const currentStep = this.playbackState.currentStep;
+    for (const checkpoint of this.recording.checkpoints) {
+      if (checkpoint.stepIndex > currentStep) {
+        return checkpoint;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get previous checkpoint
+   */
+  getPreviousCheckpoint() {
+    const currentStep = this.playbackState.currentStep;
+    let lastCheckpoint;
+    for (const checkpoint of this.recording.checkpoints) {
+      if (checkpoint.stepIndex < currentStep) {
+        lastCheckpoint = checkpoint;
+      } else {
+        break;
+      }
+    }
+    return lastCheckpoint;
+  }
+  /**
+   * Pause playback
+   */
+  pause(reason) {
+    this.playbackState.isPaused = true;
+    this.playbackState.pauseReason = reason;
+    this.emit("paused", reason ?? "Manual pause");
+  }
+  /**
+   * Resume playback
+   */
+  resume() {
+    this.playbackState.isPaused = false;
+    this.playbackState.pauseReason = void 0;
+    this.emit("resumed");
+  }
+  /**
+   * Get current step
+   */
+  getCurrentStep() {
+    const index = this.playbackState.currentStep;
+    if (index >= 0 && index < this.recording.steps.length) {
+      return this.recording.steps[index];
+    }
+    return void 0;
+  }
+  /**
+   * Get current state
+   */
+  getCurrentState() {
+    return deepClone(this.playbackState.state);
+  }
+  /**
+   * Get playback state
+   */
+  getPlaybackState() {
+    return { ...this.playbackState };
+  }
+  /**
+   * Check if at beginning
+   */
+  isAtBeginning() {
+    return this.playbackState.currentStep <= 0;
+  }
+  /**
+   * Check if at end
+   */
+  isAtEnd() {
+    return this.playbackState.currentStep >= this.recording.steps.length - 1;
+  }
+  /**
+   * Get progress percentage
+   */
+  getProgress() {
+    if (this.recording.steps.length === 0) {
+      return 100;
+    }
+    return (this.playbackState.currentStep + 1) / this.recording.steps.length * 100;
+  }
+  /**
+   * Apply a step to state
+   */
+  applyStep(state, step) {
+    const newState = deepClone(state);
+    switch (step.type) {
+      case "input":
+        newState.messages.push({
+          role: "user",
+          content: String(step.input)
+        });
+        break;
+      case "response":
+        newState.messages.push({
+          role: "assistant",
+          content: String(step.output)
+        });
+        break;
+      case "tool-call":
+        if (step.toolCall) {
+          newState.messages.push({
+            role: "assistant",
+            content: `[Tool Call: ${step.toolCall.name}]`
+          });
+        }
+        break;
+      case "tool-result":
+        if (step.toolCall) {
+          newState.messages.push({
+            role: "tool",
+            content: String(step.toolCall.result)
+          });
+        }
+        break;
+      case "memory-write":
+        if (step.output && typeof step.output === "object") {
+          Object.assign(newState.memory, step.output);
+        }
+        break;
+    }
+    return newState;
+  }
+  /**
+   * Rebuild state at a specific step
+   */
+  rebuildStateAt(targetStep) {
+    let startStep = -1;
+    let state = deepClone(this.recording.initialState);
+    for (let i = targetStep; i >= -1; i--) {
+      const cached = this.stateHistory.get(i);
+      if (cached) {
+        startStep = i;
+        state = deepClone(cached);
+        break;
+      }
+    }
+    for (const checkpoint of this.recording.checkpoints) {
+      if (checkpoint.stepIndex > startStep && checkpoint.stepIndex <= targetStep) {
+        startStep = checkpoint.stepIndex;
+        state = deepClone(checkpoint.state);
+      }
+    }
+    for (let i = startStep + 1; i <= targetStep; i++) {
+      if (i >= 0 && i < this.recording.steps.length) {
+        state = this.applyStep(state, this.recording.steps[i]);
+      }
+    }
+    return state;
+  }
+  /**
+   * Check pause conditions
+   */
+  checkPauseConditions(step) {
+    if (this.config.pauseOnDecisions && step.type === "decision") {
+      this.pause("Decision point");
+    }
+    if (this.config.pauseOnErrors && step.error) {
+      this.pause("Error occurred");
+    }
+    if (this.config.pauseOnToolCalls && step.type === "tool-call") {
+      this.pause("Tool call");
+    }
+  }
+  /**
+   * Get all checkpoints
+   */
+  getCheckpoints() {
+    return this.recording.checkpoints;
+  }
+  /**
+   * Get steps count
+   */
+  get stepsCount() {
+    return this.recording.steps.length;
+  }
+};
+function createReplayController(recording, session, config) {
+  return new ReplayController(recording, session, config);
+}
+
+// src/replay/ReplayEngine.ts
+var DEFAULT_CONFIG = {
+  speedMultiplier: 1,
+  pauseOnDecisions: false,
+  pauseOnErrors: true,
+  pauseOnToolCalls: false,
+  executeTools: false,
+  executeLLM: false,
+  compareResults: true,
+  trackDifferences: true
+};
+var ReplayEngine = class extends EventEmitter {
+  config;
+  sessions = /* @__PURE__ */ new Map();
+  currentSession;
+  stateRestorer;
+  controller;
+  isRunning = false;
+  constructor(config) {
+    super();
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+    this.stateRestorer = new StateRestorer();
+  }
+  /**
+   * Start a replay session
+   */
+  start(recording, options) {
+    const session = {
+      id: generateId("replay"),
+      recordingId: recording.id,
+      state: "idle",
+      currentStep: options?.startStep ?? 0,
+      totalSteps: recording.steps.length,
+      speed: options?.speed ?? "normal",
+      startedAt: now(),
+      modifications: options?.modifications ?? [],
+      differences: []
+    };
+    this.sessions.set(session.id, session);
+    this.currentSession = session;
+    this.controller = new ReplayController(recording, session, {
+      ...this.config,
+      speedMultiplier: this.getSpeedMultiplier(session.speed)
+    });
+    this.controller.on("step:replayed", (step, state) => {
+      this.emit("step:replayed", step, state);
+    });
+    this.controller.on("paused", () => {
+      session.state = "paused";
+      this.emit("replay:paused", session);
+    });
+    this.controller.on("error", (error) => {
+      this.emit("error", error);
+    });
+    this.emit("replay:started", session);
+    this.runReplay(recording, session, options).catch((error) => {
+      this.emit("error", error);
+    });
+    return session;
+  }
+  /**
+   * Run the replay loop
+   */
+  async runReplay(recording, session, options) {
+    this.isRunning = true;
+    const startStep = options?.startStep ?? 0;
+    const endStep = options?.endStep ?? recording.steps.length - 1;
+    let currentState = this.stateRestorer.restore(
+      recording,
+      startStep > 0 ? startStep - 1 : 0
+    );
+    const replayedSteps = [];
+    const differences = [];
+    for (let i = startStep; i <= endStep && this.isRunning; i++) {
+      while (session.state === "paused" && this.isRunning) {
+        await sleep(100);
+      }
+      if (!this.isRunning) {
+        break;
+      }
+      const originalStep = recording.steps[i];
+      let step = deepClone(originalStep);
+      const modification = options?.modifications?.find(
+        (m) => m.stepIndex === i
+      );
+      if (modification) {
+        step = this.applyModification(step, modification);
+        this.emit("step:modified", originalStep, step);
+      }
+      const result2 = await this.executeStep(step, currentState, options);
+      if (this.config.trackDifferences && result2.executed) {
+        const stepDiffs = this.compareResults(originalStep, result2.step);
+        if (stepDiffs.length > 0) {
+          differences.push(...stepDiffs);
+          session.differences = differences;
+          this.emit("divergence:detected", stepDiffs);
+        }
+      }
+      replayedSteps.push(result2.step);
+      currentState = result2.state;
+      session.currentStep = i;
+      const delay = this.getStepDelay(step, session.speed);
+      if (delay > 0) {
+        await sleep(delay);
+      }
+      this.emit("step:replayed", result2.step, currentState);
+      if (this.shouldPause(step)) {
+        session.state = "paused";
+        this.emit("replay:paused", session);
+      }
+    }
+    const result = {
+      sessionId: session.id,
+      recordingId: recording.id,
+      success: this.isRunning,
+      stepsReplayed: replayedSteps.length,
+      differences,
+      finalState: currentState,
+      startedAt: session.startedAt,
+      completedAt: now(),
+      durationMs: now() - session.startedAt
+    };
+    session.state = "completed";
+    session.completedAt = result.completedAt;
+    this.isRunning = false;
+    this.emit("replay:completed", result);
+  }
+  /**
+   * Execute a step during replay
+   */
+  async executeStep(step, state, options) {
+    const newStep = deepClone(step);
+    let newState = deepClone(state);
+    let executed = false;
+    if (step.type === "tool-call" && options?.executeTools && options?.onToolCall) {
+      try {
+        const result = await options.onToolCall(step);
+        newStep.toolCall = {
+          ...newStep.toolCall,
+          result,
+          success: true
+        };
+        executed = true;
+      } catch (error) {
+        newStep.toolCall = {
+          ...newStep.toolCall,
+          result: error.message,
+          success: false
+        };
+        executed = true;
+      }
+    }
+    if (step.type === "response" && options?.executeLLM && options?.onLLMCall) {
+      try {
+        const response = await options.onLLMCall(step);
+        newStep.output = response;
+        executed = true;
+      } catch (error) {
+        newStep.error = {
+          name: "LLMError",
+          message: error.message
+        };
+        executed = true;
+      }
+    }
+    newState = this.updateState(newState, newStep);
+    return { step: newStep, state: newState, executed };
+  }
+  /**
+   * Update state based on step
+   */
+  updateState(state, step) {
+    const newState = deepClone(state);
+    if (step.type === "input") {
+      newState.messages.push({
+        role: "user",
+        content: String(step.input)
+      });
+    } else if (step.type === "response") {
+      newState.messages.push({
+        role: "assistant",
+        content: String(step.output)
+      });
+    }
+    return newState;
+  }
+  /**
+   * Apply a modification to a step
+   */
+  applyModification(step, modification) {
+    const modified = deepClone(step);
+    switch (modification.type) {
+      case "skip":
+        modified.metadata = {
+          ...modified.metadata,
+          skipped: true
+        };
+        break;
+      case "modify":
+        if (modification.data) {
+          Object.assign(modified, modification.data);
+        }
+        break;
+      case "insert":
+        break;
+      case "replace":
+        if (modification.data) {
+          return {
+            ...modified,
+            ...modification.data
+          };
+        }
+        break;
+    }
+    return modified;
+  }
+  /**
+   * Compare original and replayed results
+   */
+  compareResults(original, replayed) {
+    const differences = diff(original, replayed);
+    return toReplayDifferences(differences, original.index);
+  }
+  /**
+   * Check if should pause on this step
+   */
+  shouldPause(step) {
+    if (this.config.pauseOnDecisions && step.type === "decision") {
+      return true;
+    }
+    if (this.config.pauseOnErrors && step.error) {
+      return true;
+    }
+    if (this.config.pauseOnToolCalls && step.type === "tool-call") {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get speed multiplier
+   */
+  getSpeedMultiplier(speed) {
+    switch (speed) {
+      case "slow":
+        return 0.5;
+      case "normal":
+        return 1;
+      case "fast":
+        return 2;
+      case "instant":
+        return 0;
+      default:
+        return 1;
+    }
+  }
+  /**
+   * Get delay for step based on speed
+   */
+  getStepDelay(step, speed) {
+    if (speed === "instant") {
+      return 0;
+    }
+    const baseDelay = step.durationMs ?? 100;
+    const multiplier = this.getSpeedMultiplier(speed);
+    return baseDelay / multiplier;
+  }
+  /**
+   * Pause current replay
+   */
+  pause() {
+    if (this.currentSession && this.currentSession.state !== "paused" && this.currentSession.state !== "stopped") {
+      this.currentSession.state = "paused";
+      this.emit("replay:paused", this.currentSession);
+    }
+  }
+  /**
+   * Resume current replay
+   */
+  resume() {
+    if (this.currentSession && this.currentSession.state === "paused") {
+      this.currentSession.state = "playing";
+      this.emit("replay:resumed", this.currentSession);
+    }
+  }
+  /**
+   * Stop current replay
+   */
+  stop() {
+    this.isRunning = false;
+    if (this.currentSession) {
+      this.currentSession.state = "stopped";
+      this.emit("replay:stopped", this.currentSession);
+    }
+  }
+  /**
+   * Set replay speed
+   */
+  setSpeed(speed) {
+    if (this.currentSession) {
+      this.currentSession.speed = speed;
+    }
+  }
+  /**
+   * Jump to step
+   */
+  jumpToStep(stepIndex) {
+    if (!this.currentSession) {
+      return;
+    }
+    this.currentSession.currentStep = stepIndex;
+  }
+  /**
+   * Get current session
+   */
+  getSession() {
+    return this.currentSession;
+  }
+  /**
+   * Get session by ID
+   */
+  getSessionById(id) {
+    return this.sessions.get(id);
+  }
+  /**
+   * Get all sessions
+   */
+  getSessions() {
+    return Array.from(this.sessions.values());
+  }
+};
+function createReplayEngine(config) {
+  return new ReplayEngine(config);
+}
+
+export { ReplayController, ReplayEngine, StateRestorer, createReplayController, createReplayEngine, createStateRestorer };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map