@ddwang/magnitude-core 0.3.1-ddwang.2 → 0.3.1-ddwang.3

package/dist/index.mjs

@@ -1,11 +1,13 @@
 import { setLogLevel } from '@boundaryml/baml/logging';
-import { BamlRuntime, BamlCtxManager, Image as Image$1, ClientRegistry, toBamlError, BamlAbortError, Collector, BamlStream, ThrowIfVersionMismatch, BamlValidationError } from '@boundaryml/baml';
+import baml, { BamlRuntime, BamlCtxManager, ClientRegistry, toBamlError, BamlAbortError, Collector, BamlStream, ThrowIfVersionMismatch, BamlValidationError } from '@boundaryml/baml';
 import pino from 'pino';
 import EventEmitter from 'eventemitter3';
 import z$1, { z, ZodObject } from 'zod';
 export { z } from 'zod';
 import sharp from 'sharp';
 import { AsyncLocalStorage } from 'node:async_hooks';
+import crypto$1, { randomUUID, createHash as createHash$1 } from 'node:crypto';
+import { performance } from 'node:perf_hooks';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
@@ -23,7 +25,6 @@ import { TypeBuilder as TypeBuilder$1 } from '@boundaryml/baml/type_builder';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 import { chromium } from 'playwright';
 import objectHash from 'object-hash';
