testronaut 2.1.2 → 2.1.3

package/TODO.md

@@ -12,6 +12,7 @@
 ## Browser Automation Follow-Ups
 
 - [x] Make `click_text` match exact text, prefer the innermost visible element, and fail quickly instead of clicking an ancestor or partial match.
+- [ ] Complete `press_key` turn-loop integration: classify it as fire-and-forget, automatically inject the updated DOM after successful key presses, and test that Enter/Escape state changes are available to the next reasoning turn without an explicit `get_dom` call.
 - [ ] Replace framework/vendor-specific DOM class stripping with a framework-agnostic classifier that removes generated hashes, styling utilities, variants, and arbitrary selectors while preserving semantic component classes. Reconsider broad prefix rules such as `/^cl-/`, cap retained class count and length, and add representative fixtures for Tailwind, MUI, Ant Design, Chakra, Clerk, CSS Modules, and CSS-in-JS.
 
 ## Session and Reporting Follow-Ups
@@ -27,9 +28,18 @@
 
 ## Optimization and Rate-Limit Follow-Ups
 
+- [ ] Reduce redundant screenshot capture in focused missions without weakening evidence: clarify or enforce when starting, transition, and final screenshots materially differ, and measure the effect on turns, tokens, and report usefulness.
 - [ ] Run a history-informed model-routing benchmark before expanding cross-provider routing. Give Jev versioned, per-model/per-mission-class reliability, token, latency, and price observations from prior runs; require a configurable reliability floor; compare against the best fixed-model-plus-guardrails control with blocked repetitions; keep selection at the mission boundary; record the evidence and reason for every choice; and define cold-start, stale-data, low-confidence, and provider-failure fallbacks. Do not retry a failed mission on another provider in the benchmark because that would confound routing quality with retry recovery.
 - [ ] Add an opt-in CLI/config policy that reroutes an imminent throttled LLM request to a compatible model as an alternative to the default backoff behavior. Keep backoff as the default; use observed TPM/RPM headroom and projected request tokens; constrain failover to explicitly configured provider/model families; preserve tool/history compatibility; prevent routing loops; fall back safely when the alternate model is unavailable; and record the original model, routed model, trigger, token usage, latency, and outcome in reports.
 
+## OpenAI Provider Follow-Ups
+
+- [ ] Migrate the OpenAI adapter from Chat Completions to the Responses API in a dedicated change. Preserve Testronaut's provider-neutral message and tool-call contract, add response-ID/reasoning-state handling, normalize usage and raw headers, and cover multi-turn tool continuation with unit and API smoke tests. Once migrated, remove the GPT-5.6 Chat Completions compatibility override that sets `reasoning_effort` to `none` for function-tool requests.
+- [ ] Add active context budgeting after its behavior is designed and tested. Use model context/output metadata to reserve response and reasoning capacity, then apply explicit history compaction or summarization rules. Do not silently truncate mission instructions, current DOM state, or unmatched tool calls.
+- [ ] Learn effective OpenAI TPM/RPM limits from successful response headers and rate-limit errors. Prefer observed project/model limits over inferring a named account tier; retain the environment override and conservative startup values.
+- [ ] Persist provider-observed rate limits in a separate, expiring local cache keyed by provider, API project/account, endpoint/region, model, and traffic type. Never rewrite user config or infer a named usage tier from a TPM value; expose configured, cached, and live sources distinctly and discard stale observations.
+- [ ] After dynamic rate limits are established, make DOM injection quota-aware. Budget DOM tokens against both remaining TPM and the model context window, preserve mission instructions and actionable controls, and fall back to semantic sections plus on-demand DOM chunks instead of silent truncation.
+
 ## Automated MFA Follow-Ups
 
 - [ ] Add an integration smoke test against a local or staging API fixture for `get_mfa_code`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testronaut",
