agentperf 0.1.0 → 0.2.0

package/README.md

@@ -26,10 +26,17 @@ round-trips, actions, success rate — as a markdown table and JSON under
 
 Options: `--lane both|tools|dom` · `--runs N` · `--model <id>` (default
 `gpt-5.6-luna`) · `--base-url <url>` for compatible providers · `--task
-booking|path/to/task.json` · `--max-turns N` · `--out dir`. A task file is
-`{ id, prompt, successPattern, maxTurns }` — the prompt is handed to both
-lanes verbatim and `successPattern` is a regex the page's visible text must
-match when the task is truly done.
+booking|path/to/task.json` · `--max-turns N` · `--max-snapshot-chars N` ·
+`--out dir`. A task file is `{ id, prompt, successPattern, maxTurns }` — the
+prompt is handed to both lanes verbatim and `successPattern` is a regex the
+page's visible text must match when the task is truly done.
+
+`--max-snapshot-chars` caps the accessibility snapshot the DOM lane receives
+per `read_page`. It defaults to 120,000 — deliberately generous, so a heavy
+page reaches the DOM agent whole and it pays for the page in tokens instead
+of being handicapped by truncation. Runs that still hit the cap are flagged
+in the report, because their measured cost is a floor rather than the real
+number.
 
 Instrument your app with [`@agentperf/react`](https://www.npmjs.com/package/@agentperf/react)
 to give it the tools lane.

package/dist/{chunk-BGU3NILX.js → chunk-FCYQOMLH.js}

@@ -1,5 +1,22 @@
 // src/llm.ts
+var RETRY_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var MAX_ATTEMPTS = 5;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function chat(config, messages, tools) {
+  let lastError = "";
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    try {
+      return await chatOnce(config, messages, tools);
+    } catch (error) {
+      lastError = error instanceof Error ? error.message : String(error);
+      const status = Number(/\((\d{3})\)/.exec(lastError)?.[1]);
+      if (!RETRY_STATUSES.has(status) || attempt === MAX_ATTEMPTS) throw error;
+      await sleep(2e3 * 2 ** (attempt - 1));
+    }
+  }
+  throw new Error(lastError);
+}
+async function chatOnce(config, messages, tools) {
   const response = await fetch(`${config.baseUrl}/chat/completions`, {
     method: "POST",
     headers: {
@@ -56,13 +73,8 @@ var TASK_COMPLETE = {
     required: ["summary"]
   }
 };
-async function runAgentLoop(options) {
-  const messages = [
-    { role: "system", content: options.systemPrompt },
-    { role: "user", content: options.taskPrompt }
-  ];
-  const tools = [...options.tools, TASK_COMPLETE];
-  const outcome = {
+function newLoopOutcome() {
+  return {
     turns: 0,
     actions: 0,
     promptTokens: 0,
@@ -70,6 +82,13 @@ async function runAgentLoop(options) {
     claimedDone: false,
     claimSummary: ""
   };
+}
+async function runAgentLoop(options, outcome = newLoopOutcome()) {
+  const messages = [
+    { role: "system", content: options.systemPrompt },
+    { role: "user", content: options.taskPrompt }
+  ];
+  const tools = [...options.tools, TASK_COMPLETE];
   let nudged = false;
   while (outcome.turns < options.maxTurns) {
     outcome.turns += 1;
@@ -153,10 +172,17 @@ var HOST_SHIM = `
 
 // src/lanes.ts
 import { chromium } from "playwright";
