testronaut 1.0.27 → 1.1.1

package/bin/cli.js

@@ -26,6 +26,27 @@ const apiBase = 'http://api.testronaut.app'; // Replace with your actual API bas
 
 
 const args = process.argv.slice(2);
+
+// Look for --model=<id> or --model <id>
+let modelOverride;
+const modelFlagIndex = args.findIndex(a => a === '--model' || a.startsWith('--model='));
+if (modelFlagIndex >= 0) {
+  if (args[modelFlagIndex].includes('=')) {
+    modelOverride = args[modelFlagIndex].split('=')[1];
+  } else if (args[modelFlagIndex + 1]) {
+    modelOverride = args[modelFlagIndex + 1];
+  }
+
+  if (modelOverride) {
+    process.env.TESTRONAUT_MODEL = modelOverride.trim();
+    console.log(`🧠 Model override: ${process.env.TESTRONAUT_MODEL}`);
+  }
+
+  // Remove flag & value from args so they don't look like mission filenames
+  args.splice(modelFlagIndex, modelOverride ? 2 : 1);
+}
+
+
 const missionsDir = path.resolve(process.cwd(), 'missions');
 
 const allResults = [];
@@ -165,10 +186,35 @@ const flatMissions = allResults.flatMap(entry => {
   }));
 });
 