-  "version": "2.1.2",
+  "version": "2.1.3",
   "main": "./runner/testronaut.js",
   "bin": {
     "testronaut": "bin/cli.js"

package/tests/toolsTests/chromeBrowserPressKey.test.js

@@ -0,0 +1,39 @@
+import { describe, expect, it, vi } from 'vitest';
+import { CHROME_TOOL_MAP, ChromeBrowser } from '../../tools/chromeBrowser.js';
+
+describe('ChromeBrowser.press_key', () => {
+  it('presses a key on the active page', async () => {
+    const browser = new ChromeBrowser();
+    browser.page = { keyboard: { press: vi.fn().mockResolvedValue(undefined) } };
+
+    await expect(browser.press_key({ key: 'Escape' })).resolves.toBe('pressed Escape');
+    expect(browser.page.keyboard.press).toHaveBeenCalledWith('Escape');
+  });
+
+  it('focuses a selected element before pressing Enter', async () => {
+    const browser = new ChromeBrowser();
+    const focus = vi.fn().mockResolvedValue(undefined);
+    const first = vi.fn().mockReturnValue({ focus });
+    browser.page = {
+      locator: vi.fn().mockReturnValue({ first }),
+      keyboard: { press: vi.fn().mockResolvedValue(undefined) },
+    };
+
+    await expect(browser.press_key({ key: 'Enter', selector: '#email' }))
+      .resolves.toBe('pressed Enter after focusing #email');
+
+    expect(browser.page.locator).toHaveBeenCalledWith('#email');
+    expect(first).toHaveBeenCalledOnce();
+    expect(focus).toHaveBeenCalledWith({ timeout: 3000 });
+    expect(browser.page.keyboard.press).toHaveBeenCalledWith('Enter');
+    expect(focus.mock.invocationCallOrder[0])
+      .toBeLessThan(browser.page.keyboard.press.mock.invocationCallOrder[0]);
+  });
+
+  it('is exposed through the browser tool dispatcher', async () => {
+    const press_key = vi.fn().mockResolvedValue('pressed Control+B');
+    await expect(CHROME_TOOL_MAP.press_key({ press_key }, { key: 'Control+B' }))
+      .resolves.toBe('pressed Control+B');
+    expect(press_key).toHaveBeenCalledWith({ key: 'Control+B' });
+  });
+});

package/tests/toolsTests/toolSchema.test.js

@@ -21,6 +21,12 @@ describe('tools/toolSchema', () => {
     const entry = toolsSchema.find(tool => tool.function.name === 'get_dom');
     expect(entry.function.parameters.properties.selector.type).toBe('string');
   });
+  it('includes press_key with a required key and optional selector', () => {
+    const entry = toolsSchema.find(tool => tool.function.name === 'press_key');
+    expect(entry?.function.parameters.required).toEqual(['key']);
+    expect(entry.function.parameters.properties.key.type).toBe('string');
+    expect(entry.function.parameters.properties.selector.type).toBe('string');
+  });
   it('exposes iframe targeting and iframe text search', () => {
     const fill = toolsSchema.find(tool => tool.function.name === 'fill');
     const click = toolsSchema.find(tool => tool.function.name === 'click');

package/tools/chromeBrowser.js

@@ -771,6 +771,18 @@ export class ChromeBrowser {
     }, { attempts: 3, baseMs: 250 });
   }
 
+  async press_key({ key, selector }) {
+    if (selector) {
+      const target = this.page.locator(selector).first();
+      await target.focus({ timeout: 3000 });
+    }
+
+    await this.page.keyboard.press(key);
+    return selector
+      ? `pressed ${key} after focusing ${selector}`
+      : `pressed ${key}`;
+  }
+
 
 
   /**
@@ -1525,6 +1537,7 @@ export const CHROME_TOOL_MAP = {
   reload: (b) => b.reload(),
   fill: (b, args) => b.fill(args),
   click: (b, args) => b.click(args),
+  press_key: (b, args) => b.press_key(args),
   get_dom: (b, args, agentMemory) => b.get_dom(args, agentMemory),
   check_text: (b, args) => b.check_text(args),
   click_text: async (browser, args, agentMemory) => {

package/tools/toolSchema.js

@@ -75,6 +75,27 @@ const toolsSchema = [
       },
     },
   },
+  {
+    type: 'function',
+    function: {
+      name: 'press_key',
+      description: 'Press a keyboard key or shortcut, optionally focusing an element by CSS selector first',
+      parameters: {
+        type: 'object',
+        properties: {
+          key: {
+            type: 'string',
+            description: 'Playwright key or shortcut, such as Enter, Escape, Control+B, or Meta+B',
+          },
+          selector: {
+            type: 'string',
+            description: 'Optional CSS selector of the element to focus before pressing the key',
+          },
+        },
+        required: ['key'],
+      },
+    },
+  },
   {
     type: 'function',
     function: {

package/todo.md

@@ -1,25 +0,0 @@
-# Testronaut CLI TODO
-
-## OpenAI provider follow-ups
-
-- Migrate the OpenAI adapter from Chat Completions to the Responses API in a
-  dedicated change. Preserve Testronaut's provider-neutral message and tool-call
-  contract, add response-ID/reasoning-state handling, normalize usage and raw
-  headers, and cover multi-turn tool continuation with unit and API smoke tests.
-  Once migrated, remove the GPT-5.6 Chat Completions compatibility override that
-  sets `reasoning_effort` to `none` for function-tool requests.
-- Add active context budgeting after its behavior is designed and tested. Use
-  model context/output metadata to reserve response and reasoning capacity, then
-  apply explicit history compaction or summarization rules. Do not silently
-  truncate mission instructions, current DOM state, or unmatched tool calls.
-- Learn effective OpenAI TPM/RPM limits from successful response headers and
-  rate-limit errors. Prefer observed project/model limits over inferring a named
-  account tier; retain the environment override and conservative startup values.
-- Persist provider-observed rate limits in a separate, expiring local cache keyed
-  by provider, API project/account, endpoint/region, model, and traffic type.
-  Never rewrite user config or infer a named usage tier from a TPM value; expose
-  configured, cached, and live sources distinctly and discard stale observations.
-- After dynamic rate limits are established, make DOM injection quota-aware.
-  Budget DOM tokens against both remaining TPM and the model context window,
-  preserve mission instructions and actionable controls, and fall back to
-  semantic sections plus on-demand DOM chunks instead of silent truncation.