testronaut 1.9.3 → 1.9.4

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.

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

@@ -115,9 +115,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/turnLoop.js

@@ -194,10 +194,11 @@ const pushDOMAssistant = async (browser, messages, agentMemory, { skipIfLastTool
   // 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 = 15000;
 
   // 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,
+  };
 };
 
 /**
@@ -449,6 +459,7 @@ 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;
@@ -796,26 +807,29 @@ 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'],
+        });
+        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;

package/llm/gemini/geminiProvider.js

@@ -28,6 +28,13 @@
 
 import { GoogleGenerativeAI } from '@google/generative-ai';
 
+// Gemini 3 validates thought signatures on function calls in the current turn.
+// Calls synthesized by Testronaut (for example, automatic get_dom calls) were
+// not emitted by Gemini and therefore have no real signature to preserve.
+// Google documents this sentinel specifically for deterministic client-injected
+// function-call history.
+const SYNTHETIC_THOUGHT_SIGNATURE = 'skip_thought_signature_validator';
+
 /**
  * Convert OpenAI-like messages → Gemini "contents" array.
  * - System messages are coalesced and injected as a prefix into the next user turn.
@@ -49,29 +56,41 @@ function toGeminiContents(messages) {
       continue;
     }
 
+    // Gemini 3 requires thought signatures to be returned exactly where the
+    // model emitted them. Prefer the untouched provider parts when available.
+    const geminiParts = m.provider_metadata?.gemini?.parts;
+    if (m.role === 'assistant' && Array.isArray(geminiParts) && geminiParts.length) {
+      contents.push({ role: 'model', parts: geminiParts });
+      continue;
+    }
+
     // Assistant tool calls → Gemini functionCall parts on a model turn
     if (m.role === 'assistant' && Array.isArray(m.tool_calls) && m.tool_calls.length) {
       contents.push({
         role: 'model',
-        parts: m.tool_calls.map(tc => ({
+        parts: m.tool_calls.map((tc, index) => ({
           functionCall: {
             name: tc.function?.name,
             args: safeJsonParse(tc.function?.arguments) ?? {},
           },
+          // For parallel calls Gemini expects the signature only on the first
+          // functionCall part. Genuine provider parts take the branch above and
+          // retain their original signatures instead of receiving this sentinel.
+          ...(index === 0 ? { thoughtSignature: SYNTHETIC_THOUGHT_SIGNATURE } : {}),
         })),
       });
       continue;
     }
 
-    // Tool results → encode as a user turn with a JSON part the model can parse
+    // Tool results → Gemini function responses. This keeps function-calling
+    // history valid for Gemini 3 and gives earlier models structured results.
     if (m.role === 'tool') {
+      const parsed = safeJsonParse(m.content);
       const parts = [{
-        text: JSON.stringify({
-          _tool_result: true,
-          tool_call_id: m.tool_call_id,
+        functionResponse: {
           name: m.name,
-          content: m.content,
-        }),
+          response: parsed ?? { result: m.content },
+        },
       }];
       contents.push({ role: 'user', parts });
       continue;
@@ -148,7 +167,14 @@ function fromGeminiCandidate(cand) {
   }
 
   const content = texts.join('');
-  return { role: 'assistant', content, tool_calls: tool_calls.length ? tool_calls : undefined };
+  return {
+    role: 'assistant',
+    content,
+    tool_calls: tool_calls.length ? tool_calls : undefined,
+    // Retain all parts, including Gemini 3 thought signatures and function IDs,
+    // so the next request can replay them without lossy format conversion.
+    provider_metadata: { gemini: { parts } },
+  };
 }
 
 function cryptoRandomId() {

package/package.json

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

package/tests/binTests/initHelpersTests/models.test.js

@@ -15,13 +15,19 @@ describe('model helpers', () => {
       'gpt-5.6-luna',
     ]));
     expect(openAIModels()).not.toContain('gpt-5.3');
-    expect(geminiModels()).toContain('gemini-2.5-flash');
+    expect(geminiModels()).toEqual(expect.arrayContaining([
+      'gemini-3.8-flash',
+      'gemini-3.5-flash-lite',
+      'gemini-3.1-pro-preview',
+      'gemini-2.5-flash',
+    ]));
     expect(anthropicModels()).toContain('claude-sonnet-5');
   });
 
   it('recognizes known models by provider', () => {
     expect(isKnownModel('openai', 'gpt-4.1-mini')).toBe(true);
     expect(isKnownModel('gemini', 'gpt-4.1-mini')).toBe(false);
+    expect(isKnownModel('gemini', 'gemini-3.8-flash')).toBe(true);
     expect(isKnownModel('anthropic', 'claude-sonnet-5')).toBe(true);
   });
 

package/tests/coreTests/turnLoop.test.js

@@ -205,6 +205,27 @@ describe('turnLoop', () => {
     expect(step1.result).toBe('✅ Passed');
     expect(shared.chromeToolSpies.click_text).toHaveBeenCalledTimes(1);
     expect(shared.chromeToolSpies.get_dom).toHaveBeenCalled();
+    expect(shared.chromeToolSpies.get_dom).toHaveBeenCalledWith(
+      browser,
+      expect.objectContaining({ limit: 15000, exclude: true }),
+      expect.any(Object)
+    );
+
+    const secondRequestMessages = shared.chatMock.mock.calls[1][0].messages;
+    const clickCallIndex = secondRequestMessages.findIndex(message =>
+      message.role === 'assistant' && message.tool_calls?.[0]?.function?.name === 'click_text'
+    );
+    expect(secondRequestMessages.slice(clickCallIndex, clickCallIndex + 4).map(message => ({
+      role: message.role,
+      tool: message.tool_calls?.[0]?.function?.name ?? message.name,
+    }))).toEqual([
+      { role: 'assistant', tool: 'click_text' },
+      { role: 'tool', tool: 'click_text' },
+      { role: 'assistant', tool: 'get_dom' },
+      { role: 'tool', tool: 'get_dom' },
+    ]);
+    expect(JSON.parse(secondRequestMessages[clickCallIndex + 2].tool_calls[0].function.arguments))
+      .toEqual({ limit: 15000, exclude: true });
 
     const step2 = res.steps[1];
     expect(step2.result).toMatch(/Success/);

package/tests/llmTests/geminiProvider.test.js

@@ -146,14 +146,17 @@ describe('GeminiProvider', () => {
 
     // 2) Assistant tool call → model role with functionCall
     expect(c[1].role).toBe('model');
-    expect(c[1].parts[0].functionCall).toEqual({ name: 'search', args: { q: 'x' } });
+    expect(c[1].parts[0]).toEqual({
+      functionCall: { name: 'search', args: { q: 'x' } },
+      thoughtSignature: 'skip_thought_signature_validator',
+    });
 
-    // 3) Tool result → user role with JSON marker
+    // 3) Tool result → structured Gemini function response
     expect(c[2].role).toBe('user');
-    const toolJson = JSON.parse(c[2].parts[0].text);
-    expect(toolJson._tool_result).toBe(true);
-    expect(toolJson.tool_call_id).toBe('1');
-    expect(toolJson.name).toBe('search');
+    expect(c[2].parts[0].functionResponse).toEqual({
+      name: 'search',
+      response: { results: [1, 2, 3] },
+    });
 
     // 4) Final assistant text → model role with text
     expect(c[3].role).toBe('model');
@@ -168,7 +171,10 @@ describe('GeminiProvider', () => {
           {
             content: {
               parts: [
-                { functionCall: { name: 'open', args: { url: 'https://example.com' } } },
+                {
+                  functionCall: { name: 'open', args: { url: 'https://example.com' } },
+                  thoughtSignature: 'encrypted-signature',
+                },
                 { text: 'Ok!' },
               ],
             },
@@ -189,11 +195,87 @@ describe('GeminiProvider', () => {
     expect(Array.isArray(message.tool_calls)).toBe(true);
     expect(message.tool_calls[0].function.name).toBe('open');
     expect(JSON.parse(message.tool_calls[0].function.arguments)).toEqual({ url: 'https://example.com' });
+    expect(message.provider_metadata.gemini.parts[0].thoughtSignature).toBe('encrypted-signature');
 
     expect(usage.total_tokens).toBe(999);
     expect(usage.providerRaw).toEqual({ totalTokenCount: 999, other: 'meta' });
   });
 
+  it('replays Gemini response parts so thought signatures survive tool loops', async () => {
+    const prov = new GeminiProvider({ apiKey: 'gk-xyz' });
+    const signedPart = {
+      functionCall: { name: 'click', args: { selector: '#submit' } },
+      thoughtSignature: 'opaque-signature',
+    };
+
+    await prov.chat({
+      model: 'gemini-3.8-flash',
+      messages: [
+        { role: 'user', content: 'Submit the form' },
+        {
+          role: 'assistant',
+          content: '',
+          tool_calls: [{ type: 'function', function: { name: 'click', arguments: '{"selector":"#submit"}' } }],
+          provider_metadata: { gemini: { parts: [signedPart] } },
+        },
+        { role: 'tool', name: 'click', content: 'Clicked' },
+      ],
+    });
+
+    expect(shared.lastContents[1]).toEqual({ role: 'model', parts: [signedPart] });
+    expect(shared.lastContents[2].parts[0].functionResponse).toEqual({
+      name: 'click',
+      response: { result: 'Clicked' },
+    });
+  });
+
+  it('signs deterministic client-injected function calls for Gemini 3 history', async () => {
+    const prov = new GeminiProvider({ apiKey: 'gk-xyz' });
+
+    await prov.chat({
+      model: 'gemini-3.8-flash',
+      messages: [
+        { role: 'user', content: 'Open the dashboard' },
+        {
+          role: 'assistant',
+          content: '',
+          tool_calls: [{
+            id: 'synthetic-dom',
+            type: 'function',
+            function: { name: 'get_dom', arguments: '{"selector":"main"}' },
+          }],
+        },
+        { role: 'tool', tool_call_id: 'synthetic-dom', name: 'get_dom', content: '<main>Dashboard</main>' },
+      ],
+    });
+
+    expect(shared.lastContents[1].parts[0]).toEqual({
+      functionCall: { name: 'get_dom', args: { selector: 'main' } },
+      thoughtSignature: 'skip_thought_signature_validator',
+    });
+  });
+
+  it('adds the synthetic signature only to the first parallel function call', async () => {
+    const prov = new GeminiProvider({ apiKey: 'gk-xyz' });
+
+    await prov.chat({
+      model: 'gemini-3.8-flash',
+      messages: [
+        { role: 'user', content: 'Inspect both regions' },
+        {
+          role: 'assistant',
+          tool_calls: [
+            { type: 'function', function: { name: 'get_dom', arguments: '{"selector":"main"}' } },
+            { type: 'function', function: { name: 'get_dom', arguments: '{"selector":"nav"}' } },
+          ],
+        },
+      ],
+    });
+
+    expect(shared.lastContents[1].parts[0].thoughtSignature).toBe('skip_thought_signature_validator');
+    expect(shared.lastContents[1].parts[1].thoughtSignature).toBeUndefined();
+  });
+
   it('supports image parts (encoded to inlineData)', async () => {
     const prov = new GeminiProvider({ apiKey: 'gk-xyz' });
 

package/tests/toolsTests/contextControl.test.js

@@ -109,6 +109,38 @@ describe('pruneConversationContext', () => {
     expect(nonSystem.map(m => m.content)).toEqual(['u-2', 'a-2']);
   });
 
+  it('keeps the latest real user instruction as an anchor for long tool histories', () => {
+    const messages = [
+      { role: 'system', content: 'system' },
+      { role: 'user', content: 'Complete the mission' },
+    ];
+
+    for (let i = 0; i < 25; i += 1) {
+      messages.push({
+        role: 'assistant',
+        tool_calls: [{
+          id: `call-${i}`,
+          type: 'function',
+          function: { name: 'get_dom', arguments: '{}' },
+        }],
+      });
+      messages.push({
+        role: 'tool',
+        tool_call_id: `call-${i}`,
+        name: 'get_dom',
+        content: `<main>${i}</main>`,
+      });
+    }
+
+    const pruned = pruneConversationContext(messages, { maxNonSystemMessages: 10 });
+
+    expect(pruned[0]).toEqual({ role: 'system', content: 'system' });
+    expect(pruned[1]).toEqual({ role: 'user', content: 'Complete the mission' });
+    expect(pruned.slice(2)).toHaveLength(10);
+    expect(pruned[2].role).toBe('assistant');
+    expect(pruned[3].role).toBe('tool');
+  });
+
   it('drops tool messages whose parent assistant tool_calls were pruned', () => {
     const messages = [
       // Old assistant + tool (should be pruned)
@@ -592,4 +624,4 @@ describe('summarizeGroundControlForPrompt', () => {
     expect(snapshot.navigation.routeRole).toBe('dashboard');
     expect(snapshot.navigation.currentLabel).toBe('Main dashboard');
   });
-});
+});

package/tests/toolsTests/toolSchema.test.js

@@ -2,6 +2,9 @@ import { describe, it, expect } from 'vitest';
 import toolsSchema from '../../tools/toolSchema.js';
 
 describe('tools/toolSchema', () => {
+  it('does not advertise the unimplemented get_dom_chunk tool', () => {
+    expect(toolsSchema.map(tool => tool.function.name)).not.toContain('get_dom_chunk');
+  });
   it('includes resource_progress tool with empty params', () => {
     const entry = toolsSchema.find(t => t.function?.name === 'resource_progress');
     expect(entry?.type).toBe('function');

package/tests/toolsTests/turnLoopUtils.test.js

@@ -2,6 +2,22 @@ import { describe, it, expect, vi } from 'vitest';
 import { finalResponseHandler } from '../../tools/turnLoopUtils.js';
 
 describe('tools/turnLoopUtils', () => {
+  it.each([
+    ['SUCCESS: completed', true],
+    ['FAILURE: blocked', false],
+    ['RESULT: SUCCESS - all checkpoints passed', true],
+    ['RESULT: FAILURE - checkpoint failed', false],
+    ['FINAL: success', true],
+    ['**RESULT: SUCCESS**', true],
+  ])('recognizes supported verdict form %s', (content, success) => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      expect(finalResponseHandler({ content })).toMatchObject({ success });
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
   it('redacts verification codes before printing and returning final responses', () => {
     const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
 

package/tools/contextControl.js

@@ -44,6 +44,7 @@ export function sanitizeHeavyToolHistory(messages, { keepRecentPerTool = 2 } = {
  *
  * Strategy:
  *   - Always keep all system messages.
+ *   - Always keep the latest real user instruction as a protocol anchor.
  *   - Start from the end and keep the last `maxNonSystemMessages` non-system messages.
  *   - Ensure protocol correctness:
  *       * If a tool message is kept, its parent assistant with matching tool_call_id
@@ -63,6 +64,15 @@ export function pruneConversationContext(messages, { maxNonSystemMessages = 40 }
   // Take last N non-system messages (raw window)
   const tail = nonSystem.slice(-maxNonSystemMessages);
 
+  // Gemini function-calling validation locates the current turn by scanning
+  // backward for a normal user message (not a function response). Testronaut's
+  // internal tool results use role `tool`, so retain the newest role `user`
+  // message even when a long agent loop pushes it outside the rolling tail.
+  // This is also useful context for OpenAI and Anthropic: it is the instruction
+  // the retained tool activity is attempting to satisfy.
+  const latestUser = nonSystem.findLast(m => m.role === 'user');
+  const userAnchor = latestUser && !tail.includes(latestUser) ? [latestUser] : [];
+
   // Pass 1: build map of tool_call_id -> index of assistant in tail
   const assistantToolParents = new Map(); // tool_call_id -> index in tail
   tail.forEach((m, idx) => {
@@ -93,7 +103,7 @@ export function pruneConversationContext(messages, { maxNonSystemMessages = 40 }
     cleanedTail.push(m);
   }
 
-  return [...systemMessages, ...cleanedTail];
+  return [...systemMessages, ...userAnchor, ...cleanedTail];
 }
 
 /* ---------------- Ground Control state helpers ----------------

package/tools/tokenControl.js

@@ -85,13 +85,13 @@ function getTokenizer(model) {
   } catch (_) {
     const m = String(model || '').toLowerCase();
 
-    // Treat Gemini 2.5 like modern long-context models
-    const isGemini25 = /^gemini-2\.5/.test(m);
+    // Treat current Gemini generations like modern long-context models.
+    const isGemini = /^gemini-(?:2\.5|3(?:\.|-))/.test(m);
     const isClaude = /^claude-/.test(m);
 
     // OpenAI modern families also map well to o200k_base
     const useO200k =
-      isGemini25 ||
+      isGemini ||
       isClaude ||
       m.startsWith('gpt-5') ||
       m.startsWith('gpt-4o') ||

package/tools/toolSchema.js

@@ -154,21 +154,6 @@ const toolsSchema = [
   //     }
   //   }
   // },
-  {
-    type: 'function',
-    function: {
-      name: 'get_dom_chunk',
-      description: 'Return a specific chunk of the DOM by index',
-      parameters: {
-        type: 'object',
-        properties: {
-          chunkIndex: { type: 'number' },
-          totalChunks: { type: 'number' }
-        },
-        required: ['chunkIndex', 'totalChunks']
-      }
-    }
-  },
   {
     type: 'function',
     function: {

package/tools/turnLoopUtils.js

@@ -3,14 +3,15 @@ import { redactPasswordInText } from '../core/redaction.js';
 export const finalResponseHandler = (msg) => {
   const content = String(msg.content ?? '');
   const safeContent = redactPasswordInText(content);
-  const final = content.trim().toLowerCase();
-  if (final?.startsWith('success')) {
+  const final = content.trim().replace(/^[#*_`\s]+/, '');
+  const verdict = final.match(/^(?:(?:result|final)\s*:\s*)?(success|failure)\b/i)?.[1]?.toLowerCase();
+  if (verdict === 'success') {
     console.log('\n┏━ FINAL AGENT RESPONSE ━━━━━━━━━━━━━━━━━━━');
     console.log(safeContent);
     console.log('┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
     return { finalMessage: safeContent, success: true};
   }
-  if (final?.startsWith('failure')) {
+  if (verdict === 'failure') {
     console.log('\n┏━ FINAL AGENT RESPONSE ━━━━━━━━━━━━━━━━━━━');
     console.log(safeContent);
     console.log('┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');