-async function verify(page, task) {
+async function matchesSuccess(page, task) {
   const text = await page.evaluate(() => document.body.innerText);
   return new RegExp(task.successPattern).test(text);
 }
+async function assertNotAlreadySatisfied(page, task) {
+  if (await matchesSuccess(page, task)) {
+    throw new Error(
+      `successPattern /${task.successPattern}/ already matches the page before the agent acted \u2014 the task cannot be verified against this URL`
+    );
+  }
+}
 function metrics(lane, task) {
   return {
     lane,
@@ -170,7 +196,7 @@ function metrics(lane, task) {
     totalTokens: 0
   };
 }
-function finish(run, startedMs, loop, verified, claimedDone) {
+function finish(run, startedMs, loop, verified, claimedDone, override = {}) {
   run.wallClockMs = Math.round(performance.now() - startedMs);
   run.turns = loop.turns;
   run.actions = loop.actions;
@@ -178,20 +204,23 @@ function finish(run, startedMs, loop, verified, claimedDone) {
   run.completionTokens = loop.completionTokens;
   run.totalTokens = loop.promptTokens + loop.completionTokens;
   run.success = verified;
+  run.claimSummary = loop.claimSummary || void 0;
   if (!verified) {
-    run.failure = loop.failure ?? (claimedDone ? "model claimed completion but the page does not show the expected outcome" : "run ended without completion");
+    run.failure = override.failure ?? loop.failure ?? (claimedDone ? "model claimed completion but the page does not show the expected outcome" : "run ended without completion");
   }
   return run;
 }
 async function runToolsLane(url, task, llm) {
   const browser = await chromium.launch();
   const run = metrics("tools", task);
+  const outcome = newLoopOutcome();
   const startedMs = performance.now();
   try {
     const context = await browser.newContext();
     await context.addInitScript(HOST_SHIM);
     const page = await context.newPage();
     await page.goto(url, { waitUntil: "load" });
+    await assertNotAlreadySatisfied(page, task);
     await page.waitForFunction(() => window.__agentperf?.listTools().length > 0, void 0, {
       timeout: 15e3
     });
@@ -203,7 +232,7 @@ async function runToolsLane(url, task, llm) {
     }));
     const loop = await runAgentLoop({
       llm,
-      systemPrompt: "You complete tasks on a web page through the page's own tools (WebMCP). Call get_page_state first to orient when it exists. Use only the tools. When the task is fully done, call task_complete.",
+      systemPrompt: "You complete tasks on a web page through the page's own tools (WebMCP). Call get_page_state first to orient when it exists. Use only the tools. Every action returns the updated result. When the task is fully done, call task_complete.",
       taskPrompt: task.prompt,
       tools,
       maxTurns: task.maxTurns,
@@ -215,17 +244,18 @@ async function runToolsLane(url, task, llm) {
           ),
           [name, args]
         );
+        await page.waitForTimeout(SETTLE_MS);
         const text = result.content.map((c) => c.text).join("\n");
         return result.isError ? `TOOL ERROR:
 ${text}` : text;
       }
-    });
-    const verified = loop.claimedDone && await verify(page, task);
+    }, outcome);
+    const verified = loop.claimedDone && await matchesSuccess(page, task);
     return finish(run, startedMs, loop, verified, loop.claimedDone);
   } catch (error) {
-    run.wallClockMs = Math.round(performance.now() - startedMs);
-    run.failure = error instanceof Error ? error.message : String(error);
-    return run;
+    return finish(run, startedMs, outcome, false, outcome.claimedDone, {
+      failure: error instanceof Error ? error.message : String(error)
+    });
   } finally {
     await browser.close();
   }
