testronaut 1.9.3 → 1.10.0

package/README.md

@@ -145,7 +145,7 @@ Choose your preferred LLM at init or via environment variables.
 testronaut --init
 
 # Or override anytime
-TESTRONAUT_PROVIDER=gemini TESTRONAUT_MODEL=gemini-2.5-pro testronaut
+TESTRONAUT_PROVIDER=gemini TESTRONAUT_MODEL=gemini-3.8-flash testronaut
 ```
 
 ### Token-rate override
@@ -172,7 +172,7 @@ Current supported providers:
 | Provider | Example Models |
 |-----------|----------------|
 | **OpenAI** | gpt-5.6, gpt-5.6-terra, gpt-5.6-luna, gpt-5.5, and legacy GPT/o-series models |
-| **Google Gemini** | gemini-2.5-pro, gemini-2.5-flash, gemini-2.5-flash-8b |
+| **Google Gemini** | gemini-3.8-flash, gemini-3.7-flash, gemini-3.6-flash, gemini-3.5-flash-lite, gemini-3.1-pro-preview, Gemini 2.5 legacy models |
 | **Anthropic Claude** | claude-sonnet-5, claude-opus-5, claude-haiku-4-5 |
 
 The canonical Claude provider ID is `anthropic`; `claude` is also accepted as a CLI alias.
@@ -191,6 +191,31 @@ Run a specific mission:
 testronaut login.mission.js
 ```
 
