Fix search hallucination: single-query tool with parallel agent dispatch (jaredlockhart#910)

* Fix search hallucination: single-query tool with parallel agent dispatch

Root cause: SearchTool accepted a queries list and concatenated multiple
results into one tool message, which got truncated mid-content. The model
then hallucinated the rest from memory.

Fix: SearchTool.execute() now takes a single query: str. Parallelism moves
to the agent loop — _process_tool_calls uses asyncio.gather() to dispatch
all tool calls concurrently, then appends one tool message per result. This
matches Ollama's native parallel tool call protocol.

Also rewrites CONVERSATION_PROMPT and THINKING_SYSTEM_PROMPT to be
tool-agnostic — search-specific language replaced with neutral equivalents
so the model uses the right tool (search, browse_url, etc.) for the job.

Adds _make_parallel_tool_calls_response to the mock and a new
TestParallelToolCalls test that verifies two tool calls in one turn produce
two separate tool messages in the next Ollama call.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* Rework MultiTool as fetch with single queries array and URL auto-routing

The previous MultiTool design used separate arrays (queries, urls, news)
and a complex inner-call schema that gpt-oss:20b couldn't reliably follow.
The model kept putting URLs in queries, inventing its own call formats,
or hedging by duplicating entries across arrays.

New design: single queries array — the model dumps everything in one list
and Python routes URLs to browse_url via regex, plain text to search.
This matches the pattern the model already learned from the original
single-query search tool.

Key changes:
- MultiTool renamed to "fetch" (avoids name collision with SearchTool)
- Schema simplified to just queries[] — URLs auto-detected and routed
- _create_search_tool returns SearchTool | None (was list for no reason)
- MAX_TOOL_RESULT_CHARS raised from 8k to 50k (web pages need room)
- Chat page context injection uses fetch format (was stale browse_url)
- Browser channel tool status shows cumulative checklist with checkmarks
- CONVERSATION_PROMPT kept tool-agnostic (tool descriptions do the work)
- browse_url retries full tab lifecycle up to 3x on empty content
- Tab load + tool timeouts raised to 60s for JS-heavy pages (e.g. IMDb)
- Test: two 15k-char results both survive into model context without truncation

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Hide browse_url tabs with tabHide API

Tabs were visible in the tab bar during page reads because
active: false only prevents focus steal. Now calls
browser.tabs.hide() after creation with graceful fallback.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Give ThinkingAgent its own MultiTool (max_calls=1)

Moves multi_tool support to the base Agent class so both ChatAgent and
ThinkingAgent use MultiTool for tool dispatch. ThinkingAgent gets its own
instance with max_calls=1 (matching the old single-query cap on main).
Both MultiTools share the same browse_url provider.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Enforce max_calls in MultiTool schema with per-instance maxItems

The model was sending multiple queries from ThinkingAgent because the
schema had no maxItems constraint. Now MultiTool sets description and
parameters per-instance based on max_calls, matching how SearchTool
on main advertised its cap via maxItems in the JSON schema.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Jared Lockhart <119884+jaredlockhart@users.noreply.github.com>
Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: 3 people

browser/manifest.json

@@ -7,6 +7,7 @@
   "permissions": [
     "storage",
     "tabs",
+    "tabHide",
     "<all_urls>"
   ],
 

browser/src/background/tools/browse_url.ts

@@ -4,28 +4,48 @@
 
 import { TAB_LOAD_TIMEOUT_MS } from "../../protocol.js";
 
+const BROWSE_MAX_RETRIES = 3;
+
 interface PageData {
   title: string;
   url: string;
   text: string;
 }
 
 export async function browseUrl(url: string): Promise<string> {
-  const tab = await openHiddenTab(url);
-  try {
-    await waitForTabLoad(tab.id!);
-    const pageData = await extractPageContent(tab.id!);
-    return formatResult(pageData);
-  } finally {
-    await closeTab(tab.id!);
+  for (let attempt = 1; attempt <= BROWSE_MAX_RETRIES; attempt++) {
+    console.log(`[browse_url] attempt ${attempt}/${BROWSE_MAX_RETRIES}: ${url}`);
+    const tab = await openHiddenTab(url);
+    try {
+      await waitForTabLoad(tab.id!);
+      console.log(`[browse_url] page complete, extracting content`);
+      const pageData = await extractPageContent(tab.id!);
+      const textLen = pageData.text.trim().length;
+      if (textLen > 0) {
+        console.log(`[browse_url] extracted ${textLen} chars`);
+        return formatResult(pageData);
+      }
+      console.warn(`[browse_url] empty content on attempt ${attempt}`);
+    } catch (err) {
+      console.error(`[browse_url] attempt ${attempt} failed:`, err);
+    } finally {
+      await closeTab(tab.id!);
+    }
   }
+  console.error(`[browse_url] gave up after ${BROWSE_MAX_RETRIES} attempts: ${url}`);
+  return `No content extracted from ${url} after ${BROWSE_MAX_RETRIES} attempts`;
 }
 
 async function openHiddenTab(url: string): Promise<browser.tabs.Tab> {
   const tab = await browser.tabs.create({ url, active: false });
   if (!tab.id) {
     throw new Error("Failed to create tab");
   }
+  try {
+    await browser.tabs.hide(tab.id);
+  } catch {
+    // tabHide may not be available — tab stays visible but still works
+  }
   return tab;
 }
 

browser/src/protocol.ts

@@ -389,8 +389,8 @@ export const MAX_PAGE_CONTEXT_CHARS = 5_000;
 // --- Tool constants ---
 
 export const THOUGHTS_POLL_INTERVAL_MS = 300_000;
-export const TOOL_TIMEOUT_MS = 30_000;
-export const TAB_LOAD_TIMEOUT_MS = 15_000;
+export const TOOL_TIMEOUT_MS = 60_000;
+export const TAB_LOAD_TIMEOUT_MS = 60_000;
 export const MAX_EXTRACTED_CHARS = 50_000;
 
 // --- Chat UI ---

penny/penny/agents/base.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import re
 import urllib.parse as _urlparse
@@ -18,6 +19,7 @@
 from penny.responses import PennyResponse
 from penny.tools import SearchTool, Tool, ToolCall, ToolExecutor, ToolRegistry
 from penny.tools.models import SearchResult
+from penny.tools.multi import MultiTool
 
 logger = logging.getLogger(__name__)
 
@@ -191,6 +193,7 @@ def __init__(
         allow_repeat_tools: bool = False,
         search_tool: Tool | None = None,
         news_tool: Tool | None = None,
+        multi_tool: MultiTool | None = None,
     ):
         self.config = config
         self.system_prompt = system_prompt
@@ -204,6 +207,7 @@ def __init__(
 
         self._search_tool = search_tool
         self._news_tool = news_tool
+        self._multi_tool = multi_tool
         self._browser_tools_provider: Callable[[], list[Tool]] | None = None
         self._current_user: str | None = None
         self._tool_result_text: list[str] = []
@@ -302,7 +306,7 @@ async def run(
         max_steps: int,
         history: list[tuple[str, str]] | None = None,
         system_prompt: str | None = None,
-        on_tool_start: Callable[[str, dict], Awaitable[None]] | None = None,
+        on_tool_start: Callable[[list[tuple[str, dict]]], Awaitable[None]] | None = None,
     ) -> ControllerResponse:
         """Run the agentic loop — prompt in, response out."""
         self._tool_result_text = []
@@ -323,7 +327,7 @@ async def _run_agentic_loop(
         messages: list[dict],
         tools: list[dict],
         steps: int,
-        on_tool_start: Callable[[str, dict], Awaitable[None]] | None = None,
+        on_tool_start: Callable[[list[tuple[str, dict]]], Awaitable[None]] | None = None,
     ) -> ControllerResponse:
         """Execute the step loop: call model, process tool calls, or return final answer."""
         attachments: list[str] = []
@@ -596,7 +600,12 @@ def set_browser_tools_provider(self, provider: Callable[[], list[Tool]]) -> None
         self._browser_tools_provider = provider
 
     def get_tools(self, user: str) -> list[Tool]:
-        """Build tool list for this agent. Override in subclasses for custom tools."""
+        """Build tool list for this agent.
+
+        Returns MultiTool if configured, otherwise individual tools.
+        """
+        if self._multi_tool is not None:
+            return [self._multi_tool]
         tools: list[Tool] = []
         if self._search_tool:
             tools.append(self._search_tool)
@@ -617,16 +626,20 @@ async def _process_tool_calls(
         self,
         response,
         called_tools: set[tuple[str, ...]],
-        on_tool_start: Callable[[str, dict], Awaitable[None]] | None = None,
+        on_tool_start: Callable[[list[tuple[str, dict]]], Awaitable[None]] | None = None,
     ) -> _StepResult:
-        """Process all tool calls from a model response. Returns results to append."""
+        """Process all tool calls from a model response, executing valid ones in parallel."""
         logger.info("Model requested %d tool call(s)", len(response.message.tool_calls or []))
         messages: list[dict] = [response.message.to_input_message()]
         records: list[ToolCallRecord] = []
         source_urls: list[str] = []
         attachments: list[str] = []
 
-        for ollama_tool_call in response.message.tool_calls or []:
+        # Dedup check and on_tool_start are sequential: dedup requires ordered mutation of
+        # called_tools, and on_tool_start fires UI status updates before execution begins.
+        max_calls = int(self.config.runtime.MESSAGE_MAX_TOOL_CALLS) if self.config else 5
+        pending: list[tuple[str, dict, str | None]] = []
+        for ollama_tool_call in (response.message.tool_calls or [])[:max_calls]:
             tool_name = ollama_tool_call.function.name
             arguments = ollama_tool_call.function.arguments
 
@@ -643,14 +656,24 @@ async def _process_tool_calls(
                 continue
 
             called_tools.add(call_key)
-            if on_tool_start:
-                try:
-                    await on_tool_start(tool_name, dict(arguments))
-                except Exception:
-                    logger.debug("on_tool_start callback failed for %s", tool_name)
-            result_str, record, urls, image = await self._execute_single_tool(
-                tool_name, arguments, reasoning
-            )
+            pending.append((tool_name, arguments, reasoning))
+
+        # Fire on_tool_start once with all pending tools so the UI can show
+        # a combined status (e.g. "Searching A + Searching B") for parallel calls.
+        if on_tool_start and pending:
+            try:
+                await on_tool_start([(name, dict(args)) for name, args, _ in pending])
+            except Exception:
+                logger.debug("on_tool_start callback failed")
+
+        # Execute all valid tool calls in parallel.
+        results = await asyncio.gather(
+            *[self._execute_single_tool(name, args, reasoning) for name, args, reasoning in pending]
+        )
+
+        for (tool_name, _, _), (result_str, record, urls, image) in zip(
+            pending, results, strict=True
+        ):
             records.append(record)
             source_urls.extend(urls)
             if image:
@@ -820,8 +843,9 @@ def _identity_section(self) -> str:
     def _instructions_section(self, override: str | None = None) -> str:
         """## Instructions — agent-specific prompt with tool descriptions."""
         prompt = override or self.system_prompt
-        if "{tools}" in prompt:
-            prompt = prompt.format(tools=self._build_tool_summary())
+        if "{tools}" in prompt or "{max_tool_calls}" in prompt:
+            max_tool_calls = int(self.config.runtime.MESSAGE_MAX_TOOL_CALLS) if self.config else 5
+            prompt = prompt.format(tools=self._build_tool_summary(), max_tool_calls=max_tool_calls)
         return f"## Instructions\n{prompt}"
 
     @staticmethod
@@ -842,8 +866,11 @@ def _profile_section(self, sender: str, content: str | None = None) -> str | Non
             if content is not None:
                 name = user_info.name
                 user_said_name = bool(re.search(rf"\b{re.escape(name)}\b", content, re.IGNORECASE))
-                if self._search_tool and isinstance(self._search_tool, SearchTool):
-                    self._search_tool.redact_terms = [] if user_said_name else [name]
+                redact = [] if user_said_name else [name]
+                if self._multi_tool is not None:
+                    self._multi_tool.redact_terms = redact
+                elif self._search_tool and isinstance(self._search_tool, SearchTool):
+                    self._search_tool.redact_terms = redact
 
             logger.debug("Built profile context for %s", sender)
             return f"### User Profile\nThe user's name is {user_info.name}."

penny/penny/agents/chat.py

@@ -15,6 +15,7 @@
 from penny.constants import PennyConstants
 from penny.prompts import Prompt
 from penny.responses import PennyResponse
+from penny.tools.multi import MultiTool
 
 logger = logging.getLogger(__name__)
 
@@ -53,7 +54,7 @@ async def handle(
         sender: str,
         images: list[str] | None = None,
         page_context: PageContext | None = None,
-        on_tool_start: Callable[[str, dict], Awaitable[None]] | None = None,
+        on_tool_start: Callable[[list[tuple[str, dict]]], Awaitable[None]] | None = None,
     ) -> ControllerResponse:
         """Handle an incoming message — summary method.
 
@@ -100,32 +101,38 @@ def _build_messages(
         history: list[tuple[str, str]] | None = None,
         system_prompt: str | None = None,
     ) -> list[dict]:
-        """Build messages, injecting page context as a synthetic browse_url result."""
+        """Build messages, injecting page context as a synthetic tools result."""
         messages = super()._build_messages(prompt, history, system_prompt)
         if self._pending_page_context:
             self._inject_page_context(messages, self._pending_page_context)
         return messages
 
     @staticmethod
     def _inject_page_context(messages: list[dict], page_context: PageContext) -> None:
-        """Inject a synthetic browse_url tool call + result after the user prompt."""
+        """Inject a synthetic search call + result for page context.
+
+        Uses the MultiTool format so the synthetic history matches the tool
+        the model actually sees in its tool definitions.
+        """
         if not page_context.text:
             return
 
         page_content = (
             f"Title: {page_context.title}\nURL: {page_context.url}\n\n{page_context.text}"
         )
 
-        # Assistant "called" browse_url for the current page
+        # Assistant "called" fetch with the URL in queries
         messages.append(
             {
                 "role": "assistant",
                 "content": "",
                 "tool_calls": [
                     {
                         "function": {
-                            "name": "browse_url",
-                            "arguments": {"url": page_context.url},
+                            "name": MultiTool.name,
+                            "arguments": {
+                                "queries": [page_context.url],
+                            },
                         },
                     }
                 ],
@@ -136,7 +143,7 @@ def _inject_page_context(messages: list[dict], page_context: PageContext) -> Non
             {
                 "role": "tool",
                 "content": page_content,
-                "tool_name": "browse_url",
+                "tool_name": MultiTool.name,
             }
         )
 

penny/penny/agents/notify.py

@@ -628,8 +628,8 @@ def _extract_search_query(tool_calls: list[ToolCallRecord]) -> str | None:
             if tc.tool != "search":
                 continue
             args = SearchArgs.model_validate(tc.arguments)
-            if args.queries:
-                return args.queries[0]
+            if args.query:
+                return args.query
         return None
 
     # Matches **bold text** in markdown (first occurrence)

penny/penny/channels/base.py

@@ -312,11 +312,14 @@ async def _embed_message(self, message_id: int, content: str) -> None:
     def _extract_image_prompt(response) -> str | None:
         """Extract a short image search query from the agent's tool calls."""
         for tc in response.tool_calls or []:
-            if tc.tool != "search":
-                continue
-            args = SearchArgs.model_validate(tc.arguments)
-            if args.queries:
-                return args.queries[0]
+            if tc.tool == "fetch":
+                for q in tc.arguments.get("queries", []):
+                    if not q.startswith("http"):
+                        return q
+            elif tc.tool == "search":
+                args = SearchArgs.model_validate(tc.arguments)
+                if args.query:
+                    return args.query
         return None
 
     async def _resolve_image(

penny/penny/channels/browser/channel.py

@@ -511,11 +511,23 @@ async def send_typing(self, recipient: str, typing: bool) -> bool:
         return True
 
     def _make_handle_kwargs(self, message: IncomingMessage) -> dict:
-        """Pass an on_tool_start callback so tool calls update the typing indicator."""
-        recipient = message.sender
+        """Pass an on_tool_start callback so tool calls update the typing indicator.
 
-        async def on_tool_start(tool_name: str, arguments: dict) -> None:
-            await self._send_tool_status(recipient, self._format_tool_status(tool_name, arguments))
+        Builds a cumulative checklist: prior steps show as completed (checkmark),
+        current step shows as in-progress (dots).
+        """
+        recipient = message.sender
+        completed: list[str] = []
+
+        async def on_tool_start(tools: list[tuple[str, dict]]) -> None:
+            current = [self._format_tool_status(name, args) for name, args in tools]
+            lines: list[str] = []
+            for item in completed:
+                lines.append(f"✓ {item}")
+            for item in current:
+                lines.append(item)
+            await self._send_tool_status(recipient, "<br>".join(lines))
+            completed.extend(current)
 
         return {"on_tool_start": on_tool_start}
 

penny/penny/config_params.py

@@ -116,6 +116,15 @@ def _validate_unit_float(value: str) -> float:
     group=GROUP_GLOBAL,
 )
 
+ConfigParam(
+    key="MESSAGE_MAX_TOOL_CALLS",
+    description="Max parallel tool calls per agent step",
+    type=int,
+    default=5,
+    validator=_validate_positive_int,
+    group=GROUP_GLOBAL,
+)
+
 ConfigParam(
     key="IMAGE_DOWNLOAD_TIMEOUT",
     description="Timeout in seconds for image downloads",

penny/penny/constants.py

@@ -110,7 +110,7 @@ class PreferenceSource(StrEnum):
     NEWS_NOTIFY_MAX_STEPS = 3
     TOOL_RESULT_TRUNCATION_THRESHOLD = 3
     TOOL_RESULT_TRUNCATION_MAX_CHARS = 500
-    MAX_TOOL_RESULT_CHARS = 8000
+    MAX_TOOL_RESULT_CHARS = 50000
     XML_RETRY_LIMIT = 3
     TOOL_FAILURE_ABORT_THRESHOLD = 2
     THOUGHT_CONTEXT_LIMIT = 10