-import crypto$1, { createHash as createHash$1 } from 'node:crypto';
 import { partitionHtml, serializeToMarkdown } from 'magnitude-extract';
 
 const fileMap = {
@@ -735,7 +736,7 @@ class Image {
   }
   async toBaml() {
     const { format, base64 } = await this.toJson();
-    return Image$1.fromBase64(`image/${format}`, base64);
+    return baml.Image.fromBase64(`image/${format}`, base64);
   }
   async saveToFile(filepath) {
     await this.img.clone().toFile(filepath);
@@ -820,7 +821,7 @@ async function buildXmlPartsRecursive(data, indentLevel, partsList, isInsideList
     }
     return;
   }
-  if (data instanceof Image$1) {
+  if (data instanceof baml.Image) {
     partsList.push(data);
     return;
   }
@@ -858,7 +859,7 @@ async function buildXmlPartsRecursive(data, indentLevel, partsList, isInsideList
         }
       }
       if (currentStr) mergedValueParts.push(currentStr);
-      if (mergedValueParts.length === 1 && mergedValueParts[0] instanceof Image$1) {
+      if (mergedValueParts.length === 1 && mergedValueParts[0] instanceof baml.Image) {
         partsList.push(`${indent}<${tagName}>`);
         partsList.push(mergedValueParts[0]);
         partsList.push(`</${tagName}>`);
@@ -924,7 +925,7 @@ async function buildJsonPartsRecursive(data, partsList, indent, currentLevel = 0
     }
     return;
   }
-  if (data instanceof Image$1) {
+  if (data instanceof baml.Image) {
     partsList.push(data);
     return;
   }
@@ -1122,20 +1123,35 @@ class OperationDeadlineError extends AgentError {
 }
 class AgentBusyError extends AgentError {
   constructor() {
-    super("Agent has an active operation; await whenIdle() before reusing it", { variant: "busy" });
+    super("Agent has pending work; await whenIdle() before reusing it", { variant: "busy" });
     this.name = "AgentBusyError";
   }
 }
 
+function attachOperationDiagnostics(error, diagnostics) {
+  if (!(error instanceof Error)) return;
+  try {
+    if (!("operation" in error)) Object.defineProperty(error, "operation", { value: diagnostics, enumerable: true });
+  } catch {
+  }
+}
 const operations = new AsyncLocalStorage();
 class Operation {
-  constructor(owner, options) {
+  constructor(owner, options, kind = "exec", onUpdate) {
     this.owner = owner;
-    this.options = options;
+    this.kind = kind;
+    this.onUpdate = onUpdate;
     if (options.deadline !== void 0 && !Number.isFinite(options.deadline)) {
       throw new TypeError("deadline must be a finite Unix timestamp in milliseconds");
     }
     this.deadline = options.deadline;
+    this.externalSignal = options.signal;
+    this.signal.addEventListener("abort", () => {
+      this.cancelled = performance.now();
+      this.outcome = this.signal.reason instanceof OperationDeadlineError ? "deadline" : "cancelled";
+      attachOperationDiagnostics(this.signal.reason, this.snapshot());
+      this.publish();
+    }, { once: true });
     options.signal?.addEventListener("abort", this.externalAbort, { once: true });
     if (options.signal?.aborted) this.externalAbort();
     this.scheduleDeadline();
@@ -1145,7 +1161,19 @@ class Operation {
   closed = false;
   signal = this.controller.signal;
   deadline;
-  externalAbort = () => this.cancel(this.options.signal?.reason);
+  externalSignal;
+  externalAbort = () => this.cancel(this.externalSignal?.reason);
+  id = randomUUID();
+  startedAt = Date.now();
+  started = performance.now();
+  finished;
+  cancelled;
+  idle;
+  announced = false;
+  outcome;
+  lastAction;
+  timings = {};
+  spans = /* @__PURE__ */ new Set();
   scheduleDeadline() {
     if (this.deadline === void 0 || this.signal.aborted) return;
     const remaining = this.deadline - Date.now();
@@ -1153,28 +1181,106 @@ class Operation {
     else this.timer = setTimeout(() => this.scheduleDeadline(), Math.min(remaining, 2147483647));
   }
   cancel(reason) {
+    if (this.closed) return;
     clearTimeout(this.timer);
     if (!this.signal.aborted) this.controller.abort(new OperationCancelledError(reason));
   }
   check() {
-    if (!this.signal.aborted && this.deadline !== void 0 && Date.now() >= this.deadline) {
+    if (this.signal.aborted) throw this.signal.reason;
+    if (this.closed) throw new OperationCancelledError("Operation already finished");
+    if (this.deadline !== void 0 && Date.now() >= this.deadline) {
       this.controller.abort(new OperationDeadlineError(this.deadline));
     }
     if (this.signal.aborted) throw this.signal.reason;
-    if (this.closed) throw new OperationCancelledError("Operation already finished");
   }
   run(fn) {
     return operations.run(this, fn);
   }
+  announce() {
+    this.announced = true;
+    this.publish();
+  }
+  publish() {
+    if (!this.announced) return;
+    try {
+      this.onUpdate?.(this.snapshot());
+    } catch {
+      logger.warn("Operation diagnostic listener failed");
+    }
+  }
+  snapshot() {
+    const now = this.finished ?? performance.now();
+    const timings = {};
+    for (const [phase2, timing] of Object.entries(this.timings)) timings[phase2] = { ...timing };
+    let phase = "preparing";
+    for (const span of this.spans) {
+      phase = span.phase;
+      const timing = timings[phase] ??= { count: 0, totalMs: 0 };
+      timing.count++;
+      timing.totalMs += now - span.started;
+    }
+    return {
+      id: this.id,
+      kind: this.kind,
+      status: this.finished !== void 0 ? "finished" : this.cancelled !== void 0 ? "draining" : "running",
+      outcome: this.outcome,
+      phase,
+      startedAt: this.startedAt,
+      elapsedMs: now - this.started,
+      ...this.cancelled !== void 0 && this.finished !== void 0 ? { cancellationToDrainMs: this.finished - this.cancelled } : {},
+      ...this.cancelled !== void 0 && this.idle !== void 0 ? { cancellationToIdleMs: this.idle - this.cancelled } : {},
+      ...this.lastAction ? { lastAction: { ...this.lastAction } } : {},
+      timings
+    };
+  }
+  beginPhase(phase) {
+    if (this.closed) return () => {
+    };
+    const span = { phase, started: performance.now() };
+    this.spans.add(span);
+    this.publish();
+    return () => {
+      if (!this.spans.delete(span)) return;
+      const timing = this.timings[phase] ??= { count: 0, totalMs: 0 };
+      timing.count++;
+      timing.totalMs += performance.now() - span.started;
+      this.publish();
+    };
+  }
+  prepareAction(name) {
+    this.lastAction = { index: (this.lastAction?.index ?? 0) + 1, name, state: "pending" };
+    this.publish();
+  }
+  actionState(state) {
+    if (this.lastAction) this.lastAction.state = state;
+  }
+  fail(error) {
+    this.outcome ??= "failed";
+    attachOperationDiagnostics(error, this.snapshot());
+  }
+  finish() {
+    this.finished = performance.now();
+    this.outcome ??= "succeeded";
+    this.dispose();
+    this.publish();
+  }
+  markIdle() {
+    if (this.idle !== void 0) return;
+    this.idle = performance.now();
+    this.publish();
+  }
   dispose() {
     this.closed = true;
     clearTimeout(this.timer);
-    this.options.signal?.removeEventListener("abort", this.externalAbort);
+    this.externalSignal?.removeEventListener("abort", this.externalAbort);
   }
 }
 function currentOperation() {
   return operations.getStore();
 }
+function withoutOperation(fn) {
+  return operations.exit(fn);
+}
 function checkOperation() {
   currentOperation()?.check();
 }
@@ -1183,6 +1289,19 @@ function operationOptions() {
   const operation = currentOperation();
   return { signal: operation?.signal, deadline: operation?.deadline };
 }
+function beginOperationPhase(phase) {
+  return currentOperation()?.beginPhase(phase) ?? (() => {
+  });
+}
+async function measureOperation(phase, fn) {
+  const finish = beginOperationPhase(phase);
+  try {
+    checkOperation();
+    return await fn();
+  } finally {
+    finish();
+  }
+}
 async function drainAll(promises) {
   const results = await Promise.allSettled(promises);
   const failure = results.find((result) => result.status === "rejected");
@@ -2801,7 +2920,7 @@ async function retryOnError(fnToRetry, retryOptions) {
         }
       }
     }
-    if (attempt < options.retryLimit) await operationSleep(options.delayMs);
+    if (attempt < options.retryLimit) await measureOperation("retry", () => operationSleep(options.delayMs));
   }
   throw lastError;
 }
@@ -3432,7 +3551,9 @@ class ModelHarness {
   async _withUsage(invoke) {
     checkOperation();
     const collector = new Collector("model-call");
+    const finish = beginOperationPhase("model");
     try {
+      checkOperation();
       try {
         return await invoke(collector);
       } finally {
@@ -3455,6 +3576,7 @@ class ModelHarness {
         }
       }
     } finally {
+      finish();
       for (const log of collector.logs) {
         for (const call of log.calls) {
           try {
@@ -3735,7 +3857,7 @@ class MultiModelHarness {
   uniqueModels = [];
   events = new EventEmitter();
   constructor(clients) {
-    const sortedClients = clients.toSorted((a, b) => (b.roles ? b.roles.length : 9999) - (a.roles ? a.roles.length : 9999));
+    const sortedClients = [...clients].sort((a, b) => (b.roles ? b.roles.length : 9999) - (a.roles ? a.roles.length : 9999));
     for (const client of sortedClients) {
       const harness = new ModelHarness({ llm: client });
       this.uniqueModels.push(harness);
@@ -3754,7 +3876,7 @@ class MultiModelHarness {
     }
   }
   async setup() {
-    await Promise.all(this.uniqueModels.map((model) => model.setup()));
+    await drainAll(this.uniqueModels.map((model) => model.setup()));
   }
   describe() {
     return this.uniqueModels[0].describeModel();
@@ -3808,8 +3930,14 @@ class Agent {
   _paused = false;
   _pauseResolve = null;
   activeOperation;
+  latestOperation;
   idle = Promise.resolve();
-  stopped = false;
+  resolveIdle;
+  pendingWork = 0;
+  lifecycleTail = Promise.resolve();
+  lifecycleRequest;
+  lifecycleState = "new";
+  telemetryStarted = false;
   latestTaskMemory;
   // | null = null;
   constructor(baseConfig = {}) {
@@ -3864,17 +3992,57 @@ class Agent {
     return connector;
   }
   async start() {
-    checkOperation();
-    if (this.busy) throw new AgentBusyError();
-    if (this.options.telemetry) telemetrifyAgent(this);
-    await this.models.setup();
-    logger.info("Agent: Starting connectors...");
-    for (const connector of this.connectors) {
-      if (connector.onStart) await connector.onStart();
+    return this.scheduleLifecycle("start", async () => {
+      if (this.lifecycleState === "ready") return;
+      this.lifecycleState = "starting";
+      if (this.options.telemetry && !this.telemetryStarted) {
+        telemetrifyAgent(this);
+        this.telemetryStarted = true;
+      }
+      try {
+        await this.models.setup();
+        for (const connector of this.connectors) await connector.onStart?.();
+      } catch (error) {
+        await this.stopConnectors();
+        this.lifecycleState = "stopped";
+        throw error;
+      }
+      this.lifecycleState = "ready";
+      this.events.emit("start");
+    });
+  }
+  get lifecycle() {
+    return this.lifecycleState;
+  }
+  beginWork() {
+    if (this.pendingWork++ === 0) this.idle = new Promise((resolve) => {
+      this.resolveIdle = resolve;
+    });
+  }
+  endWork() {
+    if (--this.pendingWork === 0) {
+      const resolve = this.resolveIdle;
+      this.resolveIdle = void 0;
+      withoutOperation(() => this.latestOperation?.markIdle());
+      resolve?.();
     }
-    this.events.emit("start");
-    this.stopped = false;
-    logger.info("Agent: All connectors started.");
+  }
+  scheduleLifecycle(kind, fn) {
+    checkOperation();
+    if (kind === "start" && this.activeOperation) throw new AgentBusyError();
+    if (this.lifecycleRequest?.kind === kind) return this.lifecycleRequest.promise;
+    this.beginWork();
+    return withoutOperation(() => {
+      const promise = this.lifecycleTail.then(fn).finally(() => {
+        if (this.lifecycleRequest?.promise === promise) this.lifecycleRequest = void 0;
+        this.endWork();
+      });
+      this.lifecycleRequest = { kind, promise };
+      this.lifecycleTail = promise.catch(() => {
+      });
+      if (kind === "stop") this.activeOperation?.cancel("Agent stopped");
+      return promise;
+    });
   }
   identifyAction(action) {
     const actionDefinition = this.actions.find((def) => def.name === action.variant);
@@ -3885,22 +4053,31 @@ class Agent {
   }
   /** True until underlying work settles, including after a cancelled caller returns. */
   get busy() {
-    return this.activeOperation !== void 0;
+    return this.pendingWork > 0;
   }
   whenIdle() {
     return this.idle;
   }
-  async runOperation(options, fn) {
+  /** A payload-free snapshot of the active or most recent operation. */
+  get operation() {
+    return this.latestOperation?.snapshot();
+  }
+  async runOperation(options, fn, kind = "exec") {
     const inherited = currentOperation();
     if (inherited?.owner === this) inherited.check();
-    if (this.busy) throw new AgentBusyError();
-    if (this.stopped) throw new AgentError("Agent is stopped; call start() before using it");
-    const operation = new Operation(this, options);
-    this.activeOperation = operation;
-    let markIdle;
-    this.idle = new Promise((resolve) => {
-      markIdle = resolve;
+    if (this.busy) {
+      const error = new AgentBusyError();
+      if (this.activeOperation) attachOperationDiagnostics(error, this.activeOperation.snapshot());
+      throw error;
+    }
+    if (this.lifecycleState === "stopped") throw new AgentError("Agent is stopped; call start() before using it");
+    const operation = new Operation(this, options, kind, (snapshot) => {
+      this.events.emit("operation", snapshot);
     });
+    this.activeOperation = operation;
+    this.latestOperation = operation;
+    this.beginWork();
+    operation.announce();
     const worker = operation.run(async () => {
       operation.check();
       try {
@@ -3909,10 +4086,13 @@ class Agent {
         operation.check();
       }
     });
-    const settled = worker.finally(() => {
-      operation.dispose();
+    const settled = worker.catch((error) => {
+      operation.fail(error);
+      throw error;
+    }).finally(() => {
+      operation.finish();
       this.activeOperation = void 0;
-      markIdle();
+      this.endWork();
     });
     return untilAborted(settled, operation.signal);
   }
@@ -3933,6 +4113,9 @@ class Agent {
     if (!parsed.success) {
       throw new AgentError(`Generated action '${action.variant}' violates input schema: ${parsed.error.message}`, { adaptable: true });
     }
+    const operation = currentOperation();
+    operation?.prepareAction(actionDefinition.name);
+    checkOperation();
     const memoryOnly = memoryActions.includes(actionDefinition);
     if (!memoryOnly) for (const connector of this.connectors) {
       await connector.beforeAction?.(action, operationOptions());
@@ -3940,9 +4123,18 @@ class Agent {
     }
     this.events.emit("actionStarted", action);
     checkOperation();
-    const data = await actionDefinition.resolver(
-      { input: parsed.data, agent: this, memory, ...operationOptions() }
-    );
+    const data = await measureOperation("action", async () => {
+      const options = operationOptions();
+      operation?.actionState("started");
+      try {
+        const result = await actionDefinition.resolver({ input: parsed.data, agent: this, memory, ...options });
+        operation?.actionState("completed");
+        return result;
+      } catch (error) {
+        operation?.actionState("failed");
+        throw error;
+      }
+    });
     checkOperation();
     this.events.emit("actionDone", action);
     checkOperation();
@@ -3965,21 +4157,22 @@ class Agent {
     return data;
   }
   async _recordConnectorObservations(memory) {
-    checkOperation();
-    for (const connector of this.connectors) {
-      const connObservations = connector.collectObservations ? await connector.collectObservations(operationOptions()) : [];
-      checkOperation();
-      for (const obs of connObservations) {
-        memory.recordObservation(obs);
+    return measureOperation("observations", async () => {
+      for (const connector of this.connectors) {
+        const connObservations = connector.collectObservations ? await connector.collectObservations(operationOptions()) : [];
+        checkOperation();
+        for (const obs of connObservations) {
+          memory.recordObservation(obs);
+        }
       }
-    }
-    this.events.emit("observationsRecorded");
+      this.events.emit("observationsRecorded");
+    });
   }
   get memory() {
     return this.latestTaskMemory;
   }
   async act(taskOrSteps, options = {}) {
-    return this.runOperation(options, () => this._runAct(taskOrSteps, options));
+    return this.runOperation(options, () => this._runAct(taskOrSteps, options), "act");
   }
   async _runAct(taskOrSteps, options) {
     const instructions = [
@@ -4012,28 +4205,25 @@ class Agent {
     })(task);
   }
   async _buildContext(memory, options) {
-    checkOperation();
-    const messages = await memory.render(options);
-    checkOperation();
-    const connectorInstructions = [];
-    for (const connector of this.connectors) {
-      if (connector.getInstructions) {
-        const instructions = await connector.getInstructions(operationOptions());
-        checkOperation();
-        if (instructions) {
-          connectorInstructions.push({
-            connectorId: connector.id,
-            instructions
-          });
+    return measureOperation("context", async () => {
+      const messages = await memory.render(options);
+      checkOperation();
+      const connectorInstructions = [];
+      for (const connector of this.connectors) {
+        if (connector.getInstructions) {
+          const instructions = await connector.getInstructions(operationOptions());
+          checkOperation();
+          if (instructions) {
+            connectorInstructions.push({ connectorId: connector.id, instructions });
+          }
         }
       }
-    }
-    return {
-      instructions: memory.instructions,
-      observationContent: messages,
-      //observationContent: content,
-      connectorInstructions
-    };
+      return {
+        instructions: memory.instructions,
+        observationContent: messages,
+        connectorInstructions
+      };
+    });
   }
   async _act(description, memory, options = {}) {
     checkOperation();
@@ -4122,7 +4312,7 @@ class Agent {
       await this._recordConnectorObservations(this.latestTaskMemory);
       const memoryContext = await this._buildContext(this.memory, options);
       return await this.models.query(memoryContext, query, schema);
-    });
+    }, "query");
   }
   async queueDone() {
     checkOperation();
@@ -4136,9 +4326,12 @@ class Agent {
     if (!this._paused) return;
     logger.info("Agent: Paused");
     try {
-      await untilAborted(new Promise((resolve) => {
-        this._pauseResolve = resolve;
-      }), currentOperation()?.signal);
+      await measureOperation("paused", async () => {
+        if (!this._paused) return;
+        await untilAborted(new Promise((resolve) => {
+          this._pauseResolve = resolve;
+        }), currentOperation()?.signal);
+      });
     } finally {
       this._pauseResolve = null;
     }
@@ -4161,15 +4354,19 @@ class Agent {
     return this._paused;
   }
   async stop() {
-    checkOperation();
-    this.stopped = true;
-    this.activeOperation?.cancel("Agent stopped");
-    this.doneActing = true;
-    if (this._paused) {
+    return this.scheduleLifecycle("stop", async () => {
+      if (this.lifecycleState === "stopped") return;
+      this.lifecycleState = "stopping";
+      this.doneActing = true;
       this._paused = false;
       this._pauseResolve?.();
       this._pauseResolve = null;
-    }
+      await this.stopConnectors();
+      this.lifecycleState = "stopped";
+      this.events.emit("stop");
+    });
+  }
+  async stopConnectors() {
     logger.info("Agent: Stopping connectors...");
     for (const connector of this.connectors) {
       try {
@@ -4178,7 +4375,6 @@ class Agent {
         logger.warn(`Agent: Error stopping connector ${connector.id}: ${error instanceof Error ? error.message : String(error)}`);
       }
     }
-    this.events.emit("stop");
     logger.info("Agent: All connectors stopped.");
     logger.info("Agent: Stopped successfully.");
   }
@@ -4485,14 +4681,15 @@ function parseTypeContent(content) {
 }
 
 class CursorVisual {
+  constructor(animate = true) {
+    this.animate = animate;
+  }
   /**
    * Manages the visual indicator for actions on a page
    */
   page;
   visualElementId = "action-visual-indicator";
   lastPosition = null;
-  constructor() {
-  }
   async setActivePage(page) {
     this.page = page;
     page.on("load", async () => {
@@ -4507,9 +4704,11 @@ class CursorVisual {
     );
   }
   async move(x, y) {
-    this.lastPosition = { x, y };
-    await this._drawVisual(x, y, false);
-    await operationSleep(300);
+    await measureOperation("cursor", async () => {
+      this.lastPosition = { x, y };
+      await this._drawVisual(x, y, false);
+      if (this.animate) await operationSleep(300);
+    });
   }
   async setupOnPage() {
     if (this.lastPosition) {
@@ -4520,7 +4719,7 @@ class CursorVisual {
   async _drawVisual(x, y, showClickEffect) {
     try {
       await this.page.evaluate(
-        ({ x: x2, y: y2, id, showClickEffect: showClickEffect2 }) => {
+        ({ x: x2, y: y2, id, showClickEffect: showClickEffect2, animate }) => {
           const viewportX = x2;
           const viewportY = y2;
           const docX = x2 + window.scrollX;
@@ -4562,7 +4761,6 @@ class CursorVisual {
             pointerElement.style.height = "32px";
             pointerElement.style.zIndex = "2147483647";
             pointerElement.style.pointerEvents = "none";
-            pointerElement.style.transition = "left 0.3s cubic-bezier(0.25, 0.1, 0.25, 1), top 0.3s cubic-bezier(0.25, 0.1, 0.25, 1)";
             const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
             svg.setAttribute("width", "32");
             svg.setAttribute("height", "32");
@@ -4585,11 +4783,12 @@ class CursorVisual {
             pointerElement.appendChild(svg);
             document.body.appendChild(pointerElement);
           }
+          pointerElement.style.transition = animate ? "left 0.3s cubic-bezier(0.25, 0.1, 0.25, 1), top 0.3s cubic-bezier(0.25, 0.1, 0.25, 1)" : "none";
           pointerElement.style.left = `${viewportX}px`;
           pointerElement.style.top = `${viewportY}px`;
           pointerElement.style.transform = "translate(-1px, -3px)";
         },
-        { x, y, id: this.visualElementId, showClickEffect }
+        { x, y, id: this.visualElementId, showClickEffect, animate: this.animate }
       );
     } catch (error) {
       logger.trace(`Failed to draw visual: ${error.message}`);
@@ -5067,12 +5266,13 @@ class ActionVisualizer {
     this.context = context;
     this.options = {
       showCursor: options.showCursor ?? true,
+      animateCursor: options.animateCursor ?? true,
       showHoverCircle: options.showHoverCircle ?? false,
       showClickRipple: options.showClickRipple ?? true,
       showDragLine: options.showDragLine ?? false,
       showTypeEffects: options.showTypeEffects ?? true
     };
-    this.cursor = new CursorVisual();
+    this.cursor = new CursorVisual(this.options.animateCursor);
     this.mouseEffects = new MouseEffectVisual(this.options);
     this.typeEffects = new TypeEffectVisual();
   }
@@ -5080,18 +5280,18 @@ class ActionVisualizer {
   }
   async setActivePage(page) {
     this.page = page;
-    await this.cursor.setActivePage(page);
+    if (this.options.showCursor) await this.cursor.setActivePage(page);
     await this.mouseEffects.setActivePage(page);
     await this.typeEffects.setActivePage(page);
   }
   async moveVirtualCursor(x, y) {
-    await this.cursor.move(x, y);
+    if (this.options.showCursor) await this.cursor.move(x, y);
   }
   async hideAll() {
-    await this.cursor.hide();
+    if (this.options.showCursor) await this.cursor.hide();
   }
   async showAll() {
-    await this.cursor.show();
+    if (this.options.showCursor) await this.cursor.show();
   }
 }
 
@@ -5921,33 +6121,33 @@ class WebHarness {
     return this.tabs.getActivePage();
   }
   async screenshot(options = {}) {
-    let dpr;
-    let buffer;
-    const retries = 3;
-    for (let attempt = 0; attempt <= retries; attempt++) {
-      checkOperation();
-      try {
-        dpr = await this.page.evaluate(() => window.devicePixelRatio);
-        checkOperation();
-        buffer = await this.page.screenshot({ type: "png", ...options });
+    return measureOperation("screenshot", async () => {
+      let dpr;
+      let buffer;
+      const retries = 3;
+      for (let attempt = 0; attempt <= retries; attempt++) {
         checkOperation();
-        break;
-      } catch (err) {
-        checkOperation();
-        const error = err;
-        if (error.message.includes("Target page, context or browser has been closed")) {
-          throw new Error("Attempted to take screenshot but page, context or browser is closed");
-        }
-        if (attempt >= retries) {
-          throw new Error(`Unable to capture screenshot after retries, error: ${error.message}`);
+        try {
+          dpr = await this.page.evaluate(() => window.devicePixelRatio);
+          checkOperation();
+          buffer = await this.page.screenshot({ type: "png", ...options });
+          checkOperation();
+          break;
+        } catch (err) {
+          checkOperation();
+          const error = err;
+          if (error.message.includes("Target page, context or browser has been closed")) {
+            throw new Error("Attempted to take screenshot but page, context or browser is closed");
+          }
+          if (attempt >= retries) {
+            throw new Error(`Unable to capture screenshot after retries, error: ${error.message}`);
+          }
         }
       }
-    }
-    const base64data = buffer.toString("base64");
-    const image = Image.fromBase64(base64data);
-    const { width, height } = await image.getDimensions();
-    const rescaledImage = await image.resize(width / dpr, height / dpr);
-    return rescaledImage;
+      const image = Image.fromBase64(buffer.toString("base64"));
+      const { width, height } = await image.getDimensions();
+      return await image.resize(width / dpr, height / dpr);
+    });
   }
   // async goto(url: string) {
   //     // No need to redraw here anymore, the 'load' event listener handles it
@@ -6146,7 +6346,7 @@ class WebHarness {
   }
   async waitForStability(timeout) {
     checkOperation();
-    await this.stability.waitForStability(timeout);
+    await measureOperation("stability", () => this.stability.waitForStability(timeout));
     checkOperation();
   }
   // async applyTransformations() {
@@ -6665,7 +6865,7 @@ async function retry(fn, options = {}) {
           delay * Math.pow(multiplier, attempt),
           maxDelay
         );
-        await operationSleep(currentDelay);
+        await measureOperation("retry", () => operationSleep(currentDelay));
       }
     }
   }
@@ -6799,7 +6999,7 @@ class BrowserConnector {
     this.cancelWait = () => controller.abort(new OperationCancelledError("Browser stopped"));
     this.recovery.waitUntil = Date.now() + duration;
     try {
-      await operationSleep(duration, controller.signal);
+      await measureOperation("cooldown", () => operationSleep(duration, controller.signal));
     } finally {
       operation?.signal.removeEventListener("abort", abort);
       this.cancelWait = void 0;
@@ -7036,10 +7236,10 @@ class BrowserAgent extends Agent {
       this.browserAgentEvents.emit("nav", url);
       checkOperation();
       await this.require(BrowserConnector).getHarness().navigate(url);
-    });
+    }, "nav");
   }
   async extract(instructions, schema, options = {}) {
-    return this.runOperation(options, () => this._extract(instructions, schema));
+    return this.runOperation(options, () => this._extract(instructions, schema), "extract");
   }
   async _extract(instructions, schema) {
     this.browserAgentEvents.emit("extractStarted", instructions, schema);