+Reuse cookies, local storage, and IndexedDB authentication state across an ordered set of mission files:
+
+```bash
+testronaut --session=shared-auth checkout.mission.js account.mission.js
+```
+
+Each mission still receives a fresh browser context. The default
+`--session=isolated` mode does not carry authentication forward. Shared-auth
+suites can wrap a reusable login prerequisite in `launchProtocol()` so later
+mission files probe the restored authenticated page without an LLM call:
+
+```js
+import { launchProtocol, runMissions } from 'testronaut';
+
+const login = launchProtocol('Visit the app and log in.', {
+  id: 'authenticated:test-user',
+  probe: { url: process.env.URL, selector: '#dashboard' },
+});
+
+await runMissions({ preMission: login, mission: 'Test the dashboard.' }, 'dashboard');
+```
+
+Unwrapped `preMission` values remain fully compatible and always run normally.
+Place logout last in a shared-auth suite.
+
 Preview or inspect without launching a browser:
 ```bash
 testronaut list
@@ -371,7 +396,7 @@ Each includes:
 - **LLMs** for reasoning, DOM parsing, and tool use  
 - **Token throttling** + adaptive cooldowns  
 - **Extensible architecture** for custom tools and workflows  
-- **DOM trimming controls** to cap list sizes (env `TESTRONAUT_DOM_LIST_LIMIT` or config `dom.listItemLimit`; use `all` cautiously—it can spike token use)
+- **DOM trimming controls** to cap list/table sizes (`TESTRONAUT_DOM_LIST_LIMIT`) and automatic post-action snapshots (`TESTRONAUT_AUTO_DOM_LIMIT` or `dom.automaticLimit`)
 - **Resource guard** to ensure full list/table downloads (config `resourceGuard` or env `TESTRONAUT_RESOURCE_*`)
 
 ---

package/TODO.md

@@ -9,6 +9,17 @@
 - [ ] Treat `--json` output as a stable automation contract with documented schemas and tests for every supported command.
 - [ ] If authentication ever moves outside project config, continue reading existing `sessionToken` values and provide an opt-in migration path before deprecating legacy storage.
 
+## Session and Reporting Follow-Ups
+
+- [ ] Evaluate a true shared browser-context mode for suites that require session storage or in-memory application state; define page reset, crash recovery, and concurrency behavior first.
+- [ ] Add optional shared-auth checkpoints/reset controls for suites that intentionally change users or tenants.
+- [ ] Refresh short-lived Testronaut API session tokens during long runs once the API and credential-storage contract is defined.
+- [ ] Store new CLI authentication outside project config, prefer environment credentials in CI, and migrate legacy project `sessionToken` values without breaking existing projects.
+- [ ] Add structured post-run self-critique fields after the versioned report schema is available.
+- [ ] Separate mission totals from phase totals and add an explicit `phase` field without losing compatibility with `submissionType`.
+- [ ] Design an optional mission scope/side-effect policy that agents can enforce and reports can display.
+- [ ] Evaluate semantic DOM diffs/chunks after configurable limits, selector scoping, and table trimming have production data.
+
 ## Automated MFA Follow-Ups
 
 - [ ] Add an integration smoke test against a local or staging API fixture for `get_mfa_code`.

package/bin/cli.js

@@ -62,6 +62,8 @@ import { matchesTagFilter, normalizeTagMatch, normalizeTags } from '../core/tags
 process.env.PLAYWRIGHT_BROWSERS_PATH = process.env.PLAYWRIGHT_BROWSERS_PATH || '0';
 
 const TMP_DIR = path.resolve('./missions/tmp');
+const runId = `run_${Date.now()}`;
+const startTime = new Date();
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const CLI_VERSION = JSON.parse(
   fs.readFileSync(path.resolve(__dirname, '../package.json'), 'utf8')
@@ -89,6 +91,28 @@ const uploadScreenshots = !args.includes('--no-upload-screenshots');
 args = args.filter(arg => arg !== '--no-upload-screenshots');
 process.env.TESTRONAUT_SCREENSHOTS = screenshotsEnabled ? '1' : '0';
 
+let sessionMode = 'isolated';
+const sessionFlagIndex = args.findIndex(a => a === '--session' || a.startsWith('--session='));
+if (sessionFlagIndex >= 0) {
+  const raw = args[sessionFlagIndex];
+  const inline = raw.includes('=');
+  const value = inline ? raw.slice(raw.indexOf('=') + 1) : args[sessionFlagIndex + 1];
+  if (!['isolated', 'shared-auth'].includes(value)) {
+    console.error('❌ --session must be "isolated" or "shared-auth".');
+    process.exit(1);
+  }
+  sessionMode = value;
+  args.splice(sessionFlagIndex, inline ? 1 : 2);
+}
+if (sessionMode === 'shared-auth') {
+  const storageStatePath = path.join(TMP_DIR, `${runId}-storage-state.json`);
+  process.env.TESTRONAUT_STORAGE_STATE_PATH = storageStatePath;
+  process.once('exit', () => {
+    try { fs.unlinkSync(storageStatePath); } catch {}
+  });
+}
+process.env.TESTRONAUT_SESSION_MODE = sessionMode;
+
 // Detect how the CLI was invoked so help text matches the actual command
 function detectCliName(npmCommand = process.env.npm_command, argv1 = process.argv[1]) {
   // npx sets npm_command to 'exec'
@@ -486,7 +510,8 @@ __test__.parseTagArgs = parseTagArgs;
 let modelOverride;
 const modelFlagIndex = args.findIndex(a => a === '--model' || a.startsWith('--model='));
 if (modelFlagIndex >= 0) {
-  if (args[modelFlagIndex].includes('=')) {
+  const inline = args[modelFlagIndex].includes('=');
+  if (inline) {
     modelOverride = args[modelFlagIndex].split('=')[1];
   } else if (args[modelFlagIndex + 1]) {
     modelOverride = args[modelFlagIndex + 1];
@@ -498,7 +523,7 @@ if (modelFlagIndex >= 0) {
   }
 
   // Remove flag & value from args so they don't look like mission filenames
-  args.splice(modelFlagIndex, modelOverride ? 2 : 1);
+  args.splice(modelFlagIndex, inline ? 1 : (modelOverride ? 2 : 1));
 }
 
 // Look for --provider=<id> or --provider <id>
@@ -601,7 +626,8 @@ if (debugFlagIndex >= 0) {
 let turnsOverride;
 const turnsFlagIndex = args.findIndex(a => a === '--turns' || a.startsWith('--turns='));
 if (turnsFlagIndex >= 0) {
-  if (args[turnsFlagIndex].includes('=')) {
+  const inline = args[turnsFlagIndex].includes('=');
+  if (inline) {
     turnsOverride = args[turnsFlagIndex].split('=')[1];
   } else if (args[turnsFlagIndex + 1]) {
     turnsOverride = args[turnsFlagIndex + 1];
@@ -618,7 +644,7 @@ if (turnsFlagIndex >= 0) {
   }
 
   // Remove flag & value so they aren’t treated as filenames
-  args.splice(turnsFlagIndex, turnsOverride ? 2 : 1);
+  args.splice(turnsFlagIndex, inline ? 1 : (turnsOverride ? 2 : 1));
 }
 
 // Look for --retry_limit / --retry-limit
@@ -631,7 +657,8 @@ const retryFlagIndex = args.findIndex(a =>
 );
 if (retryFlagIndex >= 0) {
   const rawArg = args[retryFlagIndex];
-  if (rawArg.includes('=')) {
+  const inline = rawArg.includes('=');
+  if (inline) {
     retryOverride = rawArg.split('=')[1];
   } else if (args[retryFlagIndex + 1]) {
     retryOverride = args[retryFlagIndex + 1];
@@ -649,7 +676,7 @@ if (retryFlagIndex >= 0) {
   }
 
   // Remove flag & value so they aren’t treated as filenames
-  args.splice(retryFlagIndex, retryOverride ? 2 : 1);
+  args.splice(retryFlagIndex, inline ? 1 : (retryOverride ? 2 : 1));
 }
 
 // Look for --human-input / --no-human-input / --disable-human-input
@@ -697,7 +724,8 @@ const humanInputTimeoutFlagIndex = args.findIndex(a =>
 );
 if (humanInputTimeoutFlagIndex >= 0) {
   const rawArg = args[humanInputTimeoutFlagIndex];
-  if (rawArg.includes('=')) {
+  const inline = rawArg.includes('=');
+  if (inline) {
     humanInputTimeoutOverride = rawArg.split('=')[1];
   } else if (args[humanInputTimeoutFlagIndex + 1]) {
     humanInputTimeoutOverride = args[humanInputTimeoutFlagIndex + 1];
@@ -713,12 +741,10 @@ if (humanInputTimeoutFlagIndex >= 0) {
     }
   }
 
-  args.splice(humanInputTimeoutFlagIndex, humanInputTimeoutOverride ? 2 : 1);
+  args.splice(humanInputTimeoutFlagIndex, inline ? 1 : (humanInputTimeoutOverride ? 2 : 1));
 }
 
 const allResults = [];
-const runId = `run_${Date.now()}`;
-const startTime = new Date();
 
 const HELP_TEXT = `
 🧑‍🚀 testronaut - Autonomous Agent Mission Runner