@@ -233,12 +263,12 @@ ${text}` : text;
 var DOM_TOOLS = [
   {
     name: "read_page",
-    description: "Read the page's current accessibility tree (roles and names). Call after every action that changes the page.",
+    description: "Read the page's current accessibility tree (roles and names).",
     parameters: { type: "object", properties: {} }
   },
   {
     name: "click",
-    description: "Click the element with this ARIA role and accessible name.",
+    description: "Click the element with this ARIA role and accessible name. Returns the updated page.",
     parameters: {
       type: "object",
       properties: {
@@ -250,7 +280,7 @@ var DOM_TOOLS = [
   },
   {
     name: "fill",
-    description: "Type a value into the input with this ARIA role and accessible name (replaces content).",
+    description: "Type a value into the input with this ARIA role and accessible name (replaces content). Returns the updated page.",
     parameters: {
       type: "object",
       properties: {
@@ -260,53 +290,88 @@ var DOM_TOOLS = [
       },
       required: ["role", "name", "value"]
     }
+  },
+  {
+    name: "select_option",
+    description: "Choose an option in a dropdown (select) by its accessible name and the option's visible label. Returns the updated page.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Accessible name of the dropdown" },
+        option: { type: "string", description: "Visible label of the option to choose" }
+      },
+      required: ["name", "option"]
+    }
   }
 ];
-var MAX_SNAPSHOT_CHARS = 24e3;
-async function runDomLane(url, task, llm) {
+var DEFAULT_MAX_SNAPSHOT_CHARS = 12e4;
+var SETTLE_MS = 150;
+async function runDomLane(url, task, llm, options = {}) {
+  const maxSnapshotChars = options.maxSnapshotChars ?? DEFAULT_MAX_SNAPSHOT_CHARS;
   const browser = await chromium.launch();
   const run = metrics("dom", task);
+  const outcome = newLoopOutcome();
   const startedMs = performance.now();
   try {
     const context = await browser.newContext();
     const page = await context.newPage();
     await page.goto(url, { waitUntil: "load" });
+    await assertNotAlreadySatisfied(page, task);
     const target = (role, name) => page.getByRole(String(role), {
       name: String(name),
       exact: false
     }).first();
     const loop = await runAgentLoop({
       llm,
-      systemPrompt: "You complete tasks on a web page the way a browser-driving agent does: read the accessibility tree with read_page, then click and fill elements by role and name. Re-read the page after actions that change it. When the task is fully done, call task_complete.",
+      systemPrompt: "You complete tasks on a web page the way a browser-driving agent does: read the accessibility tree with read_page, then click, fill and select_option by role and name. Every action returns the updated page. When the task is fully done, call task_complete.",
       taskPrompt: task.prompt,
       tools: DOM_TOOLS,
       maxTurns: task.maxTurns,
       invoke: async (name, args) => {
+        const snapshot = async () => {
+          const text = await page.locator("body").ariaSnapshot();
+          if (text.length <= maxSnapshotChars) return text;
+          run.snapshotTruncated = true;
+          return text.slice(0, maxSnapshotChars) + "\n\u2026 (truncated)";
+        };
         switch (name) {
-          case "read_page": {
-            const snapshot = await page.locator("body").ariaSnapshot();
-            return snapshot.length > MAX_SNAPSHOT_CHARS ? snapshot.slice(0, MAX_SNAPSHOT_CHARS) + "\n\u2026 (truncated)" : snapshot;
-          }
+          case "read_page":
+            return snapshot();
           case "click": {
             await target(args.role, args.name).click({ timeout: 5e3 });
-            await page.waitForTimeout(250);
-            return `Clicked ${String(args.role)} "${String(args.name)}".`;
+            await page.waitForTimeout(SETTLE_MS);
+            return `Clicked ${String(args.role)} "${String(args.name)}".
+
+${await snapshot()}`;
           }
           case "fill": {
             await target(args.role, args.name).fill(String(args.value ?? ""), { timeout: 5e3 });
-            return `Filled ${String(args.role)} "${String(args.name)}".`;
+            await page.waitForTimeout(SETTLE_MS);
+            return `Filled ${String(args.role)} "${String(args.name)}".
+
+${await snapshot()}`;
+          }
+          case "select_option": {
+            await target("combobox", args.name).selectOption(
+              { label: String(args.option) },
+              { timeout: 5e3 }
+            );
+            await page.waitForTimeout(SETTLE_MS);
+            return `Selected "${String(args.option)}" in "${String(args.name)}".
+
+${await snapshot()}`;
           }
           default:
             return `ACTION FAILED: unknown action "${name}"`;
         }
       }
-    });
-    const verified = loop.claimedDone && await verify(page, task);
+    }, outcome);
+    const verified = loop.claimedDone && await matchesSuccess(page, task);
     return finish(run, startedMs, loop, verified, loop.claimedDone);
   } catch (error) {
-    run.wallClockMs = Math.round(performance.now() - startedMs);
-    run.failure = error instanceof Error ? error.message : String(error);
-    return run;
+    return finish(run, startedMs, outcome, false, outcome.claimedDone, {
+      failure: error instanceof Error ? error.message : String(error)
+    });
   } finally {
     await browser.close();
   }
@@ -321,19 +386,37 @@ function median(values) {
   const mid = Math.floor(sorted.length / 2);
   return sorted.length % 2 === 1 ? sorted[mid] : Math.round((sorted[mid - 1] + sorted[mid]) / 2);
 }
+function mean(values) {
+  if (values.length === 0) return 0;
+  return Math.round(values.reduce((sum, v) => sum + v, 0) / values.length);
+}
+function range(values) {
+  if (values.length === 0) return [0, 0];
+  return [Math.min(...values), Math.max(...values)];
+}
 function aggregate(lane, runs) {
+  const ok = runs.filter((r) => r.success);
+  const wall = ok.map((r) => r.wallClockMs);
+  const tokens = ok.map((r) => r.totalTokens);
   return {
     lane,
     runs,
-    successRate: runs.length === 0 ? 0 : runs.filter((r) => r.success).length / runs.length,
-    medianWallClockMs: median(runs.map((r) => r.wallClockMs)),
-    medianTotalTokens: median(runs.map((r) => r.totalTokens)),
-    medianTurns: median(runs.map((r) => r.turns))
+    successRate: runs.length === 0 ? 0 : ok.length / runs.length,
+    medianWallClockMs: median(wall),
+    medianTotalTokens: median(tokens),
+    medianTurns: median(ok.map((r) => r.turns)),
+    meanWallClockMs: mean(wall),
+    meanTotalTokens: mean(tokens),
+    wallClockRangeMs: range(wall),
+    totalTokensRange: range(tokens)
   };
 }
 function seconds(ms) {
   return (ms / 1e3).toFixed(1) + "s";
 }
+function ratio(dom, tools) {
+  return tools > 0 ? (dom / tools).toFixed(2) + "x" : "n/a";
+}
 function toMarkdown(report) {
   const lines = [
     `# AgentPerf report \u2014 ${report.task.id}`,
