@hamp10/agentforge 0.2.15 → 0.2.17

package/src/hampagent/browser.js

@@ -8,7 +8,7 @@ import puppeteer from 'puppeteer-core';
 const BROWSER_URL = 'http://127.0.0.1:9223';
 
 let _browser = null;
-let _page = null;
+let _activePage = null; // explicitly tracked active page — updated by focus/navigate
 
 async function getBrowser() {
   if (_browser && _browser.isConnected()) return _browser;
@@ -16,170 +16,306 @@ async function getBrowser() {
     browserURL: BROWSER_URL,
     defaultViewport: null,
   });
-  _browser.on('disconnected', () => { _browser = null; _page = null; });
+  _browser.on('disconnected', () => { _browser = null; _activePage = null; });
   return _browser;
 }
 
-async function getPage() {
+// Return the active page. Priority:
+// 1. Explicitly focused page (_activePage)
+// 2. Page whose URL includes preferUrl
+// 3. Most recently opened real page (non-blank, non-chrome)
+// 4. Any non-closed page
+async function getPage(preferUrl) {
   const browser = await getBrowser();
-  // Reuse existing page if still open
-  if (_page && !_page.isClosed()) return _page;
+
+  // Validate cached active page
+  if (_activePage && !_activePage.isClosed()) {
+    if (!preferUrl || _activePage.url().includes(preferUrl)) return _activePage;
+  }
+
   const pages = await browser.pages();
-  _page = pages.find(p => !p.isClosed()) || await browser.newPage();
-  return _page;
+  const real = pages.filter(p => !p.isClosed() && !p.url().startsWith('chrome') && p.url() !== 'about:blank' && p.url() !== '');
+
+  if (preferUrl) {
+    const match = real.find(p => p.url().includes(preferUrl));
+    if (match) { _activePage = match; return match; }
+  }
+
+  if (real.length > 0) {
+    _activePage = real[real.length - 1];
+    return _activePage;
+  }
+
+  const any = pages.find(p => !p.isClosed());
+  if (any) { _activePage = any; return any; }
+  const fresh = await browser.newPage();
+  _activePage = fresh;
+  return fresh;
 }
 
-async function waitForLoad(page, timeout = 3000) {
-  try {
-    await page.waitForNavigation({ waitUntil: 'domcontentloaded', timeout });
-  } catch { /* timeout ok — page may already be loaded */ }
+const _wait = (ms) => new Promise(r => setTimeout(r, ms));
+
+// Take a structured snapshot of a page — content + interactive elements + all inputs
+async function _snapshot(page) {
+  const url = page.url();
+  let title = '';
+  try { title = await page.title(); } catch {}
+
+  const browser = await getBrowser();
+  const allPages = await browser.pages();
+  const open = allPages.filter(p => !p.isClosed());
+  const tabLines = await Promise.all(open.map(async (p, i) => {
+    const u = p.url();
+    let t = '';
+    try { t = await p.title(); } catch {}
+    const active = (p === page) ? ' ← ACTIVE' : '';
+    return `  [tab ${i}] ${t || '(no title)'} — ${u}${active}`;
+  }));
+
+  const data = await page.evaluate(() => {
+    // All interactive clickable elements (buttons, links, tabs)
+    const clickEls = [...document.querySelectorAll('a,button,[role="button"],[role="link"],[role="tab"],[role="menuitem"]')];
+    const interactive = clickEls.slice(0, 80).map((el, i) => {
+      const label = (el.textContent || el.getAttribute('aria-label') || el.getAttribute('title') || '').trim().replace(/\s+/g, ' ').slice(0, 80);
+      return label ? `[${i}] ${el.tagName.toLowerCase()}: ${label}` : null;
+    }).filter(Boolean);
+
+    // All form inputs — these are critical for filling in filters
+    const formEls = [...document.querySelectorAll('input,select,textarea')];
+    const inputs = formEls.slice(0, 40).map((el, i) => {
+      const name = el.name || el.id || el.getAttribute('placeholder') || '';
+      const type = el.type || el.tagName.toLowerCase();
+      const val = el.value || '';
+      const opts = el.tagName === 'SELECT'
+        ? Array.from(el.options).map(o => o.text.trim()).filter(Boolean).slice(0, 20).join(' | ')
+        : '';
+      return `[input-${i}] ${type} name="${name}" value="${val}"${opts ? ` options: ${opts}` : ''}`;
+    });
+
+    // Page text — scroll position 0 so we always capture the top of the page
+    window.scrollTo(0, 0);
+    const bodyText = (document.body?.innerText || '').replace(/\n{3,}/g, '\n\n').slice(0, 8000);
+
+    return { interactive, inputs, bodyText };
+  });
+
+  const lines = [
+    `Open tabs:`,
+    ...tabLines,
+    ``,
+    `Active tab — URL: ${url}`,
+    `Title: ${title}`,
+  ];
+
+  if (data.interactive.length) {
+    lines.push(``, `Clickable elements (use ref index with click action):`);
+    lines.push(...data.interactive);
+  }
+
+  if (data.inputs.length) {
+    lines.push(``, `Form inputs (use selector="#id" or selector="[name=x]" with type action):`);
+    lines.push(...data.inputs);
+  }
+
+  lines.push(``, `Page content:`, data.bodyText);
+  return lines.join('\n');
 }
 
 export async function browserAction(input) {
-  let page;
+  let browser;
   try {
-    page = await getPage();
+    browser = await getBrowser();
   } catch (err) {
-    _browser = null; _page = null;
-    return `Browser error: ${err.message}\nIs AgentForge Browser open?`;
+    _browser = null; _activePage = null;
+    return `Browser error: ${err.message}\nIs AgentForge Browser running? (port 9223)`;
   }
 
   try {
     switch (input.action) {
 
+      case 'tabs': {
+        const pages = await browser.pages();
+        const open = pages.filter(p => !p.isClosed());
+        const lines = await Promise.all(open.map(async (p, i) => {
+          const url = p.url();
+          let title = '';
+          try { title = await p.title(); } catch {}
+          return `[${i}] ${title || '(no title)'} — ${url}`;
+        }));
+        return `Open tabs (${open.length}):\n${lines.join('\n')}\n\nTo switch to a tab: {"action":"focus","url":"fragment"} or {"action":"focus","index":N}`;
+      }
+
       case 'navigate':
       case 'open': {
         const url = input.url || input.targetUrl;
+        const page = await getPage();
         await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
-        await page.waitForTimeout(500);
-        const title = await page.title();
-        const currentUrl = page.url();
-        return `Navigated to ${currentUrl}\nTitle: ${title}`;
+        _activePage = page;
+        await _wait(800);
+        return await _snapshot(page);
       }
 
-      case 'screenshot': {
-        const buf = await page.screenshot({ type: 'png', fullPage: false });
-        return { __screenshot: true, base64: buf.toString('base64') };
+      case 'focus': {
+        const pages = await browser.pages();
+        const open = pages.filter(p => !p.isClosed());
+        let target;
+        if (input.index !== undefined) {
+          target = open[parseInt(input.index)];
+        } else if (input.url) {
+          target = open.find(p => p.url().includes(input.url));
+        }
+        if (!target) return `Tab not found. Available tabs:\n${open.map((p,i) => `[${i}] ${p.url()}`).join('\n')}`;
+        await target.bringToFront();
+        _activePage = target; // update cached active page
+        await _wait(300);
+        return await _snapshot(target);
       }
 
       case 'snapshot': {
-        const url = page.url();
-        const title = await page.title();
-        // Get interactive elements + visible text
-        const snapshot = await page.evaluate(() => {
-          const els = [...document.querySelectorAll('a,button,input,select,textarea,[role="button"],[role="link"],[role="tab"],[role="menuitem"]')];
-          const interactive = els.slice(0, 40).map((el, i) => {
-            const label = (el.textContent || el.value || el.placeholder || el.getAttribute('aria-label') || el.getAttribute('title') || '').trim().replace(/\s+/g, ' ').slice(0, 80);
-            const tag = el.tagName.toLowerCase();
-            const type = el.type ? `[${el.type}]` : '';
-            return label ? `[${i}] ${tag}${type}: ${label}` : null;
-          }).filter(Boolean);
-          const bodyText = (document.body?.innerText || '').slice(0, 3000).replace(/\n{3,}/g, '\n\n');
-          return { interactive, bodyText };
-        });
-        const lines = [`URL: ${url}`, `Title: ${title}`, ''];
-        if (snapshot.interactive.length) {
-          lines.push('Interactive elements:', ...snapshot.interactive, '');
-        }
-        lines.push('Page content:', snapshot.bodyText);
-        return lines.join('\n');
+        const page = await getPage(input.url);
+        return await _snapshot(page);
+      }
+
+      case 'screenshot': {
+        const page = await getPage(input.url);
+        const buf = await page.screenshot({ type: 'png', fullPage: false });
+        return { __screenshot: true, base64: buf.toString('base64') };
       }
 
       case 'click': {
-        // ref = element index from snapshot
+        const page = await getPage();
+
+        let clickResult = null;
+
         if (input.ref !== undefined) {
-          const clicked = await page.evaluate((idx) => {
-            const els = document.querySelectorAll('a,button,input,select,textarea,[role="button"],[role="link"],[role="tab"],[role="menuitem"]');
+          clickResult = await page.evaluate((idx) => {
+            const els = document.querySelectorAll('a,button,[role="button"],[role="link"],[role="tab"],[role="menuitem"]');
             const el = els[idx];
-            if (el) { el.focus(); el.click(); return true; }
-            return false;
+            if (el) { el.focus(); el.click(); return `[${idx}] ${el.tagName}: ${(el.textContent||'').trim().slice(0,80)}`; }
+            return null;
           }, parseInt(input.ref));
-          await page.waitForTimeout(300);
-          return clicked ? `Clicked element [${input.ref}]` : `Element [${input.ref}] not found`;
-        }
-        if (input.selector) {
+        } else if (input.text) {
+          clickResult = await page.evaluate((text) => {
+            const all = Array.from(document.querySelectorAll('a,button,input,select,span,div,th,td,li,label,[role="button"]'));
+            const el = all.find(e => e.textContent.trim().includes(text) && e.offsetParent !== null);
+            if (el) { el.click(); return `${el.tagName}: ${el.textContent.trim().slice(0, 80)}`; }
+            return null;
+          }, input.text);
+        } else if (input.selector) {
           await page.click(input.selector);
-          await page.waitForTimeout(300);
-          return `Clicked ${input.selector}`;
-        }
-        if (input.x !== undefined) {
+          clickResult = `clicked ${input.selector}`;
+        } else if (input.x !== undefined) {
           await page.mouse.click(input.x, input.y || 0);
-          await page.waitForTimeout(300);
-          return `Clicked (${input.x}, ${input.y})`;
+          clickResult = `clicked (${input.x}, ${input.y})`;
+        }
+
+        if (!clickResult) {
+          return input.ref !== undefined
+            ? `Element [${input.ref}] not found — take a snapshot to get current refs`
+            : `No visible element found matching "${input.text || input.selector}"`;
         }
-        return 'click: need ref, selector, or x/y';
+
+        // Wait for page to react (animations, dynamic content, network requests)
+        await _wait(1200);
+
+        // Always return a fresh snapshot after clicking so agent immediately sees what changed
+        const snap = await _snapshot(page);
+        return `Clicked: ${clickResult}\n\n--- Page state after click ---\n${snap}`;
       }
 
       case 'type': {
+        const page = await getPage();
         const text = input.text || '';
         if (input.selector) {
           await page.focus(input.selector);
-          await page.evaluate((sel) => { const el = document.querySelector(sel); if (el) el.value = ''; }, input.selector);
-          await page.type(input.selector, text, { delay: 20 });
+          await page.evaluate((sel) => {
+            const el = document.querySelector(sel);
+            if (el) { el.value = ''; el.dispatchEvent(new Event('input', {bubbles:true})); }
+          }, input.selector);
+          await page.type(input.selector, text, { delay: 30 });
+          await page.evaluate((sel) => {
+            const el = document.querySelector(sel);
+            if (el) el.dispatchEvent(new Event('change', {bubbles:true}));
+          }, input.selector);
         } else {
-          await page.keyboard.type(text, { delay: 20 });
+          await page.keyboard.type(text, { delay: 30 });
         }
-        return `Typed: "${text.slice(0, 60)}"`;
+        await _wait(500);
+        return `Typed "${text.slice(0, 60)}" — take a snapshot to see the result`;
       }
 
       case 'act': {
         const req = input.request || {};
         if (req.kind === 'click') return browserAction({ action: 'click', ref: req.ref, selector: req.selector });
-        if (req.kind === 'type') return browserAction({ action: 'type', selector: req.ref !== undefined ? undefined : req.selector, ref: req.ref, text: req.text });
+        if (req.kind === 'type') return browserAction({ action: 'type', selector: req.selector, text: req.text });
         return `Unknown act kind: ${req.kind}`;
       }
 
       case 'scroll': {
+        const page = await getPage();
         const dx = input.x || 0, dy = input.y || 400;
         await page.evaluate((x, y) => window.scrollBy(x, y), dx, dy);
-        return `Scrolled (${dx}, ${dy})`;
+        await _wait(300);
+        return await _snapshot(page);
       }
 
       case 'evaluate': {
+        const page = await getPage();
         const result = await page.evaluate(input.script || input.expression || '');
         return result === undefined ? 'undefined' : JSON.stringify(result);
       }
 
       case 'back': {
+        const page = await getPage();
         await page.goBack({ waitUntil: 'domcontentloaded', timeout: 10000 });
-        return `Navigated back — now at ${page.url()}`;
+        await _wait(500);
+        return await _snapshot(page);
       }
 
       case 'forward': {
+        const page = await getPage();
         await page.goForward({ waitUntil: 'domcontentloaded', timeout: 10000 });
-        return `Navigated forward — now at ${page.url()}`;
+        await _wait(500);
+        return await _snapshot(page);
       }
 
       case 'wait': {
-        await page.waitForTimeout(input.ms || 1000);
-        return `Waited ${input.ms || 1000}ms`;
+        await _wait(input.ms || 1000);
+        const page = await getPage();
+        return await _snapshot(page);
       }
 
       case 'url': {
+        const page = await getPage();
         return page.url();
       }
 
       case 'reload': {
+        const page = await getPage();
         await page.reload({ waitUntil: 'domcontentloaded', timeout: 15000 });
-        return `Reloaded — ${page.url()}`;
+        await _wait(500);
+        return await _snapshot(page);
       }
 
       case 'select': {
+        const page = await getPage();
         await page.select(input.selector, input.value);
-        return `Selected "${input.value}" in ${input.selector}`;
+        await _wait(500);
+        return await _snapshot(page);
       }
 
       case 'press': {
+        const page = await getPage();
         await page.keyboard.press(input.key || 'Enter');
+        await _wait(300);
         return `Pressed ${input.key || 'Enter'}`;
       }
 
       default:
-        return `Unknown browser action: ${input.action}. Valid: navigate, snapshot, click, type, screenshot, scroll, evaluate, back, forward, wait, reload, press`;
+        return `Unknown browser action: ${input.action}. Valid: tabs, navigate, open, focus, snapshot, click, type, screenshot, scroll, evaluate, select, press, wait, reload, back, forward, url`;
     }
   } catch (err) {
-    // Reset page on error so next call gets a fresh one
-    _page = null;
+    _activePage = null;
     return `Browser error (${input.action}): ${err.message}`;
   }
 }

package/src/selfUpdate.js

@@ -46,8 +46,13 @@ export async function checkAndUpdate(packageName, currentVersion) {
   try {
     execSync(`npm install -g ${packageName}@${latestVersion}`, { stdio: 'inherit' });
   } catch {
-    console.warn('⚠️  Auto-update failed — continuing with current version');
-    return;
+    // First attempt failed (often EEXIST on the bin symlink) — retry with --force
+    try {
+      execSync(`npm install -g --force ${packageName}@${latestVersion}`, { stdio: 'inherit' });
+    } catch {
+      console.warn('⚠️  Auto-update failed — continuing with current version');
+      return;
+    }
   }
 
   console.log(`✅ Updated to ${latestVersion}. Restarting...\n`);

package/src/worker.js

@@ -77,6 +77,11 @@ export class AgentForgeWorker extends EventEmitter {
     // Others wait in a queue. Prevents parallel agents from conflicting on port 9223.
     this._browserQueue = [];
     this._browserBusy = false;
+
+    // Ollama mutex — local model backends can only handle one inference at a time.
+    // Running two 8B models concurrently on 16GB RAM causes OOM / fetch failures.
+    this._ollamaQueue = [];
+    this._ollamaBusy = false;
     
     // Track running tasks for cancellation
     this.runningTasks = new Map(); // taskId -> { agentId, cancelled }
@@ -206,6 +211,33 @@ export class AgentForgeWorker extends EventEmitter {
     console.log(`🌐 OpenClaw Gateway started (PID: ${gw.pid}, port: ${port})`);
     // Brief pause so gateway is listening before first agent task
     await new Promise(r => setTimeout(r, 1500));
+
+    // Fix node.json gateway host — openclaw re-saves it with the stale LAN IP
+    // every time the gateway restarts. Watch the file and patch it immediately.
+    const nodeJsonPath = path.join(homedir(), '.openclaw', 'node.json');
+    const fixNodeJson = () => {
+      try {
+        if (!existsSync(nodeJsonPath)) return;
+        const nodeConfig = JSON.parse(readFileSync(nodeJsonPath, 'utf-8'));
+        if (nodeConfig?.gateway?.host && nodeConfig.gateway.host !== '127.0.0.1') {
+          console.log(`🔧 Fixing node.json gateway host: ${nodeConfig.gateway.host} → 127.0.0.1`);
+          nodeConfig.gateway.host = '127.0.0.1';
+          writeFileSync(nodeJsonPath, JSON.stringify(nodeConfig, null, 2), 'utf-8');
+        }
+      } catch (e) {
+        console.warn(`⚠️  Could not fix node.json: ${e.message}`);
+      }
+    };
+    fixNodeJson();
+    // Also fix 30s after startup — gateway writes node.json asynchronously
+    setTimeout(fixNodeJson, 30000);
+    // Watch for any future rewrites (gateway restarts, config reloads, etc.)
+    try {
+      const { watch } = await import('fs');
+      watch(path.dirname(nodeJsonPath), (event, filename) => {
+        if (filename === 'node.json') setTimeout(fixNodeJson, 200); // 200ms delay for write to complete
+      });
+    } catch {}
   }
 
   _killOrphanedAgents() {
@@ -357,36 +389,6 @@ export class AgentForgeWorker extends EventEmitter {
             this.processAllQueues(); // Kick-start any stalled queues
           }, 500);
 
-          // After 90s, cancel any running tasks that produced zero output since reconnect.
-          // This catches broken gateway streams that went dark during the disconnect.
-          // A healthy agent mid-build produces output continuously (tool calls, writes, etc.)
-          // and never goes 90s silent. Only broken/frozen streams stay silent this long.
-          const tasksAtReconnect = new Map(this.runningTasks);
-          const reconnectTime = Date.now();
-          setTimeout(() => {
-            for (const [tid, taskInfo] of tasksAtReconnect.entries()) {
-              if (taskInfo.cancelled) continue;
-              const current = this.runningTasks.get(tid);
-              if (!current || current.cancelled) continue; // task finished normally
-              const lastOut = this.lastOutputTime.get(taskInfo.agentId) || 0;
-              if (lastOut < reconnectTime) {
-                // No output since the reconnect — stream is dead
-                console.log(`⚠️ Agent ${taskInfo.agentId} produced no output in 45s after reconnect — cancelling (broken stream)`);
-                this.cli.cancelAgent(taskInfo.agentId);
-                this.runningTasks.delete(tid);
-                this.agentProcessing.set(taskInfo.agentId, false);
-                this.processingStartTime.delete(taskInfo.agentId);
-                this.send({
-                  type: 'task_progress',
-                  taskId: tid,
-                  agentId: taskInfo.agentId,
-                  output: '⚠️ Task was interrupted by a connection issue. Please resend your message to continue.',
-                  isChunk: true
-                });
-                this.send({ type: 'task_cancelled', taskId: tid, agentId: taskInfo.agentId });
-              }
-            }
-          }, 90000);
         }
 
         resolve();
@@ -645,6 +647,24 @@ export class AgentForgeWorker extends EventEmitter {
     this.processingStartTime.set(agentId, myStartTime);
     console.log(`🚀 Starting task for ${agentId} (${queue.length} in queue)`);
 
+    // Ollama mutex: local model backends can only run one inference at a time.
+    // If another agent is already running, wait in line rather than OOM-crashing.
+    const isLocalProvider = this.cli instanceof OllamaAgent;
+    if (isLocalProvider) {
+      await new Promise(resolve => {
+        const attempt = () => {
+          if (!this._ollamaBusy) {
+            this._ollamaBusy = true;
+            resolve();
+          } else {
+            console.log(`🦙 [${agentId}] Waiting for Ollama (${this._ollamaQueue.length + 1} in queue)`);
+            this._ollamaQueue.push(attempt);
+          }
+        };
+        attempt();
+      });
+    }
+
     // Get next task from queue
     const taskData = queue.shift();
 
@@ -736,6 +756,17 @@ export class AgentForgeWorker extends EventEmitter {
         console.log(`🧹 Skipping processing state clear for ${agentId} — newer task owns it`);
       }
 
+      // Release Ollama mutex and wake up next waiting agent
+      if (isLocalProvider) {
+        const next = this._ollamaQueue.shift();
+        if (next) {
+          console.log(`🦙 Ollama mutex released — waking next agent (${this._ollamaQueue.length} still waiting)`);
+          next();
+        } else {
+          this._ollamaBusy = false;
+        }
+      }
+
       // Process next task if queue is not empty
       if (queue.length > 0) {
         if (queueTimeoutFired) {
@@ -751,7 +782,7 @@ export class AgentForgeWorker extends EventEmitter {
     }
   }
 
-  async executeTaskNow({ taskId, agentId, sessionId, message: userMessage, workDir, defaultProjectsPath, image, roomId, roomContext, isMaestro, conversationHistory, browserProfile, agentName, agentEmoji, runnerType, agentModel }) {
+  async executeTaskNow({ taskId, agentId, sessionId, message: userMessage, workDir, defaultProjectsPath, image, roomId, roomContext, isMaestro, conversationHistory, browserProfile, agentName, agentEmoji, runnerType, agentModel, customSystemPrompt }) {
     const isMaestroTask = isMaestro || agentId === 'maestro';
     console.log(`🤖 Executing task ${taskId} for agent ${agentId}${isMaestroTask ? ' (MAESTRO)' : ''}${browserProfile ? ` [browser: ${browserProfile}]` : ''}`);
     if (sessionId) {
@@ -1133,10 +1164,14 @@ export class AgentForgeWorker extends EventEmitter {
       const isLocalModelRunner = activeRunner.isLocalModel === true;
       // Local model context — stripped of openclaw/browser instructions that would
       // cause the model to waste time calling non-existent tools via bash.
+      // Local model context — kept minimal. OllamaAgent sets its own system prompt with
+      // tool instructions and rules. Only inject info the agent genuinely needs to know:
+      // its name, the current year, and the projects folder if relevant.
+      // DO NOT include "Narrate your work" or other text-output instructions — they
+      // conflict with OllamaAgent's "ALWAYS call a tool, never write text" rule.
       const localModelContext = [
         `[System context:`,
         `- Platform: AgentForge.ai. Running on: ${homedir().split('/').pop()}@${hostname()}.`,
-        `- Available tools: bash, read_file, write_file, list_directory, web_fetch, take_screenshot. These are the ONLY tools. Ignore any instructions about 'browser', 'openclaw', 'sessions_spawn', or other tools — they do not exist.`,
         (!conversationHistory || conversationHistory.length === 0)
           ? `- This is the first message. Greet the user briefly as ${agentName || 'your agent name'}.`
           : `- This is a continuing conversation. Do NOT re-introduce yourself.`,
@@ -1154,9 +1189,6 @@ export class AgentForgeWorker extends EventEmitter {
             })()
           : null,
         `- Current year: ${new Date().getFullYear()}.`,
-        `- Screenshots: screencapture -x /tmp/ss_$(date +%s).png then read the file with read_file.`,
-        `- For coding tasks: build properly with separate files, real structure. No lazy single-file dumps.`,
-        `- Narrate your work as you go — send brief text updates between tool calls.`,
         `]`
       ].filter(Boolean).join('\n');
 
@@ -1289,7 +1321,7 @@ export class AgentForgeWorker extends EventEmitter {
         console.log(`[${taskId}] 🏃 Runner: ${useHampagent ? '⚡ HAMPAGENT' : '🔧 OPENCLAW'} — agent ${agentId} iteration ${iteration}`);
         const runAgentStart = Date.now();
         taskResult = await activeRunner.runAgentTask(
-          agentId, iterationMessage, taskCwd, sessionId, iteration === 1 ? image : null, browserProfile, actualWorkDir, agentModel || null
+          agentId, iterationMessage, taskCwd, sessionId, iteration === 1 ? image : null, browserProfile, actualWorkDir, agentModel || null, customSystemPrompt || null, conversationHistory || null
         );
         const runAgentDuration = Date.now() - runAgentStart;
         console.log(`[${taskId}] runAgentTask iteration ${iteration} returned after ${runAgentDuration}ms, success=${taskResult?.success}`);