Skip to content

Open-source Python library for AI browser agents, plus Browser Use Cloud: stealth browsers and a hosted agent API.

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.py
index 4bcacf171..3c3134d75 100644
--- a/browser_use/llm/anthropic/chat.py
+++ b/browser_use/llm/anthropic/chat.py
@@ -1,4 +1,5 @@
import json
+import re
from collections.abc import Mapping
from dataclasses import dataclass
from typing import Any, TypeVar, overload
@@ -28,6 +29,10 @@ from browser_use.llm.views import ChatInvokeCompletion, ChatInvokeUsage
T = 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)
+
@dataclass
class 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 recovered
if 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.py
new file mode 100644
index 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)