@@ -343,30 +426,39 @@ function toMarkdown(report) {
     `- **Task:** ${report.task.prompt}`,
     `- **Started:** ${report.startedAt}`,
     "",
-    "| lane | success | median wall-clock | median tokens | median round-trips |",
-    "|------|---------|-------------------|---------------|--------------------|"
+    "| lane | success | median wall-clock | mean wall-clock | median tokens | mean tokens | round-trips |",
+    "|------|---------|-------------------|-----------------|---------------|-------------|-------------|"
   ];
   for (const lane of report.lanes) {
-    const success = `${Math.round(lane.successRate * 100)}% (${lane.runs.filter((r) => r.success).length}/${lane.runs.length})`;
+    const passed = lane.runs.filter((r) => r.success).length;
     lines.push(
-      `| ${lane.lane} | ${success} | ${seconds(lane.medianWallClockMs)} | ${lane.medianTotalTokens.toLocaleString()} | ${lane.medianTurns} |`
+      `| ${lane.lane} | ${Math.round(lane.successRate * 100)}% (${passed}/${lane.runs.length}) | ${seconds(lane.medianWallClockMs)} | ${seconds(lane.meanWallClockMs)} | ${lane.medianTotalTokens.toLocaleString()} | ${lane.meanTotalTokens.toLocaleString()} | ${lane.medianTurns} |`
     );
   }
   const tools = report.lanes.find((l) => l.lane === "tools");
   const dom = report.lanes.find((l) => l.lane === "dom");
