@testdriverai/agent 7.8.0-canary.14 → 7.8.0-canary.16

package/docs/v7/test-results-json.mdx

@@ -0,0 +1,258 @@
+---
+title: "Test Result JSON"
+sidebarTitle: "Test Result JSON"
+description: "Per-test JSON result files with metadata, versions, and infrastructure details"
+icon: "file-code"
+---
+
+## Overview
+
+TestDriver automatically writes a JSON result file for each test case after it finishes. These files contain comprehensive metadata about the test run, including SDK and runner versions, infrastructure details, interaction statistics, and links to recordings.
+
+Result files are written to:
+
+```
+.testdriver/results/<testFile>/<testName>.json
+```
+
+For example, a test file `tests/login.test.mjs` with a test named `"should log in"` produces:
+
+```
+.testdriver/results/tests/login.test.mjs/should_log_in.json
+```
+
+<Note>
+  Test names are sanitized for filesystem use — special characters are replaced with underscores and names are truncated to 200 characters.
+</Note>
+
+## Enabling
+
+No configuration is required. The JSON files are written automatically by the TestDriver Vitest reporter plugin whenever tests run.
+
+## JSON Schema
+
+Each result file is organized into logical groups:
+
+### `versions`
+
+| Field | Type | Description |
+|---|---|---|
+| `versions.sdk` | `string \| null` | TestDriver SDK version (e.g. `"7.8.0"`) |
+| `versions.vitest` | `string \| null` | Vitest version used to run the test |
+| `versions.api` | `string \| null` | TestDriver API server version |
+| `versions.runnerBefore` | `string \| null` | Runner version at sandbox start |
+| `versions.runnerAfter` | `string \| null` | Runner version after auto-update |
+| `versions.runnerWasUpdated` | `boolean` | Whether the runner was auto-updated during provisioning |
+
+### `test`
+
+| Field | Type | Description |
+|---|---|---|
+| `test.file` | `string \| null` | Relative path to the test file |
+| `test.name` | `string \| null` | Name of the test case |
+| `test.suite` | `string \| null` | Name of the parent `describe` block |
+| `test.passed` | `boolean` | Whether the test passed |
+| `test.caseId` | `string \| null` | Database ID for this test case |
+| `test.runId` | `string \| null` | Database ID for the overall test run |
+| `test.error` | `string \| null` | Error message if the test failed |
+| `test.errorStack` | `string \| null` | Error stack trace if the test failed |
+
+### `urls`
+
+| Field | Type | Description |
+|---|---|---|
+| `urls.api` | `string \| null` | API root URL used for this test |
+| `urls.console` | `string \| null` | TestDriver console base URL |
+| `urls.vnc` | `string \| null` | VNC URL for the sandbox |
+| `urls.testRun` | `string \| null` | Direct link to this test case in the console |
+
+### `replay`
+
+The `replay` object contains the recording replay URL and derived embed links. The `gifUrl` and `embedUrl` are generated automatically from the replay URL.
+
+| Field | Type | Description |
+|---|---|---|
+| `replay.url` | `string \| null` | Recording replay URL |
+| `replay.gifUrl` | `string \| null` | Animated GIF thumbnail of the recording |
+| `replay.embedUrl` | `string \| null` | Embeddable replay URL (appends `&embed=true`) |
+| `replay.markdown` | `string \| null` | Ready-to-use Markdown embed with GIF linking to the replay |
+
+The `replay.markdown` field produces a clickable GIF badge you can paste directly into PR comments, README files, or issue descriptions:
+
+```markdown
+[![Test Recording](https://api.testdriver.ai/replay/abc123/gif?shareKey=xyz)](https://console.testdriver.ai/replay/abc123?share=xyz)
+```
+
+### `date`
+
+| Field | Type | Description |
+|---|---|---|
+| `date` | `string` | ISO 8601 timestamp when the test finished |
+
+### `team`
+
+| Field | Type | Description |
+|---|---|---|
+| `team.id` | `string \| null` | Team ID from the sandbox |
+| `team.sessionId` | `string \| null` | SDK session ID |
+
+### `infrastructure`
+
+| Field | Type | Description |
+|---|---|---|
+| `infrastructure.sandboxId` | `string \| null` | Sandbox instance ID |
+| `infrastructure.instanceId` | `string \| null` | Instance ID |
+| `infrastructure.os` | `string \| null` | Operating system of the sandbox (`"linux"` or `"windows"`) |
+| `infrastructure.amiId` | `string \| null` | AWS AMI ID used for provisioning |
+| `infrastructure.e2bTemplateId` | `string \| null` | E2B template ID used for provisioning |
+| `infrastructure.imageVersion` | `string \| null` | Sandbox image version |
+
+### `realtime`
+
+| Field | Type | Description |
+|---|---|---|
+| `realtime.channel` | `string \| null` | Ably channel name used for communication |
+| `realtime.messageCount` | `number` | Number of messages published to the realtime channel |
+
+### `interactions`
+
+| Field | Type | Description |
+|---|---|---|
+| `interactions.total` | `number` | Total number of interactions recorded |
+| `interactions.cached` | `number` | Number of interactions served from cache |
+| `interactions.byType` | `object` | Breakdown of interactions by type (e.g. `find`, `click`, `assert`) |
+
+## Example Output
+
+```json
+{
+  "sdkVersion": "7.8.0",
+  "vitestVersion": "4.0.0",
+  "apiVersion": "1.45.0",
+  "runnerVersionBefore": "2.1.0",
+  "runnerVersionAfter": "2.1.1",
+  "wasUpdated": true,
+  "apiUrl": "https://api.testdriver.ai",
+  "consoleUrl": "https://console.testdriver.ai",
+  "testRunLink": "https://console.testdriver.ai/runs/abc123/def456",
+  "dashcamUrl": "https://app.dashcam.io/replay/abc123",
+  "vncUrl": "wss://sandbox-123.testdriver.ai/vnc",
+  "date": "2025-01-15T14:30:00.000Z",
+  "team": {
+    "id": "team_abc123",
+    "sessionId": "sess_xyz789"
+  },
+  "infrastructure": {
+    "sandboxId": "sandbox-123",
+    "instanceId": "i-abc123",
+    "os": "linux",
+    "amiId": "ami-0abc123",
+    "e2bTemplateId": null,
+    "imageVersion": "v2.1.0"
+  },
+  "realtime": {
+    "channel": "sandbox:sandbox-123",
+    "messageCount": 42
+  },
+  "interactions": {
+    "total": 15,
+    "cached": 3,
+    "byType": {
+      "find": 8,
+      "click": 5,
+      "assert": 2
+    }
+  }
+}
+```
+
+## Using Result Files in CI
+
+Result files are useful for extracting test metadata in CI pipelines without parsing log output.
+
+### GitHub Actions Example
+
+Use `fromJSON` to parse a result file into a GitHub Actions expression you can reference in subsequent steps:
+
+```yaml
+- name: Run tests
+  run: npx vitest run tests/login.test.mjs
+
+- name: Parse result
+  id: result
+  run: |
+    # Read the first JSON result file
+    FILE=$(find .testdriver/results -name '*.json' | head -n 1)
+    echo "json=$(cat "$FILE")" >> "$GITHUB_OUTPUT"
+
+- name: Comment on PR
+  if: fromJSON(steps.result.outputs.json).test.passed == false
+  uses: actions/github-script@v7
+  with:
+    script: |
+      const result = ${{ steps.result.outputs.json }};
+      await github.rest.issues.createComment({
+        owner: context.repo.owner,
+        repo: context.repo.repo,
+        issue_number: context.issue.number,
+        body: [
+          `❌ **${result.test.name}** failed`,
+          ``,
+          `Error: ${result.test.error}`,
+          ``,
+          result.replay.markdown,
+          ``,
+          `[View full recording](${result.urls.testRun})`
+        ].join('\n')
+      });
+```
+
+You can also load all results into a matrix or iterate over them:
+
+```yaml
+- name: Run tests
+  run: npx vitest run tests/*.test.mjs
+
+- name: Collect results
+  id: results
+  run: |
+    # Merge all result files into a JSON array
+    echo "json=$(find .testdriver/results -name '*.json' -exec cat {} + | jq -s '.')" >> "$GITHUB_OUTPUT"
+
+- name: Summary
+  run: |
+    echo '## Test Results' >> $GITHUB_STEP_SUMMARY
+    RESULTS='${{ steps.results.outputs.json }}'
+    echo "$RESULTS" | jq -r '.[] | "| \(.test.name) | \(if .test.passed then "✅" else "❌" end) | \(.urls.testRun) |"' >> $GITHUB_STEP_SUMMARY
+```
+
+### Reading Results Programmatically
+
+```javascript
+import fs from "fs";
+import path from "path";
+
+const resultsDir = ".testdriver/results";
+
+function readResults(dir) {
+  const results = [];
+  for (const testDir of fs.readdirSync(dir, { recursive: true })) {
+    const fullPath = path.join(dir, testDir);
+    if (fullPath.endsWith(".json") && fs.statSync(fullPath).isFile()) {
+      results.push(JSON.parse(fs.readFileSync(fullPath, "utf-8")));
+    }
+  }
+  return results;
+}
+
+const results = readResults(resultsDir);
+const passed = results.filter(r => r.test.passed);
+const failed = results.filter(r => !r.test.passed);
+
+console.log(`${passed.length} passed, ${failed.length} failed`);
+for (const r of failed) {
+  console.log(`  FAIL: ${r.test.name} — ${r.test.error}`);
+  console.log(`  Recording: ${r.urls.testRun}`);
+  console.log(`  Embed: ${r.replay.markdown}`);
+}
+```

