claude-proxy / tests /application /test_web_tools.py
dheraingoud's picture
Copilot App
Sync upstream v6.19.35 and preserve custom addons
a9e27c0
Raw History Blame Contribute Delete
4.63 kB
"""Application web-tool behavior through its explicit outbound capability."""
import asyncio
from collections.abc import AsyncIterator
import pytest
from free_claude_code.application.errors import InvalidRequestError
from free_claude_code.application.execution import ProviderExecutor
from free_claude_code.application.routing import ModelRouter
from free_claude_code.application.web_tools.ports import WebFetchEgressPolicy
from free_claude_code.application.web_tools.service import WebToolService
from free_claude_code.config.settings import Settings
from free_claude_code.core.anthropic.models import Message, MessagesRequest, Tool
from free_claude_code.core.stream_output import StreamOutput
from free_claude_code.core.web_tools import WebFetchResult
from tests.web_tools_support import StubWebToolsClient
async def _no_provider(_provider_id, _api_key_number):
pytest.fail("This request must not resolve a provider")
def _service(settings, client, *, token_counter=lambda *_: 5):
return WebToolService(
settings=settings,
client=client,
executor=ProviderExecutor(_no_provider),
token_counter=token_counter,
)
def _request(tool, *, typed=True):
return MessagesRequest(
model="claude-sonnet",
messages=[Message(role="user", content="https://example.com/")],
tools=[
Tool(
name=tool,
type=(
"web_fetch_20250910"
if tool == "web_fetch"
else "web_search_20250305"
)
if typed
else None,
)
],
tool_choice={"type": "tool", "name": tool},
)
async def _drain(body: AsyncIterator[StreamOutput]) -> str:
return "".join([frame async for packet in body for frame in packet.frames])
def test_ordinary_client_tool_needs_no_web_or_token_work():
settings = Settings()
service = _service(
settings,
StubWebToolsClient(),
token_counter=lambda *_: pytest.fail("Unhandled request counted tokens"),
)
routed = ModelRouter(settings).resolve_messages_request(
_request("web_search", typed=False)
)
assert service.try_stream_messages(routed, request_id="req_unhandled") is None
def test_disabled_tool_fails_during_preparation():
settings = Settings().model_copy(update={"enable_web_server_tools": False})
service = _service(settings, StubWebToolsClient())
routed = ModelRouter(settings).resolve_messages_request(_request("web_fetch"))
with pytest.raises(InvalidRequestError, match="disabled"):
service.try_stream_messages(routed, request_id="req_disabled")
@pytest.mark.asyncio
async def test_concurrent_requests_keep_their_own_egress_policy():
entered, release = asyncio.Event(), asyncio.Event()
class Client(StubWebToolsClient):
def __init__(self):
self.policies = []
async def fetch(
self, url: str, *, egress: WebFetchEgressPolicy
) -> WebFetchResult:
self.policies.append(egress)
if len(self.policies) == 2:
entered.set()
await release.wait()
return WebFetchResult(
url=url, title="page", media_type="text/plain", data="text"
)
client = Client()
settings = [
Settings().model_copy(
update={
"web_fetch_allow_private_networks": False,
"web_fetch_allowed_schemes": "https",
}
),
Settings().model_copy(
update={
"web_fetch_allow_private_networks": True,
"web_fetch_allowed_schemes": "http, https",
}
),
]
tasks = []
try:
for index, snapshot in enumerate(settings):
service = _service(snapshot, client)
body = service.try_stream_messages(
ModelRouter(snapshot).resolve_messages_request(_request("web_fetch")),
request_id=f"req_{index}",
)
assert body is not None
tasks.append(asyncio.create_task(_drain(body)))
await asyncio.wait_for(entered.wait(), 1)
assert client.policies == [
WebFetchEgressPolicy(False, frozenset({"https"})),
WebFetchEgressPolicy(True, frozenset({"http", "https"})),
]
release.set()
outputs = await asyncio.gather(*tasks)
assert all("web_fetch_tool_result" in output for output in outputs)
finally:
release.set()
await asyncio.gather(*tasks, return_exceptions=True)