@@ -738,6 +764,8 @@ Options:
   --turns=<n>               Override max turns for this run (e.g., --turns=30)
   --debug[=<bool>]          Enable verbose debug logs (or set TESTRONAUT_DEBUG=1)
   --provider=<id>           Override LLM provider (openai, gemini, or anthropic)
+  --model=<id>              Override the provider model for this run
+  --session=<mode>          Browser auth reuse: isolated (default) or shared-auth
   -o, --options key=value   Set run options, such as mfa=github-test-mfa or inbox=github-staging
   --dev                     Use the staging API base URL
   --vercel-bypass=<secret>  Send Vercel protection bypass header for protected deployments
@@ -849,13 +877,16 @@ if (args.length === 1 && args[0] === 'list') {
     return;
   }
   const listedMissions = [];
+  const listTags = cliTags ?? normalizeTags(tagConfig?.tags, { allowUntagged: true });
+  const listTagMatch = normalizeTagMatch(cliTagMatch ?? tagConfig?.tagMatch);
   if (!jsonOutput) console.log(`Missions in ${path.relative(process.cwd(), missionsRoot) || '.'}:`);
   for (const file of discoveredMissions) {
     try {
       const mission = await loadMissionModule(path.resolve(missionsRoot, file));
       const tags = normalizeTags(mission.tags);
-      listedMissions.push({ file, tags });
-      if (!jsonOutput) console.log(`  ${file}${tags.length ? `  [${tags.join(', ')}]` : ''}`);
+      const selected = matchesTagFilter(tags, listTags, listTagMatch);
+      listedMissions.push({ file, tags, selected });
+      if (!jsonOutput) console.log(`  ${selected ? '✓' : '·'} ${file}${tags.length ? `  [${tags.join(', ')}]` : ''}`);
     } catch (error) {
       console.log(`  ${file}  [could not load: ${error.message}]`);
       process.exitCode = 1;
@@ -907,7 +938,7 @@ if (dryRun) {
       invalid = true;
     }
   }
-  writeOutput({ dryRun: true, outputDir, provider: resolveProviderModel({ cwd: process.cwd() }), screenshots: screenshotsEnabled, missions });
+  writeOutput({ dryRun: true, outputDir, provider: resolveProviderModel({ cwd: process.cwd() }), session: { mode: sessionMode }, screenshots: screenshotsEnabled, missions });
   if (invalid) process.exitCode = 1;
   return;
 }