package/examples/scroll-keyboard.test.mjs

@@ -16,7 +16,7 @@ describe("Scroll Keyboard Test", () => {
     // Navigate to https://www.webhamster.com/
     await testdriver.focusApplication("Google Chrome");
     const urlBar = await testdriver.find(
-      "testdriver-sandbox.vercel.app/login, the URL in the omnibox showing the current page", {zoom: true}
+      "the URL in the omnibox", {zoom: true}
     );
     await urlBar.click();
     await testdriver.pressKeys(["ctrl", "a"]);

package/interfaces/vitest-plugin.mjs

@@ -1218,6 +1218,122 @@ class TestDriverReporter {
       );
       console.log("");
 
+      // Write per-test-case JSON result file
+      {
+        const testResult = meta.testResult || {};
+
+        // Parse replay URL to extract replayId and shareKey for embed links
+        let replayUrl = dashcamUrl || null;
+        let replayGifUrl = null;
+        let replayEmbedUrl = null;
+        let replayMarkdown = null;
+        const replayMatch = dashcamUrl && dashcamUrl.match(/\/replay\/([a-f0-9]+)\?share=([^&\s]+)/);
+        if (replayMatch) {
+          const [, replayId, shareKey] = replayMatch;
+          const apiRoot = pluginState.apiRoot;
+          replayGifUrl = `${apiRoot}/replay/${replayId}/gif?shareKey=${shareKey}`;
+          replayEmbedUrl = `${consoleUrl}/replay/${replayId}?share=${shareKey}&embed=true`;
+          replayMarkdown = `[![Test Recording](${replayGifUrl})](${replayUrl})`;
+        }
+
+        const resultData = {
+          // Versions
+          versions: {
+            sdk: testResult.sdkVersion || null,
+            vitest: resolveVitestVersion() || null,
+            api: testResult.apiVersion || null,
+            runnerBefore: testResult.runnerVersionBefore || null,
+            runnerAfter: testResult.runnerVersionAfter || null,
+            runnerWasUpdated: testResult.wasUpdated || false,
+          },
+
+          // Test info
+          test: {
+            file: testResult.testFile || null,
+            name: testResult.testName || null,
+            suite: testResult.suiteName || null,
+            passed: status === "passed",
+            caseId: testCaseDbId || null,
+            runId: testRunDbId || null,
+            error: errorMessage || testResult.error || null,
+            errorStack: errorStack || testResult.errorStack || null,
+          },
+
+          // URLs
+          urls: {
+            api: testResult.apiUrl || null,
+            console: consoleUrl || null,
+            vnc: testResult.vncUrl || null,
+            testRun: testCaseDbId ? `${consoleUrl}/runs/${testRunDbId}/${testCaseDbId}` : null,
+          },
+
+          // Recording replay
+          replay: {
+            url: replayUrl,
+            gifUrl: replayGifUrl,
+            embedUrl: replayEmbedUrl,
+            markdown: replayMarkdown,
+          },
+
+          // Timing
+          date: testResult.date || new Date().toISOString(),
+
+          // Team & session
+          team: {
+            id: testResult.teamId || null,
+            sessionId: testResult.sessionId || null,
+          },
+
+          // Infrastructure
+          infrastructure: {
+            sandboxId: testResult.sandboxId || null,
+            instanceId: testResult.instanceId || null,
+            os: testResult.os || null,
+            amiId: testResult.amiId || null,
+            e2bTemplateId: testResult.e2bTemplateId || null,
+            imageVersion: testResult.imageVersion || null,
+          },
+
+          // Realtime
+          realtime: {
+            channel: testResult.realtimeChannel || null,
+            messageCount: testResult.realtimeMessageCount || 0,
+          },
+
+          // Interactions
+          interactions: testResult.interactions || { total: 0, cached: 0, byType: {} },
+        };
+
+        // Sanitize testName for filesystem use
+        const safeName = (test.name || "unknown").replace(/[^a-zA-Z0-9_.-]/g, "_").substring(0, 200);
+        const resultDir = path.join(process.cwd(), ".testdriver", "results", testFile);
+        fs.mkdirSync(resultDir, { recursive: true });
+
+        // Include a stable unique suffix in the filename to avoid collisions
+        // when multiple tests in the same file share the same name.
+        const hashSourceParts = [];
+        if (test.id) {
+          hashSourceParts.push(String(test.id));
+        }
+        if (Array.isArray(test.suitePath)) {
+          hashSourceParts.push(test.suitePath.join(" > "));
+        }
+        if (test.file && (test.file.name || test.file.path)) {
+          hashSourceParts.push(test.file.name || test.file.path);
+        }
+        // Fallback to the test name if no other identifiers are available.
+        if (hashSourceParts.length === 0) {
+          hashSourceParts.push(test.name || "unknown");
+        }
+        const hashSource = hashSourceParts.join(" | ");
+        const uniqueHash = crypto.createHash("sha256").update(hashSource).digest("hex").slice(0, 8);
+
+        fs.writeFileSync(
+          path.join(resultDir, `${safeName}-${uniqueHash}.json`),
+          JSON.stringify(resultData, null, 2),
+        );
+      }
+
       // If there were retries, list all per-attempt dashcam URLs for debugging
       if (hasRetries) {
         const validAttempts = dashcamUrls.filter(a => a.url);
@@ -1229,13 +1345,6 @@ class TestDriverReporter {
         }
       }
 
-      // Output parseable format for docs generation (examples only)
-      if (testFile.startsWith("examples/")) {
-        const testFileName = path.basename(testFile);
-        console.log(
-          `TESTDRIVER_EXAMPLE_URL::${testFileName}::${consoleUrl}/runs/${testRunDbId}/${testCaseDbId}`,
-        );
-      }
     } catch (error) {
       logger.error("Failed to report test case:", error.message);
     }

package/lib/vitest/hooks.mjs

@@ -403,6 +403,11 @@ export function TestDriver(context, options = {}) {
     config.apiRoot = process.env.TD_API_ROOT;
   }
 
+  // Use TD_E2B_TEMPLATE_ID from environment if not provided in config
+  if (!config.e2bTemplateId && process.env.TD_E2B_TEMPLATE_ID) {
+    config.e2bTemplateId = process.env.TD_E2B_TEMPLATE_ID;
+  }
+
   const testdriver = new TestDriverSDK(apiKey, config);
   testdriver.__vitestContext = context.task;
   testdriver._debugOnFailure = mergedOptions.debugOnFailure || false;
@@ -644,6 +649,61 @@ export function TestDriver(context, options = {}) {
       // Clean up console spies
       cleanupConsoleSpy(currentInstance);
 
+      // Build test result metadata for JSON report output
+      {
+        const sdkPkg = require("../../package.json");
+        const inst = currentInstance.getInstance?.() || {};
+        const sbx = currentInstance.sandbox || {};
+        const apiRoot = currentInstance.config?.TD_API_ROOT || null;
+
+        context.task.meta.testResult = {
+          // Versions
+          sdkVersion: sdkPkg.version || null,
+          apiVersion: currentInstance._apiVersion || null,
+          runnerVersionBefore: inst.runnerVersionBefore || null,
+          runnerVersionAfter: inst.runnerVersionAfter || null,
+          wasUpdated: inst.wasUpdated || false,
+
+          // URLs
+          apiUrl: apiRoot,
+          vncUrl: inst.vncUrl || inst.url || null,
+
+          // Dates
+          date: new Date().toISOString(),
+
+          // Team / session
+          teamId: sbx._teamId || null,
+          sessionId: currentInstance.getSessionId?.() || null,
+
+          // Test info
+          testFile: context.task.meta.testFile || null,
+          testName: context.task.name || null,
+          suiteName: context.task.suite?.name || null,
+
+          // Test result
+          testPassed: context.task.result?.state === "pass",
+          error: context.task.result?.errors?.[0]?.message || null,
+          errorStack: context.task.result?.errors?.[0]?.stack || null,
+
+          // Infrastructure
+          sandboxId: inst.sandboxId || inst.instanceId || null,
+          instanceId: inst.instanceId || null,
+          os: currentInstance.os || inst.os || null,
+          amiId: inst.amiId || null,
+          e2bTemplateId: inst.e2bTemplateId || null,
+          imageVersion: inst.imageVersion || null,
+
+          // Realtime
+          realtimeChannel: inst.channelName || sbx._channelName || null,
+          realtimeMessageCount: typeof sbx.getPublishCount === "function" ? sbx.getPublishCount() : 0,
+
+          // Interactions
+          interactions: currentInstance._interactionStats
+            ? { ...currentInstance._interactionStats, byType: { ...currentInstance._interactionStats.byType } }
+            : { total: 0, cached: 0, byType: {} },
+        };
+      }
+
       // Wait for connection to finish if it was initiated
       if (currentInstance.__connectionPromise) {
         await currentInstance.__connectionPromise.catch(() => { }); // Ignore connection errors during cleanup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testdriverai/agent",
-  "version": "7.8.0-canary.14",
+  "version": "7.8.0-canary.16",
   "description": "Next generation autonomous AI agent for end-to-end testing of web & desktop",
   "main": "sdk.js",
   "types": "sdk.d.ts",

package/sdk.d.ts

@@ -273,6 +273,8 @@ export interface TestDriverOptions {
   sandboxAmi?: string;
   /** EC2 instance type for sandbox (e.g., 'i3.metal') */
   sandboxInstance?: string;
+  /** E2B template ID to use when creating the sandbox (e.g., 'my-template-id') */
+  e2bTemplateId?: string;
   /** Cache key for element finding operations. If provided, enables caching tied to this key */
   cacheKey?: string;
   /** Reconnect to the last used sandbox instead of creating a new one. When true, provision methods (chrome, vscode, installer, etc.) will be skipped since the application is already running. Throws error if no previous sandbox exists. */
@@ -327,6 +329,8 @@ export interface ConnectOptions {
   sandboxAmi?: string;
   /** EC2 instance type for sandbox (e.g., 'i3.metal') */
   sandboxInstance?: string;
+  /** E2B template ID to use when creating the sandbox (e.g., 'my-template-id') */
+  e2bTemplateId?: string;
   /** Operating system for the sandbox (default: 'linux') */
   os?: "windows" | "linux";
   /**

package/sdk.js

@@ -481,7 +481,7 @@ class Element {
       let cacheKey = null;
       let cacheThreshold = null;
       let perCommandThresholds = null; // Per-command { screen, element } override
-      let zoom = false; // Default to disabled, enable with zoom: true
+      let zoom = true; // Default to enabled
       let perCommandAi = null; // Per-command AI config override
 
       let minConfidence = null; // Minimum confidence threshold
@@ -494,8 +494,8 @@ class Element {
         // New: options is an object with cacheKey and/or cacheThreshold
         cacheKey = options.cacheKey || null;
         cacheThreshold = options.cacheThreshold ?? null;
-        // zoom defaults to false unless explicitly set to true
-        zoom = options.zoom === true;
+        // zoom defaults to true unless explicitly set to false
+        zoom = options.zoom !== false;
         // Minimum confidence threshold: fail find if AI confidence is below this value
         minConfidence = options.confidence ?? null;
         // Element type hint for prompt wrapping
@@ -568,7 +568,7 @@ class Element {
         cacheKey: cacheKey,
         os: this.sdk.os,
         resolution: this.sdk.resolution,
-        zoom: zoom,
+        zoom: zoom === true ? 1 : zoom === false ? 0 : zoom,
         confidence: minConfidence,
         type: elementType,
         ai: {
@@ -623,6 +623,11 @@ class Element {
 
     // Track find interaction once at the end (fire-and-forget, don't block)
     const sessionId = this.sdk.getSessionId();
+    const findCacheHit = response?.cacheHit || response?.cache_hit || response?.cached || false;
+    // Increment local interaction counters
+    this.sdk._interactionStats.total++;
+    this.sdk._interactionStats.byType.find = (this.sdk._interactionStats.byType.find || 0) + 1;
+    if (findCacheHit) this.sdk._interactionStats.cached++;
     if (sessionId && this.sdk.apiClient) {
       this.sdk.apiClient
         .req("interaction/track", {
@@ -632,11 +637,7 @@ class Element {
           timestamp: absoluteTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
           success: this._found,
           error: findError,
-          cacheHit:
-            response?.cacheHit ||
-            response?.cache_hit ||
-            response?.cached ||
-            false,
+          cacheHit: findCacheHit,
           selector: response?.selector,
           selectorUsed: !!response?.selector,
           confidence: response?.confidence ?? null,
@@ -1498,6 +1499,7 @@ class TestDriverSDK {
     // Store sandbox configuration options
     this.sandboxAmi = options.sandboxAmi || null;
     this.sandboxInstance = options.sandboxInstance || null;
+    this.e2bTemplateId = options.e2bTemplateId || null;
 
     // Store reconnect preference from options
     this.reconnect =
@@ -1616,6 +1618,12 @@ class TestDriverSDK {
     // Uploaded to S3 at cleanup so they can be displayed alongside dashcam replays.
     this._logBuffer = [];
 
+    // API version discovered by _logEnvironmentInfo()
+    this._apiVersion = null;
+
+    // Local interaction counters — incremented at each interaction/track call site
+    this._interactionStats = { total: 0, cached: 0, byType: {} };
+
     // Set up event listeners once (they live for the lifetime of the SDK instance)
     this._setupLogging();
 
@@ -2716,6 +2724,7 @@ CAPTCHA_SOLVER_EOF`,
    * @param {string} options.ip - Direct IP address to connect to
    * @param {string} options.sandboxAmi - AMI to use for the sandbox
    * @param {string} options.sandboxInstance - Instance type for the sandbox
+   * @param {string} options.e2bTemplateId - E2B template ID to use when creating the sandbox
    * @param {string} options.os - Operating system for the sandbox (windows or linux)
    * @param {boolean} options.reuseConnection - Reuse recent connection if available (default: true)
    * @returns {Promise<Object>} Sandbox instance details
@@ -2804,6 +2813,12 @@ CAPTCHA_SOLVER_EOF`,
     } else if (this.sandboxInstance) {
       this.agent.sandboxInstance = this.sandboxInstance;
     }
+    // Use e2bTemplateId from connectOptions if provided, otherwise fall back to constructor value
+    if (connectOptions.e2bTemplateId !== undefined) {
+      this.agent.e2bTemplateId = connectOptions.e2bTemplateId;
+    } else if (this.e2bTemplateId) {
+      this.agent.e2bTemplateId = this.e2bTemplateId;
+    }
     // Use os from connectOptions if provided, otherwise fall back to this.os
     if (connectOptions.os !== undefined) {
       this.agent.sandboxOs = connectOptions.os;
@@ -3193,6 +3208,11 @@ CAPTCHA_SOLVER_EOF`,
 
         // Track successful findAll interaction (fire-and-forget, don't block)
         const sessionId = this.getSessionId();
+        const findAllCacheHit = response.cached || false;
+        // Increment local interaction counters
+        this._interactionStats.total++;
+        this._interactionStats.byType.findAll = (this._interactionStats.byType.findAll || 0) + 1;
+        if (findAllCacheHit) this._interactionStats.cached++;
         if (sessionId && this.apiClient) {
           this.apiClient
             .req("interaction/track", {
@@ -3202,7 +3222,7 @@ CAPTCHA_SOLVER_EOF`,
               timestamp: absoluteTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
               success: true,
               input: { count: elements.length },
-              cacheHit: response.cached || false,
+              cacheHit: findAllCacheHit,
               selector: response.selector,
               selectorUsed: !!response.selector,
               screenshotUrl: response.screenshotKey ?? null,
@@ -3248,6 +3268,11 @@ CAPTCHA_SOLVER_EOF`,
 
         // No elements found - track interaction (fire-and-forget, don't block)
         const sessionId = this.getSessionId();
+        const noResultCacheHit = response?.cached || false;
+        // Increment local interaction counters
+        this._interactionStats.total++;
+        this._interactionStats.byType.findAll = (this._interactionStats.byType.findAll || 0) + 1;
+        if (noResultCacheHit) this._interactionStats.cached++;
         if (sessionId && this.apiClient) {
           this.apiClient
             .req("interaction/track", {
@@ -3258,7 +3283,7 @@ CAPTCHA_SOLVER_EOF`,
               success: false,
               error: "No elements found",
               input: { count: 0 },
-              cacheHit: response?.cached || false,
+              cacheHit: noResultCacheHit,
               selector: response?.selector,
               selectorUsed: !!response?.selector,
               screenshotUrl: response?.screenshotKey ?? null,
@@ -3292,6 +3317,9 @@ CAPTCHA_SOLVER_EOF`,
 
       // Track findAll error interaction (fire-and-forget, don't block)
       const sessionId = this.getSessionId();
+      // Increment local interaction counters
+      this._interactionStats.total++;
+      this._interactionStats.byType.findAll = (this._interactionStats.byType.findAll || 0) + 1;
       if (sessionId && this.apiClient) {
         this.apiClient
           .req("interaction/track", {
@@ -3843,6 +3871,8 @@ CAPTCHA_SOLVER_EOF`,
       res.on('end', () => {
         try {
           const info = JSON.parse(data);
+          // Persist API version for test result metadata
+          this._apiVersion = info.version || null;
           const commit = info.commit || 'unknown';
           const shortCommit = commit.substring(0, 7);
           const commitUrl = commit !== 'unknown'