-  if (tools && dom && tools.medianTotalTokens > 0 && tools.medianWallClockMs > 0) {
+  if (tools && dom && tools.medianTotalTokens > 0) {
     lines.push(
       "",
-      `**DOM lane pays ${(dom.medianTotalTokens / tools.medianTotalTokens).toFixed(1)}x the tokens and ${(dom.medianWallClockMs / tools.medianWallClockMs).toFixed(1)}x the wall-clock of the tools lane** (medians; failed runs included in success rate, excluded from nothing).`
+      `**DOM vs tools \u2014 tokens ${ratio(dom.medianTotalTokens, tools.medianTotalTokens)} (median) / ${ratio(dom.meanTotalTokens, tools.meanTotalTokens)} (mean); wall-clock ${ratio(dom.medianWallClockMs, tools.medianWallClockMs)} (median) / ${ratio(dom.meanWallClockMs, tools.meanWallClockMs)} (mean); round-trips ${dom.medianTurns} vs ${tools.medianTurns}.**`,
+      "",
+      `Spread \u2014 DOM ${seconds(dom.wallClockRangeMs[0])}\u2013${seconds(dom.wallClockRangeMs[1])}, ${dom.totalTokensRange[0].toLocaleString()}\u2013${dom.totalTokensRange[1].toLocaleString()} tokens; tools ${seconds(tools.wallClockRangeMs[0])}\u2013${seconds(tools.wallClockRangeMs[1])}, ${tools.totalTokensRange[0].toLocaleString()}\u2013${tools.totalTokensRange[1].toLocaleString()} tokens.`,
+      "",
+      "Central tendencies are over successful runs only; failures are counted in the success rate. Token counts are uncached prompt+completion totals as the API reports them \u2014 provider prompt caching may reduce billed cost, and does so unequally across lanes."
     );
   }
   lines.push("", "## Runs", "");
-  lines.push("| lane | # | success | wall-clock | tokens | round-trips | actions | failure |");
-  lines.push("|------|---|---------|------------|--------|-------------|---------|---------|");
+  lines.push("| lane | # | success | wall-clock | tokens | round-trips | actions | notes |");
+  lines.push("|------|---|---------|------------|--------|-------------|---------|-------|");
   for (const lane of report.lanes) {
     lane.runs.forEach((r, i) => {
+      const notes = [
+        r.failure,
+        r.snapshotTruncated ? "snapshot truncated \u2014 cost is a floor" : "",
+        r.claimSummary ? `claim: ${r.claimSummary.slice(0, 90)}` : ""
+      ].filter(Boolean).join("; ");
       lines.push(
-        `| ${r.lane} | ${i + 1} | ${r.success ? "\u2713" : "\u2717"} | ${seconds(r.wallClockMs)} | ${r.totalTokens.toLocaleString()} | ${r.turns} | ${r.actions} | ${r.failure ?? ""} |`
+        `| ${r.lane} | ${i + 1} | ${r.success ? "\u2713" : "\u2717"} | ${seconds(r.wallClockMs)} | ${r.totalTokens.toLocaleString()} | ${r.turns} | ${r.actions} | ${notes} |`
       );
     });
   }
@@ -388,6 +480,7 @@ export {
   runAgentLoop,
   HOST_SHIM,
   runToolsLane,
+  DEFAULT_MAX_SNAPSHOT_CHARS,
   runDomLane,
   aggregate,
   toMarkdown,

package/dist/cli.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 import {
+  DEFAULT_MAX_SNAPSHOT_CHARS,
   aggregate,
   runDomLane,
   runToolsLane,
   toMarkdown,
   writeReport
-} from "./chunk-BGU3NILX.js";
+} from "./chunk-FCYQOMLH.js";
 
 // src/cli.ts
 import { readFileSync } from "fs";
@@ -43,6 +44,9 @@ async function main() {
   const lanes = laneArg === "both" ? ["dom", "tools"] : [laneArg];
   const runs = Number(arg("runs", "3"));
   const outDir = arg("out", "results");
+  const laneOptions = {
+    maxSnapshotChars: Number(arg("max-snapshot-chars", String(DEFAULT_MAX_SNAPSHOT_CHARS)))
+  };
   console.log(`AgentPerf \u2014 ${task.id} @ ${url}`);
   console.log(`model ${llm.model}, ${runs} run(s) per lane: ${lanes.join(", ")}
 `);
@@ -57,10 +61,10 @@ async function main() {
     const results = [];
     for (let i = 1; i <= runs; i++) {
       process.stdout.write(`[${lane}] run ${i}/${runs}\u2026 `);
-      const result = lane === "tools" ? await runToolsLane(url, task, llm) : await runDomLane(url, task, llm);
+      const result = lane === "tools" ? await runToolsLane(url, task, llm) : await runDomLane(url, task, llm, laneOptions);
       results.push(result);
       console.log(
-        result.success ? `\u2713 ${(result.wallClockMs / 1e3).toFixed(1)}s, ${result.totalTokens} tokens, ${result.turns} turns` : `\u2717 ${result.failure}`
+        result.success ? `\u2713 ${(result.wallClockMs / 1e3).toFixed(1)}s, ${result.totalTokens} tokens, ${result.turns} turns${result.snapshotTruncated ? " (snapshot truncated \u2014 cost is a floor)" : ""}` : `\u2717 ${result.failure}`
       );
     }
     report.lanes.push(aggregate(lane, results));

package/dist/index.d.ts

@@ -27,10 +27,22 @@ interface TaskSpec {
     /** Hard cap on model round-trips before the run is failed. */
     maxTurns: number;
 }
+interface LaneOptions {
+    /**
+     * Cap on the accessibility snapshot handed to the DOM lane per `read_page`.
+     * Set it high enough that the page is never truncated: a truncated snapshot
+     * handicaps the DOM lane instead of letting it pay honestly in tokens.
+     */
+    maxSnapshotChars?: number;
+}
 interface RunMetrics {
     lane: Lane;
     taskId: string;
     success: boolean;
+    /** Set when the DOM lane's snapshot hit the cap — the run is then a floor, not a measurement. */
+    snapshotTruncated?: boolean;
+    /** What the model said it did, recorded so a reader can audit the run rather than trust it. */
+    claimSummary?: string;
     /** Why a run failed, when it did. */
     failure?: string;
     wallClockMs: number;
@@ -46,9 +58,14 @@ interface LaneAggregate {
     lane: Lane;
     runs: RunMetrics[];
     successRate: number;
+    /** Central tendencies are over SUCCESSFUL runs only; failures live in successRate. */
     medianWallClockMs: number;
     medianTotalTokens: number;
     medianTurns: number;
+    meanWallClockMs: number;
+    meanTotalTokens: number;
+    wallClockRangeMs: [number, number];
+    totalTokensRange: [number, number];
 }
 interface BenchmarkReport {
     url: string;
@@ -77,7 +94,14 @@ declare global {
     }
 }
 declare function runToolsLane(url: string, task: TaskSpec, llm: LlmConfig): Promise<RunMetrics>;
-declare function runDomLane(url: string, task: TaskSpec, llm: LlmConfig): Promise<RunMetrics>;
+/**
+ * Deliberately generous: a heavy page must reach the DOM lane whole, so it
+ * pays for the page in tokens rather than being handicapped by truncation.
+ * Runs that still hit the cap are flagged — their cost is a floor, not a
+ * measurement.
+ */
+declare const DEFAULT_MAX_SNAPSHOT_CHARS = 120000;
+declare function runDomLane(url: string, task: TaskSpec, llm: LlmConfig, options?: LaneOptions): Promise<RunMetrics>;
 
 /**
  * The agent loop both lanes share, so nothing about the driver differs
@@ -101,8 +125,13 @@ declare function runAgentLoop(options: {
     tools: LlmToolDef[];
     invoke: (name: string, args: Record<string, unknown>) => Promise<string>;
     maxTurns: number;
-}): Promise<LoopOutcome>;
+}, outcome?: LoopOutcome): Promise<LoopOutcome>;
 
+/**
+ * Central tendencies are computed over successful runs only. A crashed run
+ * records near-zero cost, and averaging that in would drag a lane's reported
+ * cost toward zero — understating exactly the lane that failed.
+ */
 declare function aggregate(lane: Lane, runs: RunMetrics[]): LaneAggregate;
 declare function toMarkdown(report: BenchmarkReport): string;
 declare function writeReport(report: BenchmarkReport, outDir: string): {
@@ -118,4 +147,4 @@ declare function writeReport(report: BenchmarkReport, outDir: string): {
  */
 declare const HOST_SHIM = "\n(() => {\n  const tools = new Map();\n  const api = {\n    listTools: () =>\n      Array.from(tools.values()).map((t) => ({\n        name: t.name,\n        description: t.description,\n        inputSchema: t.inputSchema || { type: \"object\", properties: {} },\n        annotations: t.annotations || {}\n      })),\n    call: async (name, args) => {\n      const tool = tools.get(name);\n      if (!tool) {\n        return {\n          content: [{ type: \"text\", text: \"No tool named \\\"\" + name + \"\\\" is registered on this page.\" }],\n          isError: true\n        };\n      }\n      const result = await tool.execute(args || {});\n      if (typeof result === \"string\") return { content: [{ type: \"text\", text: result }] };\n      return result;\n    }\n  };\n  Object.defineProperty(window, \"__agentperf\", { value: api });\n\n  const modelContext = {\n    registerTool: (tool, options) => {\n      tools.set(tool.name, tool);\n      if (options && options.signal) {\n        options.signal.addEventListener(\"abort\", () => { tools.delete(tool.name); });\n      }\n    },\n    getTools: async () => api.listTools()\n  };\n  Object.defineProperty(document, \"modelContext\", { value: modelContext, configurable: true });\n  Object.defineProperty(navigator, \"modelContext\", { value: modelContext, configurable: true });\n})();\n";
 
-export { type BenchmarkReport, HOST_SHIM, type Lane, type LaneAggregate, type RunMetrics, type TaskSpec, aggregate, runAgentLoop, runDomLane, runToolsLane, toMarkdown, writeReport };
+export { type BenchmarkReport, DEFAULT_MAX_SNAPSHOT_CHARS, HOST_SHIM, type Lane, type LaneAggregate, type LaneOptions, type RunMetrics, type TaskSpec, aggregate, runAgentLoop, runDomLane, runToolsLane, toMarkdown, writeReport };

package/dist/index.js

@@ -1,4 +1,5 @@
 import {
+  DEFAULT_MAX_SNAPSHOT_CHARS,
   HOST_SHIM,
   aggregate,
   runAgentLoop,
@@ -6,8 +7,9 @@ import {
   runToolsLane,
   toMarkdown,
   writeReport
-} from "./chunk-BGU3NILX.js";
+} from "./chunk-FCYQOMLH.js";
 export {
+  DEFAULT_MAX_SNAPSHOT_CHARS,
   HOST_SHIM,
   aggregate,
   runAgentLoop,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentperf",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Measure what AI agents pay to use a website: the same task via DOM driving vs. WebMCP tool calls — wall-clock, tokens, round-trips, success rate.",
   "license": "Apache-2.0",
   "repository": {