@@ -1008,6 +1039,7 @@ const report = {
     provider: llmProvider,
     model: llmModel,
   },
+  session: { mode: sessionMode },
   summary: {
     totalMissions: flatMissions.length,
     passed: flatMissions.filter(m => m.status === 'passed').length,

package/bin/init.js

@@ -122,12 +122,17 @@ export async function initializeTestronautProject() {
         name: 'geminiModel',
         message: 'Select a Google Gemini model:',
         choices: [
-          { title: 'Gemini 2.5 Pro (general, high quality)', value: 'gemini-2.5-pro' },
-          { title: 'Gemini 2.5 Flash (fast, cost-efficient)', value: 'gemini-2.5-flash' },
-          { title: 'Gemini 2.5 Flash-8B (lightweight)', value: 'gemini-2.5-flash-8b' },
+          { title: 'Gemini 3.8 Flash (latest stable, recommended)', value: 'gemini-3.8-flash' },
+          { title: 'Gemini 3.7 Flash (previous stable)', value: 'gemini-3.7-flash' },
+          { title: 'Gemini 3.6 Flash (stable, token-efficient)', value: 'gemini-3.6-flash' },
+          { title: 'Gemini 3.5 Flash-Lite (fastest, cost-efficient)', value: 'gemini-3.5-flash-lite' },
+          { title: 'Gemini 3.1 Pro Preview (complex reasoning)', value: 'gemini-3.1-pro-preview' },
+          { title: 'Gemini 2.5 Pro (legacy)', value: 'gemini-2.5-pro' },
+          { title: 'Gemini 2.5 Flash (legacy)', value: 'gemini-2.5-flash' },
+          { title: 'Gemini 2.5 Flash-Lite (legacy)', value: 'gemini-2.5-flash-lite' },
         ],
-        // Keep prior selection if present; default to fast/cost-effective Flash.
-        initial: pickInitialIndex(models, config.model, 'gemini-2.5-flash')
+        // Keep prior selection if present; otherwise use the latest stable model.
+        initial: pickInitialIndex(models, config.model, 'gemini-3.8-flash')
       });
 
       config.model = geminiModel;

package/bin/initHelpers.js