+// Read provider/model from config (allow env override for model)
+const cfgPath = path.resolve(process.cwd(), 'testronaut-config.json');
+let llmProvider = 'openai';
+let llmModel = 'gpt-4o';
+
+if (fs.existsSync(cfgPath)) {
+  try {
+    const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+    if (cfg?.provider) llmProvider = String(cfg.provider);
+    if (cfg?.model) llmModel = String(cfg.model);
+  } catch (e) {
+    console.warn('⚠️ Could not read testronaut-config.json:', e.message);
+  }
+}
+
+// Env override takes precedence for the model (matches runtime behavior)
+if (process.env.TESTRONAUT_MODEL?.trim()) {
+  llmModel = process.env.TESTRONAUT_MODEL.trim();
+}
+
+
 const report = {
   runId,
   startTime: startTime.toISOString(),
   endTime: endTime.toISOString(),
+  llm: {
+    provider: llmProvider,
+    model: llmModel,
+  },
   summary: {
     totalMissions: flatMissions.length,
     passed: flatMissions.filter(m => m.status === 'passed').length,

package/bin/init.js

@@ -13,33 +13,76 @@ export async function initializeTestronautProject() {
   let config = {};
   if (fs.existsSync(configPath)) {
     config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+
+    // --- Back-compat migration: old configs stored provider in `model`
+    if (!config.provider && config.model === 'openai') {
+      config.provider = 'openai';
+      // don't overwrite model yet; we'll re-ask below only if not initialized
+    }
   }
 
   // If not initialized before, walk through setup
   if (!config.initialized) {
-    // Prompt for LLM
-    const response = await prompts({
+    // 1) Provider
+    const { llmProvider } = await prompts({
       type: 'select',
       name: 'llmProvider',
       message: 'Which LLM provider would you like to use?',
       choices: [
-        { title: 'OpenAI (GPT-4o)', value: 'openai' },
+        { title: 'OpenAI (GPT family)', value: 'openai' },
         // Add others like Anthropic, Mistral, etc. later
       ]
     });
 
-    config.model = response.llmProvider;
+    config.provider = llmProvider; // store provider explicitly
+
+    // 2) If OpenAI, ask for model
+    const { openaiModel } = await prompts({
+      type: 'select',
+      name: 'openaiModel',
+      message: 'Select an OpenAI model for agentic workflows (function/tool calling):',
+      choices: [
+        { title: 'GPT-4.1 (general purpose)', value: 'gpt-4.1' },
+        { title: 'GPT-4.1 mini (faster, cheaper)', value: 'gpt-4.1-mini' },
+        { title: 'GPT-4o (multimodal, tool use)', value: 'gpt-4o' },
+        { title: 'GPT-4o mini (speed/cost optimized)', value: 'gpt-4o-mini' },
+        { title: 'o3 (reasoning w/ native tool use)', value: 'o3' },
+        { title: 'o4-mini (reasoning, cost-effective)', value: 'o4-mini' },
+
+        // 👇 GPT-5 family
+        { title: 'GPT-5 (latest reasoning model)', value: 'gpt-5' },
+        { title: 'GPT-5 mini (faster)', value: 'gpt-5-mini' },
+        { title: 'GPT-5 nano (lightweight)', value: 'gpt-5-nano' },
+      ],
+      initial: 1
+    });
+
+    config.model = openaiModel;
+
+    // Warn about GPT-5 availability
+    if (openaiModel.startsWith('gpt-5')) {
+      console.log(`
+    ⚠️  Warning: GPT-5 support may not be available for all users.
+      - Access depends on your OpenAI account/region
+      - Some capabilities may be gated or rate-limited
+      `);
+    }
+
+    // Default config fields
     config.initialized = true;
-    config.outputDir = 'missions/mission_reports';
-    config.projectName = path.basename(root);
-    config.maxTurns = 20;
+    config.outputDir = config.outputDir || 'missions/mission_reports';
+    config.projectName = config.projectName || path.basename(root);
+    config.maxTurns = config.maxTurns ?? 20;
+
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
     console.log('📝 Created testronaut-config.json');
 
-    if (response.llmProvider === 'openai') {
-      // Display .env instructions
+    if (llmProvider === 'openai') {
+      // Display .env instructions for OpenAI
       if (!fs.existsSync(envPath)) {
-        const exampleEnv = `# Add your OpenAI API key below\nOPENAI_API_KEY=sk-...\n`;
+        const exampleEnv = `# Add your OpenAI API key below
+OPENAI_API_KEY=sk-...
+`;
         fs.writeFileSync(envPath, exampleEnv);
         console.log('🔐 Created .env file');
       }
@@ -51,7 +94,7 @@ export async function initializeTestronautProject() {
 
     OPENAI_API_KEY=sk-...
 
-📌 The key must have permissions to call the OpenAI Chat Completions API.
+📌 The key must have permissions to call the OpenAI API.
 
 ✅ You’re now ready to write missions in \`missions/\` and run your first mission using:
 

package/core/redaction.js

@@ -0,0 +1,79 @@
+// core/redaction.js
+
+function clone(obj) {
+  try { return structuredClone(obj); } catch { return JSON.parse(JSON.stringify(obj ?? {})); }
+}
+
+export function maskPreview(val, showLength = true) {
+  const s = String(val ?? '');
+  if (!s) return '••••••';
+  // Show length for debugging without leaking the value
+  return showLength ? `•••••• (${s.length})` : '••••••';
+}
+
+function hasPasswordHint(str = '') {
+  return /\b(pass(word)?|pwd|passwd)\b/i.test(String(str || ''));
+}
+
+function isPasswordCall(fnName, args = {}) {
+  if (!(fnName === 'type' || fnName === 'fill')) return false;
+  const { selector, label, placeholder, name, inputType, role, testId } = args;
+  return (
+    hasPasswordHint(selector) ||
+    hasPasswordHint(label) ||
+    hasPasswordHint(placeholder) ||
+    hasPasswordHint(name) ||
+    String(inputType || '').toLowerCase() === 'password' ||
+    hasPasswordHint(role) ||
+    hasPasswordHint(testId)
+  );
+}
+
+/**
+ * Redact ONLY password values in tool args:
+ * - Applies to type/fill on password-looking fields
+ * - Also masks any arg property explicitly named password/pwd/passwd (shallow)
+ */
+export function redactArgs(fnName, args = {}, { showLength = true } = {}) {
+  const out = clone(args);
+
+  // Mask direct props named password/pwd/passwd if present
+  for (const k of Object.keys(out || {})) {
+    if (hasPasswordHint(k)) {
+      out[k] = maskPreview(out[k], showLength);
+    }
+  }
+
+  // For typing into a password field, mask the value
+  if (isPasswordCall(fnName, args)) {
+    if ('text'  in out) out.text  = maskPreview(out.text, showLength);
+    if ('value' in out) out.value = maskPreview(out.value, showLength);
+    if ('input' in out) out.input = maskPreview(out.input, showLength);
+    if ('keys'  in out) out.keys  = maskPreview(out.keys, showLength);
+  }
+
+  return out;
+}
+
+/**
+ * Redact password literals in freeform mission text.
+ * Heuristic: look for the word "password" then the next quoted string OR
+ * a token after "with|as|to|=" within ~80 chars.
+ */
+export function redactPasswordInText(text = '', { showLength = true } = {}) {
+  let s = String(text ?? '');
+
+  // Case 1: password ... "VALUE"
+  s = s.replace(
+    /(\bpassword\b[^"'\\\n]{0,80}["'])([^"']+)(["'])/gi,
+    (_m, pre, pwd, post) => pre + maskPreview(pwd, showLength) + post
+  );
+
+  // Case 2: password ... (with|as|to|=) VALUE
+  s = s.replace(
+    /(\bpassword\b[^.\n]{0,80}?\b(with|as|to|=)\s*)([^\s"'`]+)/gi,
+    (_m, pre, _kw, pwd) => pre + maskPreview(pwd, showLength)
+  );
+
+  return s;
+}

package/core/turnIntent.js

@@ -0,0 +1,64 @@
+import { redactArgs } from './redaction.js';
+
+export function truncateMiddle(str = '', max = 80) {
+  if (!str || str.length <= max) return str;
+  const half = Math.floor((max - 1) / 2);
+  return `${str.slice(0, half)}…${str.slice(-half)}`;
+}
+
+function pickArg(args, keys) {
+  for (const k of keys) {
+    if (args?.[k] != null && String(args[k]).trim() !== '') return String(args[k]);
+  }
+  return null;
+}
+
+export function summarizeToolCall(fnName, args = {}) {
+  const safeArgs = redactArgs(fnName, args);
+
+  const selector = pickArg(safeArgs, ['selector','xpath','css','role','testId']);
+  const text     = pickArg(safeArgs, ['text','value','keys','input','query','label']);
+  const url      = pickArg(safeArgs, ['url','href','to']);
+  const file     = pickArg(safeArgs, ['filePath','fileName','downloadPath']);
+  const x        = pickArg(safeArgs, ['x']);
+  const y        = pickArg(safeArgs, ['y']);
+  const timeout  = pickArg(safeArgs, ['timeoutMs','timeout']);
+
+  const sel = selector ? ` (${truncateMiddle(selector, 60)})` : '';
+  const val = text ? ` "${truncateMiddle(text, 60)}"` : '';
+  const tmo = timeout ? ` [≤${timeout}ms]` : '';
+
+  switch (fnName) {
+    case 'navigate': return `Navigate to ${truncateMiddle(url || '(no url)', 80)}`;
+    case 'click_text': return `Click text${val}`;
+    case 'click': return `Click element${sel}`;
+    case 'type':
+    case 'fill': return `Type${val}${selector ? ` into ${truncateMiddle(selector, 60)}` : ''}`;
+    case 'press': return `Press key${val || ''}${selector ? ` in ${truncateMiddle(selector, 60)}` : ''}`;
+    case 'hover': return `Hover over${sel || val || ''}`;
+    case 'wait_for_selector': return `Wait for${sel}${tmo}`;
+    case 'wait': return `Wait${tmo || ''}`;
+    case 'screenshot': return `Capture screenshot${selector ? ` of ${truncateMiddle(selector, 60)}` : ''}`;
+    case 'get_dom': return `Inspect DOM (focused extract)`;
+    case 'check_text': return `Check page for${val || ' specific text'}`;
+    case 'scroll': return `Scroll to coords (${x ?? '?'}, ${y ?? '?'})`;
+    case 'upload_file': return `Upload file ${truncateMiddle(file || '(unknown)', 60)}${selector ? ` via ${truncateMiddle(selector, 60)}` : ''}`;
+    case 'download_file': return `Download file to ${truncateMiddle(file || '(unknown)', 60)}`;
+    case 'expand_menu': return `Expand menu${sel || ''}`;
+    case 'set_viewport': return `Set viewport ${safeArgs?.width}×${safeArgs?.height}`;
+    default:
+      return `Run ${fnName} with ${truncateMiddle(JSON.stringify(safeArgs ?? {}), 80)}`;
+  }
+}
+
+export function summarizeTurnIntentFromMessage(msg) {
+  try {
+    if (msg?.tool_calls?.length) {
+      return msg.tool_calls
+        .map(c => summarizeToolCall(c.function?.name || 'unknown', JSON.parse(c.function?.arguments || '{}')))
+        .join(' → ');
+    }
+    if (msg?.content) return `Reasoning: ${truncateMiddle(msg.content, 120)}`;
+  } catch {}
+  return 'No intent detected';
+}

package/core/turnLoop.js

@@ -11,8 +11,17 @@ import {
   tokenEstimate, 
   tokenUseCoolOff, 
   recordTokenUsage, 
-  pruneOldTokenUsage 
+  pruneOldTokenUsage,
+  getCurrentTokenLimit,
+  updateLimitsFromHeaders
 } from '../tools/tokenControl.js';
+import { resolveModel } from '../openAI/modelResolver.js';
+import { summarizeTurnIntentFromMessage } from './turnIntent.js';
+import { redactArgs } from './redaction.js';
+
+
+const MODEL_ID = resolveModel();
+console.log(`🧠 Using OpenAI model: ${MODEL_ID}`);
 
 const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
 
@@ -52,7 +61,7 @@ const pushDOMAssistant = async (browser, messages, agentMemory, { skipIfLastTool
   });
 
   const domHtml = await CHROME_TOOL_MAP.get_dom(browser, { limit: 100000, exclude: true }, agentMemory);
-  await tokenEstimate('gpt-4o', domHtml);
+  await tokenEstimate( MODEL_ID, domHtml);
   // fs.writeFileSync(`missions/mission_reports/debug-expanded-${Date.now()}.html`, domHtml);
 
   messages.push({
@@ -89,7 +98,7 @@ export const turnLoop = async (
       ({ turnTimestamps, totalTokensUsed } = pruneOldTokenUsage(turnTimestamps));
 
       // Cool off check
-      ({ totalTokensUsed, turnTimestamps, shouldBackoff } = await tokenUseCoolOff(totalTokensUsed, turnTimestamps));
+      ({ totalTokensUsed, turnTimestamps, shouldBackoff } = await tokenUseCoolOff(totalTokensUsed, turnTimestamps, MODEL_ID));
       if(shouldBackoff) return await turnLoop(browser, messages, maxTurns, turn, currentStep);
 
       //Tool Validator
@@ -123,12 +132,14 @@ export const turnLoop = async (
       
 
       response = await openai.chat.completions.create({
-        model: 'gpt-4o',
+        model: MODEL_ID,
         messages,
         tools: toolsSchema,
       });
     } catch (err) {
       if (err.status === 429) {
+        // If headers include limits, learn them for this model
+        try { updateLimitsFromHeaders(MODEL_ID, err.headers || err.response?.headers || {}); } catch {}
         const delay = Math.min(60000, 2 ** retryCount * 2000);
         console.warn(`⚠️ Rate limited. Retrying in ${delay / 1000}s... (retry ${retryCount + 1})`);
         await wait(delay);
@@ -169,6 +180,11 @@ export const turnLoop = async (
     
     const msg = response.choices[0].message;
 
+    const planLine = summarizeTurnIntentFromMessage(msg);
+    currentStep.summary = planLine;
+    currentStep.events.unshift(`📝 Plan: ${planLine}`);
+    console.log(`📝 Plan: ${planLine}`);
+
     if (msg.tool_calls?.length) {
       console.log('Processing tool calls...');
       const toolResponses = [];
@@ -178,8 +194,9 @@ export const turnLoop = async (
         const fnName = call.function.name;
         lastToolName = fnName;
         const args = JSON.parse(call.function.arguments || '{}');
-        console.log(`[model] → ${fnName}`, args);
-        currentStep.events.push(`[model] → ${fnName} ${args}`);
+        const safeArgs = redactArgs(fnName, args);
+        console.log(`[model] → ${fnName}`, safeArgs);
+        currentStep.events.push(`[model] → ${fnName} ${safeArgs}`);
         // console.log('Calling tool:', fnName);
         let result;
         let errorMessage = null;
@@ -248,7 +265,7 @@ export const turnLoop = async (
             exclude: true,
             focus: [],
           }, agentMemory);
-          await tokenEstimate('gpt-4o', domHtml);
+          await tokenEstimate(MODEL_ID, domHtml);
           await pushDOMAssistant(browser, messages, agentMemory, {
             skipIfLastTool: ['get_dom', 'check_text']
           });

package/openAI/modelResolver.js

@@ -0,0 +1,33 @@
+import path from 'path';
+import fs from 'fs';
+
+// Resolve model from config (or ENV) with safe fallback
+const root = process.cwd();
+const configPath = path.join(root, 'testronaut-config.json');
+
+export function resolveModel() {
+  // Highest priority: env override
+  if (process.env.TESTRONAUT_MODEL?.trim()) {
+    return process.env.TESTRONAUT_MODEL.trim();
+  }
+
+  try {
+    if (fs.existsSync(configPath)) {
+      const cfg = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      // Only use the model if provider is openai (future-proofing for other providers)
+      if (cfg?.provider === 'openai' && typeof cfg?.model === 'string' && cfg.model.trim()) {
+        return cfg.model.trim();
+      }
+      // Back-compat: older configs may have stored 'openai' in model
+      if (!cfg?.provider && cfg?.model === 'openai') {
+        return 'gpt-4o';
+      }
+    }
+  } catch (e) {
+    console.warn('⚠️ Could not read testronaut-config.json; using default model. Error:', e.message);
+  }
+
+  return 'gpt-4o';
+}
+
+

package/package.json

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

package/runner/testronaut.js

@@ -1,37 +1,68 @@
 import { runAgent } from '../core/agent.js';
-import { runSuite } from './suiteRunner.js';
+import { redactPasswordInText } from '../core/redaction.js';
+// import { runSuite } from './suiteRunner.js';
 
-const objectives = [];
+// const objectives = [];
 
-export function mission(title, fn) {
-  console.log(`\n🚀 Mission: ${title}`);
-  fn();
-}
+// export function mission(title, fn) {
+//   console.log(`\n🚀 Mission: ${title}`);
+//   fn();
+// }
+
+// export function objective(desc, workflow) {
+//   objectives.push({ name: desc, workflow });
+// }
+
+// export async function launch(preMissionSetup) {
+//   await runSuite(objectives, preMissionSetup);
+// }
 
-export function objective(desc, workflow) {
-  objectives.push({ name: desc, workflow });
-}
 
-export async function launch(preMissionSetup) {
-  await runSuite(objectives, preMissionSetup);
-}
 
 export async function runMissions({ preMission, mission, postMission }, missionName) {
   const normalizeToArray = (x) => (Array.isArray(x) ? x : x ? [x] : []);
-  
-  const pre = normalizeToArray(preMission);
+
+  const pre  = normalizeToArray(preMission);
   const main = normalizeToArray(mission);
   const post = normalizeToArray(postMission);
 
   const goals = [];
 
+  const pickName = (kind, fn, i) => {
+    const baseFallback =
+      kind === 'premission'   ? `pre-${i + 1}` :
+      kind === 'postmission'  ? `post-${i + 1}` :
+                                `mission-${i + 1}`;
+
+    // MAIN mission: prefer the missionName argument
+    if (kind === 'mission') {
+      if (missionName) {
+        // if multiple main items, disambiguate nicely
+        const suffix = main.length > 1 ? ` (${i + 1}/${main.length})` : '';
+        return `${missionName}${suffix}`;
+      }
+      // no missionName: if mission is a string, derive from its first non-empty line
+      if (typeof fn === 'string') {
+        const firstLine = (fn.trim().split('\n').find(Boolean) || fn.trim()).slice(0, 60);
+        return firstLine.length === 60 ? `${firstLine}…` : firstLine || baseFallback;
+      }
+    }
+
+    // PRE/POST (and fallback for mission): prefer author-provided labels on the function
+    const explicit =
+      fn?.submissionName || fn?.displayName || fn?.title || fn?.name;
+    if (explicit && String(explicit).trim()) return String(explicit).trim();
+
+    return baseFallback;
+  };
+
   if (pre.length) {
     goals.push(
       ...pre.map((fn, i) => ({
         goal: fn,
-        label: 'pre-mission',              // legacy label
-        submissionType: 'premission',      // normalized
-        submissionName: fn?.name || `pre-${i + 1}`,
+        label: 'pre-mission',          // legacy label (kept for logs)
+        submissionType: 'premission',  // normalized
+        submissionName: pickName('premission', fn, i),
       }))
     );
   }
@@ -42,7 +73,7 @@ export async function runMissions({ preMission, mission, postMission }, missionN
         goal: fn,
         label: 'mission',
         submissionType: 'mission',
-        submissionName: fn?.name || `mission-${i + 1}`,
+        submissionName: pickName('mission', fn, i),
       }))
     );
   }
@@ -53,28 +84,30 @@ export async function runMissions({ preMission, mission, postMission }, missionN
         goal: fn,
         label: 'post-mission',
         submissionType: 'postmission',
-        submissionName: fn?.name || `post-${i + 1}`,
+        submissionName: pickName('postmission', fn, i),
       }))
     );
   }
 
   console.log(
     '\n🧭 Running mission flow:\n',
-    goals.map(g => `${g.label}: ${g.goal?.name ?? g.goal}`)
+    goals.map(g => {
+      if (typeof g.goal === 'string') {
+        // redact only the password literal in the human-readable mission text
+        return `${g.label}: ${redactPasswordInText(g.goal)}`;
+      }
+      return `${g.label}: ${g.goal?.name || g.submissionName || g.goal}`;
+    })
   );
-  
+
   const success = await runAgent(goals, missionName);
   if (!success) {
     console.log(`❌ Aborting after failed goal.`);
     return;
   }
-  // console.log("success[0]: ", success[0]);
-  // console.log("success[0].steps.length: ", success[0].steps.length);
-  // console.log("success[0].steps[success[0].steps.length - 1].result: ", success[0].steps[success[0].steps.length - 1].result)
+
   const missionStatus = success[0].steps[success[0].steps.length - 1].result;
-  // console.log("missionStatus: ", missionStatus)
   if (missionStatus.toLowerCase().includes('failure')) {
-    // console.log("we detected the failure!")
     success[0].status = 'failed';
   }
   console.log('\n✅ Mission flow complete.');

package/tools/generateHtmlReport.js

@@ -3,7 +3,7 @@ import fs from 'fs';
 import path from 'path';
 
 export function generateHtmlReport(report, outputPath) {
-  const { runId, startTime, endTime, missions = [], summary = {} } = report;
+  const { runId, startTime, endTime, missions = [], summary = {}, llm = {} } = report;
   const durationSec =
     (startTime && endTime)
       ? ((new Date(endTime) - new Date(startTime)) / 1000).toFixed(2)
@@ -13,6 +13,7 @@ export function generateHtmlReport(report, outputPath) {
   const esc = (s) => String(s ?? '')
     .replace(/&/g, '&amp;').replace(/</g, '&lt;')
     .replace(/>/g, '&gt;');
+  const escAttr = (s) => esc(s).replace(/"/g, '&quot;'); // for HTML attributes
   const badge = (status) =>
     status === 'passed' ? '✅ Passed' :
     status === 'failed' ? '❌ Failed' : (status || '—');
@@ -31,10 +32,18 @@ export function generateHtmlReport(report, outputPath) {
         ? `<img src="${esc(step.screenshotPath)}" alt="screenshot turn ${esc(step.turn ?? idx)}">`
         : '';
 
+      const plan = (typeof step.summary === 'string' && step.summary.trim())
+        ? step.summary.trim()
+        : '';
+      const planSpan = plan
+        ? `<span class="plan" title="${escAttr(plan)}">${esc(plan)}</span>`
+        : '';
+
       return `
         <details class="step" ${ok ? '' : 'open'}>
           <summary>
             <span class="turn">Turn ${esc((step.turn ?? idx) + 1)}</span>
+            ${planSpan}
             <span class="step-result ${ok ? 'ok' : 'bad'}">${esc(step.result || '—')}</span>
             <span class="tokens">tokens: ${esc(step.tokensUsed ?? '—')} / total: ${esc(step.totalTokensUsed ?? '—')}</span>
           </summary>
@@ -210,6 +219,10 @@ export function generateHtmlReport(report, outputPath) {
     .step summary:hover{ background: rgba(255,255,255,.08); }
 
     .turn{ font-weight:700; }
+    .plan{
+      flex:1; color: var(--text-muted); font-size:12px;
+      white-space:nowrap; overflow:hidden; text-overflow:ellipsis;
+    }
     .step-result.ok{ color: var(--ok); font-weight:700; }
     .step-result.bad{ color: var(--bad); font-weight:700; }
     .tokens{ color: var(--text-muted); font-size:12px; margin-left:auto; font-variant-numeric: tabular-nums; }
@@ -241,6 +254,7 @@ export function generateHtmlReport(report, outputPath) {
       <div><strong>Run ID:</strong> ${esc(runId ?? '—')}</div>
       <div><strong>Start:</strong> ${esc(startTime ?? '—')}</div>
       <div><strong>End:</strong> ${esc(endTime ?? '—')} • <strong>Duration:</strong> ${durationSec}s</div>
+      <div><strong>LLM:</strong> ${esc(llm.provider ?? '—')} • <strong>Model:</strong> ${esc(llm.model ?? '—')}</div>
     </div>
   </div>
 
@@ -248,6 +262,7 @@ export function generateHtmlReport(report, outputPath) {
     <div class="pill">Missions: ${esc(summary.totalMissions ?? totals.total)}</div>
     <div class="pill ok">Passed: ${esc(summary.passed ?? totals.passed)}</div>
     <div class="pill bad">Failed: ${esc(summary.failed ?? totals.failed)}</div>
+    <div class="pill">LLM: ${esc(llm.provider ?? '—')} • ${esc(llm.model ?? '')}</div>
   </div>
 
   <div class="container">

package/tools/tokenControl.js

@@ -1,33 +1,164 @@
-import { encoding_for_model } from '@dqbd/tiktoken';
+import { encoding_for_model, get_encoding } from '@dqbd/tiktoken';
 import { wait } from './turnLoopUtils.js';
 
-const TOKEN_BACKOFF_MS = 60000;
-const TOKEN_LIMIT_PER_MIN = 90000;
+/**
+ * Dynamic token-per-minute limits by model family.
+ * - You can tweak these defaults anytime.
+ * - ENV override: TESTRONAUT_TOKENS_PER_MIN forces a single limit for everything.
+ * - At runtime, you can call `updateLimitsFromHeaders(model, headers)` after a 429
+ *   to adopt server-advertised limits (if present).
+ */
+const DEFAULT_LIMITS = [
+  // Newer families first (checked in order)
+  { test: /^gpt-5(-|$)/i,               tpm: 90000 },
+  { test: /^gpt-5-mini(-|$)/i,          tpm: 240000 },
+  { test: /^gpt-5-nano(-|$)/i,          tpm: 600000 },
+
+  { test: /^gpt-4o(-|$)/i,              tpm: 450000 },
+  { test: /^gpt-4\.1(-|$)/i,            tpm: 1000000 },
+
+  { test: /^o3(-|$)/i,                  tpm: 300000 },
+  { test: /^o4-mini(-|$)/i,             tpm: 600000 },
+
+  // Older / fallback
+  { test: /^gpt-4(-|$)/i,               tpm: 150000 },
+  { test: /^gpt-3\.5(-|$)/i,            tpm: 600000 },
+
+  // Ultimate fallback for anything else
+  { test: /.*/,                         tpm: 150000 },
+];
+
+// Live, mutable limits (can be updated by headers at runtime)
+const liveLimits = new Map(); // modelId -> { tpm, source: 'default'|'env'|'header' }
+
+// One-time warning tracking for tokenizer fallback
+const warnedModels = new Set();
+
+/* ---------------- Tokenizer helpers (same idea as before) ---------------- */
+
+function getTokenizer(model) {
+  try {
+    return encoding_for_model(model);
+  } catch (_) {
+    const m = (model || '').toLowerCase();
+    const useO200k =
+      m.startsWith('gpt-5') ||
+      m.startsWith('gpt-4o') ||
+      m.startsWith('gpt-4.1') ||
+      m.startsWith('o') ||
+      m.includes('omni');
+
+    try {
+      return get_encoding(useO200k ? 'o200k_base' : 'cl100k_base');
+    } catch (e2) {
+      if (!warnedModels.has(model)) {
+        console.warn(`⚠️ Could not load tokenizer for "${model}". Will approximate by bytes/4.`, e2?.message || e2);
+        warnedModels.add(model);
+      }
+      return null;
+    }
+  }
+}
 
 export const tokenEstimate = async (model, text) => {
-  const encoding = encoding_for_model(model);
-  const tokenCount = encoding.encode(text).length;
-  console.log(`🧠 Estimated token count: ${tokenCount}`);
-  return tokenCount;
+  const str = typeof text === 'string' ? text : JSON.stringify(text ?? '');
+  const enc = getTokenizer(model);
+
+  if (enc) {
+    try {
+      const tokenCount = enc.encode(str).length;
+      enc.free?.();
+      console.log(`🧠 Estimated token count (${model}): ${tokenCount}`);
+      return tokenCount;
+    } catch (e) {
+      enc.free?.();
+      if (!warnedModels.has(model)) {
+        console.warn(`⚠️ Tokenizer encode failed for "${model}". Falling back to bytes/4.`, e?.message || e);
+        warnedModels.add(model);
+      }
+    }
+  }
+
+  // Final fallback: rough heuristic (UTF-8 bytes / 4)
+  const bytes = Buffer.from(str, 'utf8').length;
+  const approx = Math.ceil(bytes / 4);
+  console.log(`🧠 Estimated token count (approx, ${model}): ${approx}`);
+  return approx;
+};
+
+/* ---------------- Dynamic limit resolution ---------------- */
+
+function resolveDefaultLimitForModel(model) {
+  // Highest priority: ENV override (forces a single limit for all models)
+  const envTPM = process.env.TESTRONAUT_TOKENS_PER_MIN
+    ? Number(process.env.TESTRONAUT_TOKENS_PER_MIN)
+    : undefined;
+  if (envTPM && Number.isFinite(envTPM) && envTPM > 0) {
+    return { tpm: envTPM, source: 'env' };
+  }
+
+  // Otherwise find best-matching default
+  const hit = DEFAULT_LIMITS.find(entry => entry.test.test(model || ''));
+  return { tpm: hit?.tpm ?? 150000, source: 'default' };
+}
+
+/**
+ * Public: get the current token-per-minute limit for a model.
+ * Checks liveOverrides first (header-learned), then ENV, then defaults.
+ */
+export function getCurrentTokenLimit(model) {
+  const m = (model || '').trim() || 'unknown';
+  const live = liveLimits.get(m);
+  if (live?.tpm) return live;
+
+  const resolved = resolveDefaultLimitForModel(m);
+  liveLimits.set(m, resolved);
+  return resolved;
 }
 
-export const tokenUseCoolOff = async (totalTokensUsed, turnTimestamps) => {
-  // console.log("total tokens used: ", totalTokensUsed);
-  // console.log("turnTimestamps: ", turnTimestamps);
-  
-  if (totalTokensUsed > TOKEN_LIMIT_PER_MIN) {
-    const msToWait = await getDynamicBackoffMs(turnTimestamps);
-    console.warn(`⚠️ Token throttle risk → Waiting ${msToWait / 1000}s to cool off...`);
-    await wait(msToWait);
-    // totalTokensUsed = 0; // Reset token count after backoff
-    // turnTimestamps = []; // Reset timestamps after backoff
+/**
+ * Public: update limits from HTTP response headers (e.g., after 429).
+ * Looks for typical headers like:
+ *  - x-ratelimit-limit-tokens: "90000"
+ *  - x-ratelimit-remaining-tokens, x-ratelimit-reset-tokens, etc.
+ * If found, we store the new TPM for this model (source='header').
+ */
+export function updateLimitsFromHeaders(model, headers = {}) {
+  if (!model) return;
+
+  // Normalize header keys to lowercase
+  const lower = {};
+  for (const k of Object.keys(headers || {})) lower[k.toLowerCase()] = headers[k];
+
+  // Common header names OpenAI/Azure may set (varies!)
+  const tokenCap =
+    Number(lower['x-ratelimit-limit-tokens']) ||
+    Number(lower['x-ratelimit-limit-tpm']) ||
+    Number(lower['x-ratelimit-limit-token']) ||
+    undefined;
+
+  if (tokenCap && Number.isFinite(tokenCap) && tokenCap > 0) {
+    const cur = getCurrentTokenLimit(model);
+    if (cur.tpm !== tokenCap || cur.source !== 'header') {
+      liveLimits.set(model, { tpm: tokenCap, source: 'header' });
+      console.log(`📏 Updated TPM for ${model}: ${tokenCap} (from headers)`);
+    }
+  }
+}
+
+/* ---------------- Cooloff / backoff logic ---------------- */
+
+export const tokenUseCoolOff = async (totalTokensUsed, turnTimestamps, model) => {
+  const { tpm } = getCurrentTokenLimit(model);
+  if (totalTokensUsed > tpm) {
+    const msToWait = await getDynamicBackoffMs(turnTimestamps, tpm);
+    console.warn(`⚠️ Token throttle risk (${totalTokensUsed}/${tpm}) → Waiting ${Math.ceil((msToWait || 1000)/1000)}s...`);
+    await wait(msToWait || 1000);
     console.log('✅ Backoff complete, resuming...');
-    // return true;
     return { shouldBackoff: true, totalTokensUsed: 0, turnTimestamps: [] };
   }
-  // return false;
   return { shouldBackoff: false, totalTokensUsed, turnTimestamps };
-}
+};
 
 export const recordTokenUsage = (turnTimestamps, tokensUsed) => {
   const now = Date.now();
@@ -41,22 +172,18 @@ export const pruneOldTokenUsage = (turnTimestamps, windowMs = 60000) => {
   return { turnTimestamps: recentEntries, totalTokensUsed };
 };
 
-const getDynamicBackoffMs = async (turnTimestamps, tokenLimit = TOKEN_LIMIT_PER_MIN) => {
+const getDynamicBackoffMs = async (turnTimestamps, tokenLimit) => {
   const now = Date.now();
   let runningTotal = 0;
 
-  // Sort oldest → newest to find the earliest point to fall below the limit
   const sorted = [...turnTimestamps].sort((a, b) => a[0] - b[0]);
-
   for (let i = 0; i < sorted.length; i++) {
-    runningTotal += sorted[i][1]; // add tokensUsed
-
+    runningTotal += sorted[i][1];
     if (runningTotal > tokenLimit) {
       const [timestampOfExcess] = sorted[i];
       const msUntilSafe = 60000 - (now - timestampOfExcess);
-      return Math.max(msUntilSafe, 1000); // wait at least 1s
+      return Math.max(msUntilSafe, 1000); // at least 1s
     }
   }
-
-  return 0; // Safe to proceed
-}
+  return 0;
+};