Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)
Python
Allow repeated automatic WebSearch across providers (#1871)
Ali Khokhar5464f068c32b
diff --git a/pyproject.toml b/pyproject.tomlindex 823cd38e..b56df965 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "hatchling.build"[project]name = "free-claude-code"-version = "6.2.57"+version = "6.2.58"description = "Local proxy connecting coding agents to OpenAI-compatible AI providers"readme = "README.md"requires-python = ">=3.14.0"diff --git a/src/free_claude_code/application/web_tools/request.py b/src/free_claude_code/application/web_tools/request.pyindex 8f96fb8e..1efee57c 100644--- a/src/free_claude_code/application/web_tools/request.py+++ b/src/free_claude_code/application/web_tools/request.py@@ -1,10 +1,17 @@"""Recognize the narrow Anthropic web-tool requests FCC can execute locally."""+import jsonimport refrom dataclasses import dataclassfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.core.anthropic import MessagesRequest, Tool+from free_claude_code.core.anthropic.models import (+ ContentBlockServerToolUse,+ ContentBlockText,+ ContentBlockWebSearchToolResult,+ Message,+)WEB_SEARCH_TYPE = "web_search_20250305"WEB_FETCH_TYPE = "web_fetch_20250910"@@ -41,6 +48,7 @@ class AutomaticWebSearchPlan:request: MessagesRequestdomains: WebSearchDomainFilter+ max_uses: int | Nonedef forced_tool_turn_text(request: MessagesRequest) -> str:@@ -117,10 +125,6 @@ def plan_automatic_web_search("Anthropic web_search is disabled (ENABLE_WEB_SERVER_TOOLS=false). ""Enable local web tools or remove web_search from the request.")- if _has_server_tool_history(request):- raise InvalidRequestError(- "Automatic web_search does not accept prior Anthropic server-tool history."- )if tool.name != "web_search":raise InvalidRequestError(f"Server tool type {WEB_SEARCH_TYPE!r} must use name 'web_search'."@@ -138,7 +142,7 @@ def plan_automatic_web_search(+ ", ".join(unsupported)+ ".")- _validate_max_uses(options.get("max_uses"))+ max_uses = _validate_max_uses(options.get("max_uses"))allowed = _parse_domains(options.get("allowed_domains"), field="web_search.allowed_domains")@@ -161,12 +165,16 @@ def plan_automatic_web_search(},)translated = request.model_copy(- update={"tools": [hidden_tool]},+ update={+ "tools": [hidden_tool],+ "messages": _normalized_search_history(request.messages),+ },deep=True,)return AutomaticWebSearchPlan(request=translated,domains=WebSearchDomainFilter(allowed=allowed, blocked=blocked),+ max_uses=max_uses,)@@ -190,21 +198,96 @@ def unsupported_server_tool_error(return None-def _has_server_tool_history(request: MessagesRequest) -> bool:- for message in request.messages:- if not isinstance(message.content, list):+_INCOMPLETE_HISTORY = (+ "Automatic web_search does not accept incomplete or unsupported prior "+ "Anthropic server-tool history."+)+++def _normalized_search_history(messages: list[Message]) -> list[Message]:+ """Quote completed local search data for every upstream transport."""+ normalized: list[Message] = []+ for message in messages:+ content = message.content+ if not isinstance(content, list) or not any(+ getattr(block, "type", None) in _SERVER_HISTORY_TYPES for block in content+ ):+ normalized.append(message)continue- for block in message.content:- if getattr(block, "type", None) in _SERVER_HISTORY_TYPES:- return True- return False+ if message.role != "assistant":+ raise InvalidRequestError(_INCOMPLETE_HISTORY)++ uses: dict[str, ContentBlockServerToolUse] = {}+ results: dict[str, ContentBlockWebSearchToolResult] = {}+ for block in content:+ if isinstance(block, ContentBlockServerToolUse):+ query = block.input.get("query")+ if (+ block.name != "web_search"+ or not block.id+ or block.id in uses+ or set(block.input) != {"query"}+ or not isinstance(query, str)+ or not query.strip()+ ):+ raise InvalidRequestError(_INCOMPLETE_HISTORY)+ uses[block.id] = block+ elif isinstance(block, ContentBlockWebSearchToolResult):+ if not block.tool_use_id or block.tool_use_id in results:+ raise InvalidRequestError(_INCOMPLETE_HISTORY)+ results[block.tool_use_id] = block+ elif getattr(block, "type", None) in _SERVER_HISTORY_TYPES:+ raise InvalidRequestError(_INCOMPLETE_HISTORY)+ if not uses or uses.keys() != results.keys():+ raise InvalidRequestError(_INCOMPLETE_HISTORY)++ projected = []+ for block in content:+ if isinstance(block, ContentBlockServerToolUse):+ projected.append(_search_history_text(block, results[block.id]))+ elif not isinstance(block, ContentBlockWebSearchToolResult):+ projected.append(block)+ normalized.append(message.model_copy(update={"content": projected}, deep=True))+ return normalized+++def _search_history_text(+ use: ContentBlockServerToolUse, result: ContentBlockWebSearchToolResult+) -> ContentBlockText:+ content = result.content+ if isinstance(content, list):+ hits: list[dict[str, str]] = []+ for hit in content:+ if (+ not isinstance(hit, dict)+ or hit.get("type") != "web_search_result"+ or not isinstance(hit.get("title"), str)+ or not isinstance(hit.get("url"), str)+ ):+ raise InvalidRequestError(_INCOMPLETE_HISTORY)+ hits.append({"title": hit["title"], "url": hit["url"]})+ record: dict[str, object] = {"query": use.input["query"], "results": hits}+ elif (+ isinstance(content, dict)+ and content.get("type") == "web_search_tool_result_error"+ and isinstance(content.get("error_code"), str)+ ):+ record = {"query": use.input["query"], "error_code": content["error_code"]}+ else:+ raise InvalidRequestError(_INCOMPLETE_HISTORY)+ return ContentBlockText(+ type="text",+ text="[Earlier web search data]\n"+ + json.dumps(record, ensure_ascii=False, separators=(",", ":")),+ )-def _validate_max_uses(value: object) -> None:+def _validate_max_uses(value: object) -> int | None:if value is None:- return+ return Noneif isinstance(value, bool) or not isinstance(value, int) or value <= 0:raise InvalidRequestError("web_search.max_uses must be a positive integer.")+ return valuedef _parse_domains(value: object, *, field: str) -> tuple[str, ...]:diff --git a/src/free_claude_code/application/web_tools/service.py b/src/free_claude_code/application/web_tools/service.pyindex 28a22055..2897757e 100644--- a/src/free_claude_code/application/web_tools/service.py+++ b/src/free_claude_code/application/web_tools/service.py@@ -1,5 +1,6 @@"""Application workflow for supported local Anthropic web-tool requests."""+import asyncioimport sysimport uuidfrom collections.abc import AsyncIterator, Mapping@@ -20,12 +21,17 @@ from free_claude_code.core.anthropic import (from free_claude_code.core.anthropic.server_tool_sse import (ServerToolResponseContext,server_tool_completion_frames,+ server_tool_finish_frames,+ server_tool_message_start_frames,+ server_tool_result_frames,server_tool_start_frames,+ server_tool_use_frames,web_fetch_result_block,web_search_result_block,web_tool_error_block,)from free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.json_types import JsonObjectfrom free_claude_code.core.trace import close_stream_input, trace_eventfrom free_claude_code.core.web_tools import WebSearchResult@@ -163,30 +169,26 @@ class WebToolService:for chunk in chunks:yield chunkreturn- if len(tool_calls) != 1:- raise _protocol_failure(- "Upstream model returned multiple tool calls for automatic WebSearch.",- request_id=request_id,- )- call = tool_calls[0]- if call.get("name") != HIDDEN_WEB_SEARCH_NAME:- raise _protocol_failure(- "Upstream model returned an unexpected tool for automatic WebSearch.",- request_id=request_id,- )- arguments = call.get("input")- if not isinstance(arguments, dict) or set(arguments) != {"query"}:- raise _protocol_failure(- "Upstream model returned malformed arguments for automatic WebSearch.",- request_id=request_id,- )- raw_query = arguments.get("query")- if not isinstance(raw_query, str) or not raw_query.strip():- raise _protocol_failure(- "Upstream model returned an empty query for automatic WebSearch.",- request_id=request_id,- )- query = raw_query.strip()+ queries: list[str] = []+ for call in tool_calls:+ if call.get("name") != HIDDEN_WEB_SEARCH_NAME:+ raise _protocol_failure(+ "Upstream model returned an unexpected tool for automatic WebSearch.",+ request_id=request_id,+ )+ arguments = call.get("input")+ if not isinstance(arguments, dict) or set(arguments) != {"query"}:+ raise _protocol_failure(+ "Upstream model returned malformed arguments for automatic WebSearch.",+ request_id=request_id,+ )+ raw_query = arguments.get("query")+ if not isinstance(raw_query, str) or not raw_query.strip():+ raise _protocol_failure(+ "Upstream model returned an empty query for automatic WebSearch.",+ request_id=request_id,+ )+ queries.append(raw_query.strip())provider_usage = _provider_usage(message)input_tokens = _integer_field(provider_usage, "input_tokens")if input_tokens is None:@@ -199,24 +201,62 @@ class WebToolService:request_id=request_id,model=routed.resolved.original_model,)- local_stream = self._stream_local_tool(- tool_name="web_search",- tool_input={"query": query},- input_tokens=input_tokens,- response_model=routed.resolved.original_model,- provider_usage=provider_usage,- domains=plan.domains,- )- try:- async for frame in local_stream:- yield frame- finally:- await close_stream_input(- local_stream,- owner="automatic_web_search",- source="api",- preserved_error=sys.exception(),+ message_id = f"msg_{uuid.uuid4()}"+ contexts = [+ ServerToolResponseContext(+ message_id=message_id,+ tool_id=f"srvtoolu_{uuid.uuid4().hex}",+ model=routed.resolved.original_model,+ tool_name="web_search",+ tool_input={"query": query},+ input_tokens=input_tokens,+ provider_usage=provider_usage,)+ for query in queries+ ]+ executed = min(len(contexts), plan.max_uses or len(contexts))+ for frame in server_tool_message_start_frames(contexts[0]):+ yield frame++ limit = asyncio.Semaphore(4)++ async def search_one(+ context: ServerToolResponseContext,+ ) -> tuple[JsonObject, str]:+ async with limit:+ return await self._search_result(context, plan.domains)++ summaries: list[str] = []+ async with asyncio.TaskGroup() as group:+ tasks = [+ group.create_task(search_one(context))+ for context in contexts[:executed]+ ]+ for index, context in enumerate(contexts):+ for frame in server_tool_use_frames(context, index=index * 2):+ yield frame+ if index < executed:+ result_block, summary = await tasks[index]+ else:+ result_block = web_tool_error_block(+ context, error_code="max_uses_exceeded"+ )+ summary = (+ f"Web search limit reached for: {context.tool_input['query']}"+ )+ for frame in server_tool_result_frames(+ result_block, index=index * 2 + 1+ ):+ yield frame+ summaries.append(summary)++ for frame in server_tool_finish_frames(+ contexts[0],+ summary="\n\n".join(summaries),+ index=len(contexts) * 2,+ request_count=executed,+ ):+ yield frametrace_event(stage="execution",event="free_claude_code.api.web_search.automatic_completed",@@ -247,15 +287,10 @@ class WebToolService:for frame in server_tool_start_frames(context):yield frame- try:- if tool_name == "web_search":- query = tool_input["query"]- results = await self._client.search(query)- if domains is not None:- results = _filter_results(results, domains)- result_block = web_search_result_block(context, results)- summary = _search_summary(query, results)- else:+ if tool_name == "web_search":+ result_block, summary = await self._search_result(context, domains)+ else:+ try:fetched = await self._client.fetch(tool_input["url"], egress=self._egress)@@ -263,19 +298,37 @@ class WebToolService:context, fetched, retrieved_at=datetime.now(UTC).isoformat())summary = fetched.data- except Exception as error:- fetch_url = tool_input.get("url") if tool_name == "web_fetch" else None- _log_web_tool_failure(tool_name, error, fetch_url=fetch_url)- result_block = web_tool_error_block(context)- summary = _web_tool_client_error_summary(- tool_name, error, verbose=self._verbose_client_errors- )+ except Exception as error:+ _log_web_tool_failure(tool_name, error, fetch_url=tool_input["url"])+ result_block = web_tool_error_block(context)+ summary = _web_tool_client_error_summary(+ tool_name, error, verbose=self._verbose_client_errors+ )for frame in server_tool_completion_frames(context, result_block, summary=summary):yield frame+ async def _search_result(+ self,+ context: ServerToolResponseContext,+ domains: WebSearchDomainFilter | None,+ ) -> tuple[JsonObject, str]:+ query = context.tool_input["query"]+ try:+ results = await self._client.search(query)+ if domains is not None:+ results = _filter_results(results, domains)+ return web_search_result_block(context, results), _search_summary(+ query, results+ )+ except Exception as error:+ _log_web_tool_failure("web_search", error, fetch_url=None)+ return web_tool_error_block(context), _web_tool_client_error_summary(+ "web_search", error, verbose=self._verbose_client_errors+ )+def _search_summary(query: str, results: list[WebSearchResult]) -> str:if not results:diff --git a/src/free_claude_code/core/anthropic/server_tool_sse.py b/src/free_claude_code/core/anthropic/server_tool_sse.pyindex db9e7aa5..7a705821 100644--- a/src/free_claude_code/core/anthropic/server_tool_sse.py+++ b/src/free_claude_code/core/anthropic/server_tool_sse.py@@ -28,6 +28,13 @@ class ServerToolResponseContext:def server_tool_start_frames(context: ServerToolResponseContext) -> Iterator[str]:+ yield from server_tool_message_start_frames(context)+ yield from server_tool_use_frames(context, index=0)+++def server_tool_message_start_frames(+ context: ServerToolResponseContext,+) -> Iterator[str]:yield format_sse_event("message_start",{@@ -46,11 +53,16 @@ def server_tool_start_frames(context: ServerToolResponseContext) -> Iterator[str},},)+++def server_tool_use_frames(+ context: ServerToolResponseContext, *, index: int+) -> Iterator[str]:yield format_sse_event("content_block_start",{"type": "content_block_start",- "index": 0,+ "index": index,"content_block": {"type": SERVER_TOOL_USE,"id": context.tool_id,@@ -60,7 +72,7 @@ def server_tool_start_frames(context: ServerToolResponseContext) -> Iterator[str},)yield format_sse_event(- "content_block_stop", {"type": "content_block_stop", "index": 0}+ "content_block_stop", {"type": "content_block_stop", "index": index})@@ -104,14 +116,16 @@ def web_fetch_result_block(}-def web_tool_error_block(context: ServerToolResponseContext) -> JsonObject:+def web_tool_error_block(+ context: ServerToolResponseContext, *, error_code: str = "unavailable"+) -> JsonObject:search = context.tool_name == "web_search"return {"type": WEB_SEARCH_TOOL_RESULT if search else WEB_FETCH_TOOL_RESULT,"tool_use_id": context.tool_id,"content": {"type": WEB_SEARCH_TOOL_RESULT_ERROR if search else WEB_FETCH_TOOL_ERROR,- "error_code": "unavailable",+ "error_code": error_code,},}@@ -122,18 +136,32 @@ def server_tool_completion_frames(*,summary: str,) -> Iterator[str]:+ yield from server_tool_result_frames(result_block, index=1)+ yield from server_tool_finish_frames(context, summary=summary, index=2)+++def server_tool_result_frames(result_block: JsonObject, *, index: int) -> Iterator[str]:yield format_sse_event("content_block_start",- {"type": "content_block_start", "index": 1, "content_block": result_block},+ {"type": "content_block_start", "index": index, "content_block": result_block},)yield format_sse_event(- "content_block_stop", {"type": "content_block_stop", "index": 1}+ "content_block_stop", {"type": "content_block_stop", "index": index})+++def server_tool_finish_frames(+ context: ServerToolResponseContext,+ *,+ summary: str,+ index: int,+ request_count: int = 1,+) -> Iterator[str]:yield format_sse_event("content_block_start",{"type": "content_block_start",- "index": 2,+ "index": index,"content_block": {"type": "text", "text": ""},},)@@ -141,12 +169,12 @@ def server_tool_completion_frames("content_block_delta",{"type": "content_block_delta",- "index": 2,+ "index": index,"delta": {"type": "text_delta", "text": summary},},)yield format_sse_event(- "content_block_stop", {"type": "content_block_stop", "index": 2}+ "content_block_stop", {"type": "content_block_stop", "index": index})yield format_sse_event("message_delta",@@ -158,6 +186,7 @@ def server_tool_completion_frames(summary,context.provider_usage,usage_key=f"{context.tool_name}_requests",+ request_count=request_count,),},)@@ -182,6 +211,7 @@ def _completion_usage(provider_usage: Mapping[str, object] | None,*,usage_key: str,+ request_count: int,) -> dict[str, object]:if provider_usage is None:usage: dict[str, object] = {@@ -192,7 +222,7 @@ def _completion_usage(usage = _integer_usage(provider_usage)usage.setdefault("input_tokens", input_tokens)usage.setdefault("output_tokens", max(1, len(summary) // 4))- usage["server_tool_use"] = {usage_key: 1}+ usage["server_tool_use"] = {usage_key: request_count}return usagediff --git a/tests/api/test_web_server_tools.py b/tests/api/test_web_server_tools.pyindex 8abb0310..bb8dc44f 100644--- a/tests/api/test_web_server_tools.py+++ b/tests/api/test_web_server_tools.py@@ -34,12 +34,17 @@ from free_claude_code.application.web_tools.service import WebToolServicefrom free_claude_code.config.provider_catalog import PROVIDER_CATALOGfrom free_claude_code.config.reasoning import ReasoningPreferencefrom free_claude_code.config.settings import Settings+from free_claude_code.core.anthropic.conversion import AnthropicToOpenAIConverterfrom free_claude_code.core.anthropic.models import (ContentBlockServerToolUse,Message,MessagesRequest,Tool,)+from free_claude_code.core.anthropic.native import (+ NativeMessagesOptions,+ build_native_messages_request,+)from free_claude_code.core.anthropic.stream_contracts import (assert_anthropic_stream_contract,parse_sse_text,@@ -48,6 +53,9 @@ from free_claude_code.core.anthropic.stream_contracts import (from free_claude_code.core.anthropic.streaming import format_sse_eventfrom free_claude_code.core.failures import ExecutionFailure, FailureKindfrom free_claude_code.core.openai_responses import OpenAIResponsesRequest+from free_claude_code.core.openai_responses.provider_input import (+ build_responses_provider_request,+)from free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.core.version import package_versionfrom free_claude_code.core.web_tools import WebFetchResult, WebSearchResult@@ -268,11 +276,13 @@ def _provider_tool_events(name: str = HIDDEN_WEB_SEARCH_NAME,arguments: dict[str, object] | None = None,additional_calls: int = 0,+ additional_inputs: list[dict[str, object]] | None = None,) -> list[str]:calls = [(name, arguments if arguments is not None else {"query": "selected"})]calls.extend((name, {"query": f"extra-{index}"}) for index in range(additional_calls))+ calls.extend((name, item) for item in additional_inputs or [])events = [format_sse_event("message_start",@@ -763,15 +773,352 @@ async def test_automatic_web_search_aggregates_when_stream_false(assert len(provider.requests) == 1+async def test_automatic_web_search_runs_multiple_calls_in_one_message(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ provider = ScriptedSelectionProvider(_provider_tool_events(additional_calls=1))+ seen_queries: list[str] = []++ async def fake_search(self, query: str) -> list[WebSearchResult]:+ seen_queries.append(query)+ return [+ WebSearchResult(title=f"{query} first", url="https://example.com/1"),+ WebSearchResult(title=f"{query} second", url="https://example.com/2"),+ ]++ monkeypatch.setattr(+ "tests.web_tools_support.StubWebToolsClient.search", fake_search+ )+ service = _automatic_search_service(provider)++ response = await service.create(_automatic_search_request(stream=False))++ assert isinstance(response, JSONResponse)+ body = _json_body(response)+ assert [block["type"] for block in body["content"]] == [+ "server_tool_use",+ "web_search_tool_result",+ "server_tool_use",+ "web_search_tool_result",+ "text",+ ]+ first_use, first_result, second_use, second_result, _ = body["content"]+ assert [first_use["input"]["query"], second_use["input"]["query"]] == [+ "selected",+ "extra-0",+ ]+ assert first_use["id"] != second_use["id"]+ assert first_result["tool_use_id"] == first_use["id"]+ assert second_result["tool_use_id"] == second_use["id"]+ assert len(first_result["content"]) == len(second_result["content"]) == 2+ assert set(seen_queries) == {"selected", "extra-0"}+ assert body["usage"]["server_tool_use"] == {"web_search_requests": 2}+++async def test_automatic_web_search_streams_ordered_multiple_calls(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ provider = ScriptedSelectionProvider(_provider_tool_events(additional_calls=1))++ async def fake_search(self, query: str) -> list[WebSearchResult]:+ return [WebSearchResult(title=query, url=f"https://example.com/{query}")]++ monkeypatch.setattr(+ "tests.web_tools_support.StubWebToolsClient.search", fake_search+ )+ response = await _automatic_search_service(provider).create(+ _automatic_search_request()+ )++ assert isinstance(response, StreamingResponse)+ events = parse_sse_text(await _streaming_body_text(response))+ assert_anthropic_stream_contract(events)+ starts = [event for event in events if event.event == "content_block_start"]+ assert [event.data["index"] for event in starts] == list(range(5))+ assert [event.data["content_block"]["type"] for event in starts] == [+ "server_tool_use",+ "web_search_tool_result",+ "server_tool_use",+ "web_search_tool_result",+ "text",+ ]+ assert sum(event.event == "message_start" for event in events) == 1+ assert sum(event.event == "message_stop" for event in events) == 1+ assert next(+ event.data["usage"]["server_tool_use"]+ for event in events+ if event.event == "message_delta"+ ) == {"web_search_requests": 2}+++async def test_automatic_web_search_max_uses_limits_current_request(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ provider = ScriptedSelectionProvider(_provider_tool_events(additional_calls=1))+ search = AsyncMock(+ return_value=[WebSearchResult(title="found", url="https://example.com/")]+ )+ monkeypatch.setattr("tests.web_tools_support.StubWebToolsClient.search", search)+ request = _automatic_search_request(+ stream=False,+ tool=Tool(name="web_search", type="web_search_20250305", max_uses=1),+ )++ response = await _automatic_search_service(provider).create(request)++ assert isinstance(response, JSONResponse)+ body = _json_body(response)+ assert body["content"][1]["content"][0]["title"] == "found"+ assert body["content"][3]["content"] == {+ "type": "web_search_tool_result_error",+ "error_code": "max_uses_exceeded",+ }+ search.assert_awaited_once_with("selected")+ assert body["usage"]["server_tool_use"] == {"web_search_requests": 1}+++async def test_automatic_web_search_keeps_other_results_when_one_search_fails(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ provider = ScriptedSelectionProvider(_provider_tool_events(additional_calls=1))++ async def fake_search(self, query: str) -> list[WebSearchResult]:+ if query == "extra-0":+ raise RuntimeError("search unavailable")+ return [WebSearchResult(title="found", url="https://example.com/")]++ monkeypatch.setattr(+ "tests.web_tools_support.StubWebToolsClient.search", fake_search+ )+ response = await _automatic_search_service(provider).create(+ _automatic_search_request(stream=False)+ )++ assert isinstance(response, JSONResponse)+ body = _json_body(response)+ assert body["content"][1]["content"][0]["title"] == "found"+ assert body["content"][3]["content"] == {+ "type": "web_search_tool_result_error",+ "error_code": "unavailable",+ }+ assert body["usage"]["server_tool_use"] == {"web_search_requests": 2}+++async def test_automatic_web_search_validates_all_calls_before_search(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ provider = ScriptedSelectionProvider(+ _provider_tool_events(additional_inputs=[{"query": ""}])+ )+ search = AsyncMock()+ monkeypatch.setattr("tests.web_tools_support.StubWebToolsClient.search", search)++ response = await _automatic_search_service(provider).create(+ _automatic_search_request(stream=False)+ )++ assert isinstance(response, JSONResponse)+ assert response.status_code == 500+ search.assert_not_awaited()+++async def test_automatic_web_search_bounds_parallel_local_searches(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ provider = ScriptedSelectionProvider(_provider_tool_events(additional_calls=4))+ four_started = asyncio.Event()+ release = asyncio.Event()+ active = 0+ peak = 0+ started: list[str] = []++ async def fake_search(self, query: str) -> list[WebSearchResult]:+ nonlocal active, peak+ active += 1+ peak = max(peak, active)+ started.append(query)+ if active == 4:+ four_started.set()+ try:+ await release.wait()+ finally:+ active -= 1+ return []++ monkeypatch.setattr(+ "tests.web_tools_support.StubWebToolsClient.search", fake_search+ )+ pending = asyncio.create_task(+ _automatic_search_service(provider).create(+ _automatic_search_request(stream=False)+ )+ )+ try:+ await asyncio.wait_for(four_started.wait(), 1)+ assert len(started) == 4+ assert peak == 4+ release.set()+ response = await asyncio.wait_for(pending, 1)+ assert isinstance(response, JSONResponse)+ assert _json_body(response)["usage"]["server_tool_use"] == {+ "web_search_requests": 5+ }+ assert len(started) == 5+ finally:+ release.set()+ pending.cancel()+ await asyncio.gather(pending, return_exceptions=True)+++async def test_automatic_web_search_cancellation_stops_parallel_searches(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ provider = ScriptedSelectionProvider(_provider_tool_events(additional_calls=1))+ both_started = asyncio.Event()+ started: set[str] = set()+ cancelled: set[str] = set()++ async def fake_search(self, query: str) -> list[WebSearchResult]:+ started.add(query)+ if len(started) == 2:+ both_started.set()+ try:+ await asyncio.Event().wait()+ finally:+ cancelled.add(query)+ return []++ monkeypatch.setattr(+ "tests.web_tools_support.StubWebToolsClient.search", fake_search+ )+ response = await _automatic_search_service(provider).create(+ _automatic_search_request()+ )+ assert isinstance(response, StreamingResponse)+ drain = asyncio.create_task(_streaming_body_text(response))+ try:+ await asyncio.wait_for(both_started.wait(), 1)+ drain.cancel()+ with pytest.raises(asyncio.CancelledError):+ await drain+ assert cancelled == {"selected", "extra-0"}+ assert provider.close_count == 1+ finally:+ drain.cancel()+ await asyncio.gather(drain, return_exceptions=True)+++async def test_automatic_web_search_can_search_again_after_completed_history(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ provider = ScriptedSelectionProvider(+ _provider_tool_events(arguments={"query": "first"})+ )++ async def fake_search(self, query: str) -> list[WebSearchResult]:+ return [WebSearchResult(title=query, url=f"https://example.com/{query}")]++ monkeypatch.setattr(+ "tests.web_tools_support.StubWebToolsClient.search", fake_search+ )+ service = _automatic_search_service(provider)+ first = await service.create(_automatic_search_request(stream=False))+ assert isinstance(first, JSONResponse)+ first_content = _json_body(first)["content"]++ provider.events = _provider_tool_events(arguments={"query": "second"})+ second_request = _automatic_search_request(stream=False)+ second_request.messages.extend(+ [+ Message.model_validate({"role": "assistant", "content": first_content}),+ Message(role="user", content="Search for a second thing"),+ ]+ )+ second = await service.create(second_request)++ assert isinstance(second, JSONResponse)+ assert second.status_code == 200+ assert _json_body(second)["content"][1]["content"][0]["title"] == "second"+ assert len(provider.requests) == 2+ assert all(+ getattr(block, "type", None)+ not in {"server_tool_use", "web_search_tool_result"}+ for block in provider.requests[1].messages[1].content+ )+ assert "https://example.com/first" in str(provider.requests[1].messages[1].content)+ assert getattr(second_request.messages[1].content[0], "type", None) == (+ "server_tool_use"+ )+++def test_automatic_web_search_history_projects_for_each_provider_transport() -> None:+ request = _automatic_search_request()+ request.messages.extend(+ [+ Message.model_validate(+ {+ "role": "assistant",+ "content": [+ {+ "type": "server_tool_use",+ "id": "srvtoolu_prior",+ "name": "web_search",+ "input": {"query": "prior"},+ },+ {+ "type": "web_search_tool_result",+ "tool_use_id": "srvtoolu_prior",+ "content": [+ {+ "type": "web_search_result",+ "title": "Prior hit",+ "url": "https://example.com/prior",+ "encrypted_content": "opaque",+ }+ ],+ },+ ],+ }+ ),+ Message(role="user", content="Search again"),+ ]+ )++ plan = plan_automatic_web_search(request, web_tools_enabled=True)++ assert plan is not None+ chat = AnthropicToOpenAIConverter.convert_messages(plan.request.messages)+ responses = build_responses_provider_request(+ plan.request, reasoning=ReasoningPolicy.off()+ )+ native = build_native_messages_request(+ plan.request,+ options=NativeMessagesOptions(model=plan.request.model, max_tokens=100),+ ).body+ for wire in (chat, responses, native):+ serialized = json.dumps(wire)+ assert "https://example.com/prior" in serialized+ assert '"opaque"' not in serialized+ assert "server_tool_use" not in serialized+ assert getattr(request.messages[1].content[0], "type", None) == ("server_tool_use")++@pytest.mark.asyncio@pytest.mark.parametrize("events",[_provider_tool_events(arguments={"query": ""}),_provider_tool_events(name="unexpected_tool"),- _provider_tool_events(additional_calls=1),],- ids=["blank-query", "wrong-tool", "multiple-tools"],+ ids=["blank-query", "wrong-tool"],)async def test_automatic_web_search_rejects_malformed_provider_selection(events: list[str],diff --git a/uv.lock b/uv.lockindex 4cecec00..4b1fb145 100644--- a/uv.lock+++ b/uv.lock@@ -599,7 +599,7 @@ wheels = [[[package]]name = "free-claude-code"-version = "6.2.57"+version = "6.2.58"source = { editable = "." }dependencies = [{ name = "aiohttp" },