Open-source Python library for AI browser agents, plus Browser Use Cloud: stealth browsers and a hosted agent API.
Python ai-agentsai-toolsbrowser-agentbrowser-automationbrowser-usecdpcloud-browsercomputer-useheadless-browserllmmcpplaywrightpythonremote-browserstealth-browserweb-automationweb-scraping
Recover Anthropic tool arguments when the model serializes its call as text
Elay Gelbart5956e610a294
diff --git a/browser_use/llm/anthropic/chat.py b/browser_use/llm/anthropic/chat.pyindex 4bcacf171..3c3134d75 100644--- a/browser_use/llm/anthropic/chat.py+++ b/browser_use/llm/anthropic/chat.py@@ -1,4 +1,5 @@import json+import refrom collections.abc import Mappingfrom dataclasses import dataclassfrom typing import Any, TypeVar, overload@@ -28,6 +29,10 @@ from browser_use.llm.views import ChatInvokeCompletion, ChatInvokeUsageT = TypeVar('T', bound=BaseModel)+# `<parameter name="x">value</parameter>`, tolerating the mismatched `</x>` closing tag the+# model sometimes emits instead of `</parameter>`.+_TEXT_TOOL_CALL_PARAMETER = re.compile(r'<parameter name="([^"]+)">(.*?)(?:</parameter>|</\1>)', re.DOTALL)+@dataclassclass ChatAnthropic(BaseChatModel):@@ -279,6 +284,66 @@ class ChatAnthropic(BaseChatModel):return list(dict.fromkeys(candidate for candidate in candidates if candidate))+ def _repair_serialized_fields(self, values: dict[str, Any]) -> dict[str, Any]:+ """Decode fields the model double-serialized as JSON strings."""+ for key, value in values.items():+ if isinstance(value, str) and value.startswith(('[', '{')):+ try:+ values[key] = json.loads(value)+ except json.JSONDecodeError:+ cleaned = value.replace('\n', '\\n').replace('\r', '\\r').replace('\t', '\\t')+ try:+ values[key] = json.loads(cleaned)+ except json.JSONDecodeError:+ pass+ return values++ def _tool_call_from_text(self, text: str) -> dict[str, Any] | None:+ """Parse arguments out of a tool call the model rendered as text."""+ values = {name: value.strip() for name, value in _TEXT_TOOL_CALL_PARAMETER.findall(text)}+ return self._repair_serialized_fields(values) if values else None++ def _completion_from_serialized_tool_input(+ self, tool_input: Any, output_format: type[T], usage: ChatInvokeUsage | None, response: Any+ ) -> ChatInvokeCompletion[T] | None:+ """Recover the output when the model rendered its whole tool call into a string field.++ Claude sometimes calls the tool but fills only the first string property of the schema,+ with the entire call written out as text (`<parameter name=...>` markup or a JSON object)+ instead of populating the arguments. That text still carries every field, so parse it out+ rather than discarding the step.+ """+ if not isinstance(tool_input, dict):+ return None++ for value in tool_input.values():+ if not isinstance(value, str):+ continue++ candidates: list[Any] = []+ tool_call = self._tool_call_from_text(value)+ if tool_call is not None:+ candidates.append(tool_call)+ for text_candidate in self._json_candidates_from_text(value):+ try:+ candidates.append(json.loads(text_candidate))+ except (json.JSONDecodeError, TypeError):+ continue++ for candidate in candidates:+ try:+ completion = output_format.model_validate(candidate)+ except Exception:+ continue+ return ChatInvokeCompletion(+ completion=completion,+ usage=usage,+ stop_reason=response.stop_reason,+ stop_details=self._get_stop_details(response),+ )++ return None+def _completion_from_text_response(self, response: Any, output_format: type[T], usage: ChatInvokeUsage | None) -> ChatInvokeCompletion[T] | None:@@ -414,24 +479,21 @@ class ChatAnthropic(BaseChatModel):_input = json.loads(_input)elif isinstance(_input, dict):# Model sometimes double-serializes fields- for key, value in _input.items():- if isinstance(value, str) and value.startswith(('[', '{')):- try:- _input[key] = json.loads(value)- except json.JSONDecodeError:- cleaned = value.replace('\n', '\\n').replace('\r', '\\r').replace('\t', '\\t')- try:- _input[key] = json.loads(cleaned)- except json.JSONDecodeError:- pass+ _input = self._repair_serialized_fields(_input)else:raise- return ChatInvokeCompletion(- completion=output_format.model_validate(_input),- usage=usage,- stop_reason=response.stop_reason,- stop_details=self._get_stop_details(response),- )+ try:+ return ChatInvokeCompletion(+ completion=output_format.model_validate(_input),+ usage=usage,+ stop_reason=response.stop_reason,+ stop_details=self._get_stop_details(response),+ )+ except Exception:+ recovered = self._completion_from_serialized_tool_input(_input, output_format, usage, response)+ if recovered is None:+ raise+ return recoveredif self._requires_auto_tool_choice():text_completion = self._completion_from_text_response(response, output_format, usage)diff --git a/tests/ci/test_anthropic_serialized_tool_input.py b/tests/ci/test_anthropic_serialized_tool_input.pynew file mode 100644index 000000000..811976177--- /dev/null+++ b/tests/ci/test_anthropic_serialized_tool_input.py@@ -0,0 +1,98 @@+"""Regression test: when Claude calls the tool but writes the whole call out as text inside a+single string argument, the arguments must be recovered instead of failing validation with a+misleading 'Field required' error for the fields that were never populated."""++import json++import pytest+from pydantic import BaseModel++from browser_use.llm.anthropic.chat import ChatAnthropic+from browser_use.llm.exceptions import ModelProviderError+from browser_use.llm.messages import UserMessage+++class StepOutput(BaseModel):+ thinking: str+ action: list[dict]+++def _tool_use_response(tool_input: dict | str) -> dict:+ return {+ 'id': 'msg_test',+ 'type': 'message',+ 'role': 'assistant',+ 'model': 'claude-sonnet-5',+ 'content': [{'type': 'tool_use', 'id': 'toolu_test', 'name': 'StepOutput', 'input': tool_input}],+ 'stop_reason': 'tool_use',+ 'stop_sequence': None,+ 'usage': {'input_tokens': 10, 'output_tokens': 20},+ }+++def _chat(httpserver) -> ChatAnthropic:+ return ChatAnthropic(model='claude-sonnet-5', api_key='test-key', base_url=httpserver.url_for('/'))+++async def test_tool_call_rendered_as_xml_in_string_field_is_recovered(httpserver):+ """The model fills only `thinking`, with the complete call as `<parameter name=...>` markup."""+ actions = [{'click_element_by_index': {'index': 5}}]+ serialized = (+ '<invoke name="StepOutput">\n'+ '<parameter name="thinking">The submit button is at index 5.</parameter>\n'+ f'<parameter name="action">{json.dumps(actions)}</action>\n'+ '</invoke>\n'+ )+ httpserver.expect_request('/v1/messages', method='POST').respond_with_json(_tool_use_response({'thinking': serialized}))++ result = await _chat(httpserver).ainvoke([UserMessage(content='next step')], output_format=StepOutput)++ assert result.completion.thinking == 'The submit button is at index 5.'+ assert result.completion.action == actions+++async def test_tool_call_rendered_as_json_in_string_field_is_recovered(httpserver):+ """Same failure mode, but the model writes JSON into the string field instead of markup."""+ payload = {'thinking': 'Clicking submit.', 'action': [{'click_element_by_index': {'index': 5}}]}+ httpserver.expect_request('/v1/messages', method='POST').respond_with_json(+ _tool_use_response({'thinking': f'Here is my response:\n{json.dumps(payload)}'})+ )++ result = await _chat(httpserver).ainvoke([UserMessage(content='next step')], output_format=StepOutput)++ assert result.completion.action == payload['action']+++async def test_double_serialized_field_still_repaired(httpserver):+ """The pre-existing repair for a single JSON-string field must keep working."""+ actions = [{'click_element_by_index': {'index': 5}}]+ httpserver.expect_request('/v1/messages', method='POST').respond_with_json(+ _tool_use_response({'thinking': 'Clicking submit.', 'action': json.dumps(actions)})+ )++ result = await _chat(httpserver).ainvoke([UserMessage(content='next step')], output_format=StepOutput)++ assert result.completion.action == actions+++async def test_valid_tool_input_is_untouched(httpserver):+ actions = [{'click_element_by_index': {'index': 5}}]+ httpserver.expect_request('/v1/messages', method='POST').respond_with_json(+ _tool_use_response({'thinking': 'Clicking submit.', 'action': actions})+ )++ result = await _chat(httpserver).ainvoke([UserMessage(content='next step')], output_format=StepOutput)++ assert result.completion.action == actions+++async def test_unrecoverable_tool_input_still_raises(httpserver):+ """Recovery must not mask genuinely malformed output."""+ httpserver.expect_request('/v1/messages', method='POST').respond_with_json(+ _tool_use_response({'thinking': 'I could not decide what to do next.'})+ )++ with pytest.raises(ModelProviderError) as exc_info:+ await _chat(httpserver).ainvoke([UserMessage(content='next step')], output_format=StepOutput)++ assert 'action' in str(exc_info.value)