@@ -60,6 +60,7 @@ export function defaultConfig(rootBasename) {
     addTags: [],
     dom: {
       listItemLimit: 3,
+      automaticLimit: 15000,
     },
     resourceGuard: {
       enabled: true,
@@ -115,9 +116,14 @@ export function openAIModels() {
  */
 export function geminiModels() {
   return [
-    'gemini-2.5-pro',        // best reasoning, tool use
-    'gemini-2.5-flash',      // fast, cost-effective
-    'gemini-2.5-flash-lite', // lightweight / high throughput
+    'gemini-3.8-flash',       // latest stable agentic model
+    'gemini-3.7-flash',       // previous stable agentic model
+    'gemini-3.6-flash',       // stable, token-efficient
+    'gemini-3.5-flash-lite',  // lightweight / high throughput
+    'gemini-3.1-pro-preview', // highest-quality preview
+    'gemini-2.5-pro',         // legacy reasoning model
+    'gemini-2.5-flash',       // legacy fast model
+    'gemini-2.5-flash-lite',  // legacy lightweight model
   ];
 }
 

package/core/agent.js

@@ -25,9 +25,10 @@
 import 'dotenv/config';
 import { ChromeBrowser } from '../tools/chromeBrowser.js';
 import { turnLoop } from './turnLoop.js';
-import { createEmptyGroundControl, summarizeGroundControlForPrompt } from '../tools/contextControl.js';
+import { applyGroundControlUpdate, createEmptyGroundControl, summarizeGroundControlForPrompt } from '../tools/contextControl.js';
 import fs from 'fs';
 import path from 'path';
+import { hasCompletedLaunchProtocol, markLaunchProtocolCompleted } from './launchProtocol.js';
 
 /**
  * Execute goals with a browser agent.
@@ -36,7 +37,7 @@ import path from 'path';
  * @param {string} missionName
  * @param {number} [maxTurns=20] - upper bound for turnLoop per goal
  * @param {number} [retryLimit]
- * @param {{ domListLimit?: number|typeof Infinity, debug?: boolean, resourceGuard?: { enabled:boolean, hrefIncludes:string[], dataTypes:string[] }, humanInput?: { enabled:boolean, timeoutSeconds:number } }} [opts]
+ * @param {{ domListLimit?: number|typeof Infinity, automaticDomLimit?: number, storageStatePath?: string, debug?: boolean, resourceGuard?: { enabled:boolean, hrefIncludes:string[], dataTypes:string[] }, humanInput?: { enabled:boolean, timeoutSeconds:number } }} [opts]
  * @returns {Promise<Array<{missionName:string, submissionType:string, submissionName:string|null, status:'passed'|'failed', steps:any[], startTime:number, endTime:number}>>}
  */
 export async function runAgent(goals, missionName, maxTurns = 20, retryLimit, opts = {}) {
@@ -44,6 +45,7 @@ export async function runAgent(goals, missionName, maxTurns = 20, retryLimit, op
     domListLimit: opts.domListLimit,
     debug: opts.debug,
     resourceGuard: opts.resourceGuard,
+    storageStatePath: opts.storageStatePath,
   });
   await browser.start();
   let result;
@@ -57,6 +59,7 @@ export async function runAgent(goals, missionName, maxTurns = 20, retryLimit, op
     const groundControl = createEmptyGroundControl();
 
     for (const goal of goals) {
+      const telemetryStart = groundControl.telemetry.length;
       const steps = [];
       const stepsArchive = [];
       // Unique-ish JSONL file for this mission’s steps
@@ -67,6 +70,69 @@ export async function runAgent(goals, missionName, maxTurns = 20, retryLimit, op
       // Start clean
       fs.writeFileSync(stepFile, '');
 
+      let protocolResult = null;
+      const protocol = goal.launchProtocol;
+      const sharedAuth = process.env.TESTRONAUT_SESSION_MODE === 'shared-auth';
+      if (protocol && sharedAuth && hasCompletedLaunchProtocol(protocol.id)) {
+        let probeResult;
+        try {
+          probeResult = await browser.probe(protocol.probe);
+        } catch (error) {
+          probeResult = { passed: false, reason: error?.message || String(error) };
+        }
+
+        if (probeResult.passed) {
+          const currentUrl = probeResult.url || protocol.probe.url || null;
+          applyGroundControlUpdate(groundControl, {
+            app: {
+              baseUrl: protocol.probe.url || currentUrl,
+              currentUrl,
+              routeRole: 'authenticated',
+            },
+            session: { loggedIn: true },
+            navigation: { currentLabel: `Launch protocol ${protocol.id} verified` },
+            constraints: { stayWithinBaseUrl: true },
+          });
+          const now = Date.now();
+          const step = {
+            turn: 0,
+            events: [`📡 Launch protocol probe passed: ${protocol.id}`],
+            result: '✅ Mission Success',
+            summary: `Reused launch protocol ${protocol.id}`,
+            missionName,
+            tokensUsed: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+          };
+          fs.appendFileSync(stepFile, JSON.stringify(step) + '\n');
+          missionResults.push({
+            missionName,
+            submissionType: goal.submissionType || goal.label,
+            submissionName: goal.submissionName || null,
+            status: 'passed',
+            steps: [step],
+            stepFile,
+            startTime: now,
+            endTime: now,
+            telemetry: [],
+            launchProtocol: { id: protocol.id, status: 'reused', probe: 'passed' },
+          });
+          continue;
+        }
+        protocolResult = {
+          id: protocol.id,
+          status: 'executed',
+          probe: 'failed',
+          reason: probeResult.reason,
+        };
+      } else if (protocol) {
+        protocolResult = {
+          id: protocol.id,
+          status: 'executed',
+          probe: sharedAuth ? 'not-needed' : 'disabled',
+        };
+      }
+
       // Ensure user message is a string (functions/objects → toString fallback)
       const userContent =
         typeof goal.goal === 'string'
@@ -197,6 +263,7 @@ Email invitation and magic links:
           groundControl,
           resourceGuard: opts.resourceGuard,
           humanInput: opts.humanInput,
+          automaticDomLimit: opts.automaticDomLimit,
           onStep: (s) => {
             // Append each step as a JSON line
             try {
@@ -232,8 +299,14 @@ Email invitation and magic links:
         stepFile, // full history is in this JSONL (one step per line)
         startTime: Date.now() - 1, // TODO: wire actual timings if needed
         endTime: Date.now(),
+        telemetry: JSON.parse(JSON.stringify(groundControl.telemetry.slice(telemetryStart))),
+        ...(protocolResult ? { launchProtocol: protocolResult } : {}),
       });
 
+      if (protocol && result?.success) {
+        markLaunchProtocolCompleted(protocol.id);
+      }
+
       if (!result?.success) {
         console.log('🛑 Agent stopped due to failed goal.\n');
         return missionResults;

package/core/config.js

@@ -130,6 +130,22 @@ export function getDomListLimit(cfg, fallback = 3) {
   return { ...fbParsed, source: 'default' };
 }
 
+/** Resolve the character limit for automatic DOM snapshots injected after actions. */
+export function getAutomaticDomLimit(cfg, fallback = 15000) {
+  const parse = raw => {
+    if (raw === undefined || raw === null || String(raw).trim() === '') return null;
+    const value = Number(raw);
+    if (!Number.isFinite(value)) return null;
+    const clamped = Math.min(100000, Math.max(1000, Math.trunc(value)));
+    return { value: clamped, clamped: clamped !== value };
+  };
+  const env = parse(process.env.TESTRONAUT_AUTO_DOM_LIMIT);
+  if (env) return { ...env, source: 'env' };
+  const configured = parse(cfg?.dom?.automaticLimit ?? cfg?.automaticDomLimit);
+  if (configured) return { ...configured, source: 'config' };
+  return { ...parse(fallback), source: 'default' };
+}
+
 /**
  * Resolve resource guard settings for generic list/table harvesting.
  * - Patterns are used to detect resource anchors/data attributes.

package/core/launchProtocol.js

@@ -0,0 +1,42 @@
+const completedProtocols = new Set();
+
+/**
+ * Add optional shared-session reuse metadata to an ordinary mission goal.
+ * The wrapped goal remains string-coercible for backward compatibility.
+ */
+export function launchProtocol(goal, { id, probe } = {}) {
+  const protocolId = String(id || '').trim();
+  if (!protocolId) throw new Error('launchProtocol requires a non-empty id.');
+  if (!probe || (!probe.selector && !probe.text)) {
+    throw new Error('launchProtocol requires a probe selector or text value.');
+  }
+
+  return Object.freeze({
+    __testronautLaunchProtocol: true,
+    goal,
+    protocol: Object.freeze({
+      id: protocolId,
+      probe: Object.freeze({ ...probe }),
+    }),
+    toString() {
+      return typeof goal === 'string' ? goal : goal?.toString?.() ?? String(goal);
+    },
+  });
+}
+
+export function unwrapLaunchProtocol(value) {
+  if (!value?.__testronautLaunchProtocol) return { goal: value, protocol: null };
+  return { goal: value.goal, protocol: value.protocol };
+}
+
+export function hasCompletedLaunchProtocol(id) {
+  return completedProtocols.has(id);
+}
+
+export function markLaunchProtocolCompleted(id) {
+  completedProtocols.add(id);
+}
+
+export function resetLaunchProtocols() {
+  completedProtocols.clear();
+}

package/core/turnLoop.js

@@ -190,14 +190,15 @@ function formatBytes(n) {
  * @param {object} agentMemory - Memory object storing recent agent state.
  * @param {{skipIfLastTool?: string[]}} opts - Optional tool skip conditions.
  */
-const pushDOMAssistant = async (browser, messages, agentMemory, { skipIfLastTool } = {}) => {
+const pushDOMAssistant = async (browser, messages, agentMemory, { skipIfLastTool, limit = 15000 } = {}) => {
   // Avoid redundant DOM pushes immediately following tools that already include DOM context.
   if (skipIfLastTool && skipIfLastTool.includes(messages.at(-1)?.name)) {
     console.log(`[skip] Skipping DOM push after redundant tool: ${messages.at(-1)?.name}`);
-    return;
+    return { injected: false, domLength: 0 };
   }
 
   const domCallId = `get_dom_${Date.now()}`;
+  const automaticDomLimit = limit;
 
   // Inject a synthetic assistant tool call
   messages.push({
@@ -208,13 +209,17 @@ const pushDOMAssistant = async (browser, messages, agentMemory, { skipIfLastTool
         type: 'function',
         function: {
           name: 'get_dom',
-          arguments: JSON.stringify({ limit: 100000, exclude: true }),
+          arguments: JSON.stringify({ limit: automaticDomLimit, exclude: true }),
         },
       },
     ],
   });
 
-  const domHtml = await CHROME_TOOL_MAP.get_dom(browser, { limit: 100000, exclude: true }, agentMemory);
+  const domHtml = await CHROME_TOOL_MAP.get_dom(
+    browser,
+    { limit: automaticDomLimit, exclude: true },
+    agentMemory
+  );
   await tokenEstimate(MODEL_ID, domHtml);
 
   // Push the corresponding tool response back into the conversation
@@ -225,6 +230,11 @@ const pushDOMAssistant = async (browser, messages, agentMemory, { skipIfLastTool
     type: 'function',
     content: typeof domHtml === 'string' ? domHtml : JSON.stringify(domHtml),
   });
+
+  return {
+    injected: true,
+    domLength: typeof domHtml === 'string' ? domHtml.length : JSON.stringify(domHtml).length,
+  };
 };
 
 /**
@@ -427,6 +437,8 @@ export const turnLoop = async (
       const tokensUsed = usage.total_tokens || 0;
       console.log(`📊 Token Usage This Turn → Total: ${tokensUsed}`);
       step.tokensUsed = tokensUsed;
+      step.inputTokens = usage.input_tokens ?? usage.prompt_tokens ?? usage.providerRaw?.input_tokens ?? usage.providerRaw?.prompt_tokens;
+      step.outputTokens = usage.output_tokens ?? usage.completion_tokens ?? usage.providerRaw?.output_tokens ?? usage.providerRaw?.completion_tokens;
       recordTokenUsage(turnTimestamps, tokensUsed);
       ({ turnTimestamps, totalTokensUsed } = pruneOldTokenUsage(turnTimestamps));
       console.log(`📈 Running Total Tokens Used (Rolling 60s): ${totalTokensUsed}`);
@@ -449,13 +461,14 @@ export const turnLoop = async (
       console.log('Processing tool calls...');
       const toolResponses = [];
       let hadToolIssues = false;
+      let domRefreshSource = null;
 
       for (const call of msg.tool_calls) {
         const fnName = call.function.name;
         const args = JSON.parse(call.function.arguments || '{}');
         const safeArgs = redactArgs(fnName, args);
         console.log(`[model] → ${fnName}`, safeArgs);
-        step.events.push(`[model] → ${fnName} ${safeArgs}`);
+        step.events.push(`[model] → ${fnName} ${JSON.stringify(safeArgs)}`);
 
         let result;
         let errorMessage = null;
@@ -796,26 +809,30 @@ export const turnLoop = async (
           content: contentForModel,
         });
 
-        // After interactive DOM actions, refresh model context
-        if (['click_text', 'click', 'expand_menu'].includes(fnName)) {
-          console.log(`[auto] → Injecting DOM after ${fnName}...`);
-          step.events.push(`[auto] → Injecting DOM after ${fnName}...`);
-          const domHtml = await CHROME_TOOL_MAP.get_dom(browser, {
-            limit: 100000,
-            exclude: true,
-            focus: [],
-          }, agentMemory);
-          await tokenEstimate(MODEL_ID, domHtml);
-          await pushDOMAssistant(browser, messages, agentMemory, {
-            skipIfLastTool: ['get_dom', 'check_text'],
-          });
-          console.log(`[auto] → DOM size after ${fnName}: ${domHtml.length} chars`);
-          step.events.push(`[auto] → DOM size after ${fnName}: ${domHtml.length} chars`);
+        // Defer automatic DOM injection until the originating assistant call
+        // and all of its function responses are in history. Gemini requires a
+        // model functionCall to immediately follow user content or a
+        // functionResponse; inserting it before `msg` would create adjacent,
+        // reversed model function-call turns.
+        if (!errorMessage && ['click_text', 'click', 'expand_menu'].includes(fnName)) {
+          domRefreshSource = fnName;
         }
       }
 
       // Merge new assistant + tool responses back into conversation
       messages.push(msg, ...toolResponses);
+      if (domRefreshSource && !hadToolIssues) {
+        console.log(`[auto] → Injecting DOM after ${domRefreshSource}...`);
+        step.events.push(`[auto] → Injecting DOM after ${domRefreshSource}...`);
+        const domRefresh = await pushDOMAssistant(browser, messages, agentMemory, {
+          skipIfLastTool: ['get_dom', 'check_text'],
+          limit: ctx.automaticDomLimit,
+        });
+        if (domRefresh?.injected) {
+          console.log(`[auto] → DOM size after ${domRefreshSource}: ${domRefresh.domLength} chars`);
+          step.events.push(`[auto] → DOM size after ${domRefreshSource}: ${domRefresh.domLength} chars`);
+        }
+      }
       if (hadToolIssues && turnRetries < retryLimitClamped) {
         step.result = '⏳ Retrying turn';
         const retryNumber = attempt - 1;
@@ -870,6 +887,7 @@ export const turnLoop = async (
     // ─────────────────────────────────────────────
     await pushDOMAssistant(browser, messages, agentMemory, {
       skipIfLastTool: ['get_dom', 'check_text'],
+      limit: ctx.automaticDomLimit,
     });
     console.log(`[auto] → Injected DOM for next reasoning step`);
     step.events.push(`[auto] → Injected DOM for next reasoning step`);

package/llm/anthropic/anthropicProvider.js

@@ -112,6 +112,8 @@ export class AnthropicProvider {
 
     const usage = {
       total_tokens: (response.usage?.input_tokens ?? 0) + (response.usage?.output_tokens ?? 0),
+      input_tokens: response.usage?.input_tokens,
+      output_tokens: response.usage?.output_tokens,
       providerRaw: response.usage,
     };
     return { message: fromAnthropicMessage(response), usage };