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
Fix Codex failing before its first reply on OpenCode Zen (#1696)
Ali Khokharcb87064e3b60
diff --git a/pyproject.toml b/pyproject.tomlindex fe06fcc3..4880295e 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "hatchling.build"[project]name = "free-claude-code"-version = "5.22.8"+version = "5.22.9"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/core/openai_responses/__init__.py b/src/free_claude_code/core/openai_responses/__init__.pyindex 81c4a32e..be29f52b 100644--- a/src/free_claude_code/core/openai_responses/__init__.py+++ b/src/free_claude_code/core/openai_responses/__init__.py@@ -37,7 +37,16 @@ from .streaming.error_mapping import replay_unsafe_function_call_errorfrom .streaming.event_builders import ResponseEventBuilderfrom .streaming.ledger import ResponsesOutputLedgerfrom .tokens import estimate_responses_input_tokens-from .tools import ResponsesToolIdentity, responses_tool_identity_from_anthropic_name+from .tool_adaptation import (+ ResponsesToolAdapter,+ ResponsesToolEventAdapter,+ ResponsesToolPolicy,+)+from .tools import (+ ResponsesToolIdentity,+ flatten_responses_tool_name,+ responses_tool_identity_from_wire_name,+)__all__ = ["OPENAI_RESPONSES_SSE_HEADERS",@@ -54,7 +63,10 @@ __all__ = ["ResponsesOutputLedger","ResponsesProviderStream","ResponsesStreamFailure",+ "ResponsesToolAdapter",+ "ResponsesToolEventAdapter","ResponsesToolIdentity",+ "ResponsesToolPolicy","TextBlockState","ToolBlockState","build_native_responses_request",@@ -63,6 +75,7 @@ __all__ = ["build_responses_provider_request","committed_response_failure_frame","estimate_responses_input_tokens",+ "flatten_responses_tool_name","new_call_id","new_message_item_id","new_reasoning_item_id",@@ -76,6 +89,6 @@ __all__ = ["responses_reasoning_config","responses_reasoning_policy","responses_stream_failure_from_event",- "responses_tool_identity_from_anthropic_name",+ "responses_tool_identity_from_wire_name","tool_item",]diff --git a/src/free_claude_code/core/openai_responses/chat_request.py b/src/free_claude_code/core/openai_responses/chat_request.pyindex 32986cdb..5504526b 100644--- a/src/free_claude_code/core/openai_responses/chat_request.py+++ b/src/free_claude_code/core/openai_responses/chat_request.py@@ -26,11 +26,13 @@ from .reasoning import (from .reasoning_replay import reject_messages_reasoning_for_other_egressfrom .tools import (call_id_from_item,+ custom_tool_description,+ custom_tool_input_schema,custom_tool_input_text,+ flatten_responses_tool_name,optional_str,parse_arguments,required_str,- responses_tool_name_to_anthropic_name,)_PASSIVE_TOOL_TYPES = frozenset(@@ -460,7 +462,7 @@ def _image_part(part: Mapping[str, JsonValue], *, context: str) -> dict[str, objdef _tool_identity_name(item: Mapping[str, JsonValue]) -> str:name = required_str(item.get("name"), f"{item.get('type')}.name")namespace = optional_str(item.get("namespace"))- return responses_tool_name_to_anthropic_name(name, namespace=namespace)+ return flatten_responses_tool_name(name, namespace=namespace)def _arguments_text(value: JsonValue) -> str:@@ -593,7 +595,7 @@ def _chat_function_tool(nested = tool.get("function")source = nested if isinstance(nested, Mapping) else toolname = required_str(source.get("name"), "tool.name")- wire_name = responses_tool_name_to_anthropic_name(name, namespace=namespace)+ wire_name = flatten_responses_tool_name(name, namespace=namespace)parameters = source.get("parameters")if parameters is None:parameters = {"type": "object", "properties": {}}@@ -619,45 +621,16 @@ def _chat_custom_tool(nested = tool.get("custom")source = nested if isinstance(nested, Mapping) else toolname = required_str(source.get("name"), "tool.name")- wire_name = responses_tool_name_to_anthropic_name(name, namespace=namespace)+ wire_name = flatten_responses_tool_name(name, namespace=namespace)function: dict[str, object] = {"name": wire_name,- "parameters": {- "type": "object",- "properties": {- "input": {- "type": "string",- "description": "Free-form input for the custom tool.",- }- },- "required": ["input"],- },+ "parameters": custom_tool_input_schema(),}- if description := _custom_tool_description(source):+ if description := custom_tool_description(source):function["description"] = descriptionreturn {"type": "function", "function": function}, wire_name-def _custom_tool_description(source: Mapping[str, JsonValue]) -> str | None:- parts: list[str] = []- if description := optional_str(source.get("description")):- parts.append(description)- format_value = source.get("format")- if isinstance(format_value, Mapping):- format_type = optional_str(format_value.get("type"))- if format_type == "text":- parts.append("Custom tool input format: unconstrained text.")- elif format_type == "grammar":- syntax = optional_str(format_value.get("syntax"))- definition = optional_str(format_value.get("definition"))- guidance = "Custom tool input format: grammar"- if syntax:- guidance = f"{guidance} ({syntax})"- guidance = f"{guidance}: {definition}" if definition else f"{guidance}."- parts.append(guidance)- return "\n\n".join(parts) if parts else None--def _chat_tool_choice(value: JsonValue, available_names: frozenset[str]) -> object | None:@@ -684,7 +657,7 @@ def _chat_tool_choice(namespace = optional_str(choice.get("namespace")) or optional_str(value.get("namespace"))- wire_name = responses_tool_name_to_anthropic_name(name, namespace=namespace)+ wire_name = flatten_responses_tool_name(name, namespace=namespace)if wire_name not in available_names:return Nonereturn {"type": "function", "function": {"name": wire_name}}diff --git a/src/free_claude_code/core/openai_responses/messages_request.py b/src/free_claude_code/core/openai_responses/messages_request.pyindex 1aa7eaaf..6c57b75b 100644--- a/src/free_claude_code/core/openai_responses/messages_request.py+++ b/src/free_claude_code/core/openai_responses/messages_request.py@@ -23,7 +23,11 @@ from free_claude_code.core.openai_tool_names import OpenAIToolNameCodecfrom .errors import ResponsesConversionErrorfrom .models import OpenAIResponsesRequestfrom .reasoning_replay import decode_messages_reasoning-from .tools import ResponsesToolIdentity, responses_tool_name_to_anthropic_name+from .tools import (+ ResponsesToolIdentity,+ custom_tool_input_schema,+ flatten_responses_tool_name,+)_REQUEST_FIELDS = {"model",@@ -167,9 +171,7 @@ class _ToolScope:self.tools.append(body)def _register(self, identity: ResponsesToolIdentity) -> None:- name = responses_tool_name_to_anthropic_name(- identity.name, namespace=identity.namespace- )+ name = flatten_responses_tool_name(identity.name, namespace=identity.namespace)previous = self._flat.get(name)if previous is not None and previous != identity:raise ResponsesConversionError(@@ -213,9 +215,7 @@ class _ToolScope:)_fields(format_value, {"type"}, "Custom tool format")body["input_schema"] = {- "type": "object",- "properties": {"input": {"type": "string"}},- "required": ["input"],+ **custom_tool_input_schema(description=None),"additionalProperties": False,}else:@@ -233,9 +233,7 @@ class _ToolScope:return identity, bodydef alias(self, identity: ResponsesToolIdentity) -> str:- name = responses_tool_name_to_anthropic_name(- identity.name, namespace=identity.namespace- )+ name = flatten_responses_tool_name(identity.name, namespace=identity.namespace)if self._flat.get(name) != identity:raise ResponsesConversionError("Unknown tool identity.")return self._codec.encode(name)diff --git a/src/free_claude_code/core/openai_responses/tool_adaptation.py b/src/free_claude_code/core/openai_responses/tool_adaptation.pynew file mode 100644index 00000000..f4b98927--- /dev/null+++ b/src/free_claude_code/core/openai_responses/tool_adaptation.py@@ -0,0 +1,378 @@+"""Provider-selected adaptations of native Responses tool representations."""++import json+from collections.abc import Iterable, Mapping+from copy import deepcopy+from dataclasses import dataclass+from typing import cast++from free_claude_code.core.json_types import JsonObject, JsonValue++from .errors import ResponsesConversionError+from .models import OpenAIResponsesRequest+from .tool_search import normalize_tool_search+from .tools import (+ ResponsesToolIdentity,+ custom_tool_description,+ custom_tool_input_schema,+ custom_tool_input_text,+ custom_tool_input_text_from_arguments,+ flatten_responses_tool_name,+ optional_str,+ required_str,+)+++@dataclass(frozen=True, slots=True)+class ResponsesToolPolicy:+ custom_tools_as_functions: bool = False+ explicit_search_parameters: bool = False+ text_only_web_search: bool = False+++@dataclass(frozen=True, slots=True)+class _DefinitionEdit:+ original: JsonObject+ adapted: JsonObject+ namespace: str | None+ scope: str | None+++class ResponsesToolAdapter:+ """Prepare one request and retain only the information needed to undo edits."""++ def __init__(+ self, request: OpenAIResponsesRequest, policy: ResponsesToolPolicy+ ) -> None:+ self.request = request.model_copy(deep=True)+ self._policy = policy+ self._identities: dict[tuple[str | None, str], ResponsesToolIdentity] = {}+ self._edits: list[_DefinitionEdit] = []+ if policy == ResponsesToolPolicy():+ return+ if self.request.tools:+ self.request.tools = cast(list[JsonObject], self._tools(self.request.tools))+ if isinstance(self.request.input, list):+ self.request.input = [self._input(item) for item in self.request.input]+ if policy.custom_tools_as_functions:+ self.request.tool_choice = self._choice(self.request.tool_choice)++ def _register(self, identity: ResponsesToolIdentity, wire_name: str) -> None:+ key = (identity.namespace, wire_name)+ existing = self._identities.get(key)+ if existing is not None and existing != identity:+ raise ResponsesConversionError("Tool names collide after conversion.")+ self._identities[key] = identity++ def _tools(+ self, tools: JsonValue, namespace: str | None = None, scope: str | None = None+ ) -> JsonValue:+ if not isinstance(tools, list):+ return tools+ return [self._tool(tool, namespace, scope) for tool in tools]++ def _tool(+ self, value: JsonValue, namespace: str | None, scope: str | None+ ) -> JsonValue:+ if not isinstance(value, dict):+ return value+ tool = value+ kind = tool.get("type")+ if kind == "namespace":+ return {+ **tool,+ "tools": self._tools(tool.get("tools"), _name(tool), scope),+ }+ if self._policy.custom_tools_as_functions and kind in {"custom", "function"}:+ nested = tool.get(str(kind))+ source = nested if isinstance(nested, dict) else tool+ name = _name(source)+ identity = ResponsesToolIdentity(+ kind="custom" if kind == "custom" else "function",+ name=name,+ namespace=namespace or _namespace(source),+ )+ wire_name = (+ flatten_responses_tool_name(name, namespace=identity.namespace)+ if kind == "custom"+ else name+ )+ self._register(identity, wire_name)+ if kind == "custom":+ tool = {+ **{key: child for key, child in tool.items() if key != "custom"},+ **source,+ "type": "function",+ "name": wire_name,+ "parameters": custom_tool_input_schema(),+ "strict": False,+ }+ tool.pop("format", None)+ if description := custom_tool_description(source):+ tool["description"] = description+ if self._policy.explicit_search_parameters:+ tool = normalize_tool_search(tool)+ if self._policy.text_only_web_search and kind in {+ "web_search",+ "web_search_preview",+ }:+ content_types = tool.get("search_content_types")+ if content_types is not None:+ if not isinstance(content_types, list) or "text" not in content_types:+ raise ResponsesConversionError(+ "The selected provider supports text web search only."+ )+ tool = {+ key: child+ for key, child in tool.items()+ if key != "search_content_types"+ }+ if tool != value:+ self._edits.append(_DefinitionEdit(value, tool, namespace, scope))+ return tool++ def _input(self, item: JsonValue) -> JsonValue:+ if not isinstance(item, dict):+ return item+ kind = item.get("type")+ if kind == "tool_search_output":+ return {**item, "tools": self._tools(item.get("tools"), scope=_scope(item))}+ if not self._policy.custom_tools_as_functions:+ return item+ if kind in {"custom_tool_call", "function_call"}:+ name = _name(item)+ identity = ResponsesToolIdentity(+ kind="custom" if kind == "custom_tool_call" else "function",+ name=name,+ namespace=_namespace(item),+ )+ wire_name = (+ flatten_responses_tool_name(name, namespace=identity.namespace)+ if kind == "custom_tool_call"+ else name+ )+ self._register(identity, wire_name)+ if kind == "custom_tool_call":+ return {+ **{key: value for key, value in item.items() if key != "input"},+ "type": "function_call",+ "name": wire_name,+ "arguments": json.dumps(+ {"input": custom_tool_input_text(item.get("input"))},+ ensure_ascii=False,+ ),+ }+ if kind == "custom_tool_call_output":+ return {**item, "type": "function_call_output"}+ return item++ def _choice(self, choice: JsonValue) -> JsonValue:+ if not isinstance(choice, dict):+ return choice+ if choice.get("type") == "custom":+ return {+ **choice,+ "type": "function",+ "name": flatten_responses_tool_name(+ _name(choice), namespace=_namespace(choice)+ ),+ }+ children = choice.get("tools")+ if isinstance(children, list):+ return {**choice, "tools": [self._choice(tool) for tool in children]}+ return choice++ def _custom(self, item: Mapping[str, JsonValue]) -> ResponsesToolIdentity | None:+ name = item.get("name")+ if not isinstance(name, str):+ return None+ namespace = _namespace(item)+ if namespace is not None:+ identity = self._identities.get((namespace, name))+ else:+ candidates = {+ identity+ for (_, wire_name), identity in self._identities.items()+ if wire_name == name+ }+ identity = next(iter(candidates)) if len(candidates) == 1 else None+ return identity if identity is not None and identity.kind == "custom" else None++ def restore_item(self, value: JsonValue) -> JsonValue:+ if not isinstance(value, dict):+ return value+ if value.get("type") == "tool_search_output":+ return {+ **value,+ "tools": self.restore_tools(value.get("tools"), scope=_scope(value)),+ }+ if (+ value.get("type") != "function_call"+ or (identity := self._custom(value)) is None+ ):+ return value+ arguments = value.get("arguments")+ item: JsonObject = {+ **{key: child for key, child in value.items() if key != "arguments"},+ "type": "custom_tool_call",+ "name": identity.name,+ "input": custom_tool_input_text_from_arguments(arguments)+ if isinstance(arguments, str)+ else "",+ }+ if identity.namespace is not None:+ item["namespace"] = identity.namespace+ return item++ def restore_tools(+ self, tools: JsonValue, namespace: str | None = None, scope: str | None = None+ ) -> JsonValue:+ if not isinstance(tools, list):+ return tools+ result: list[JsonValue] = []+ for tool in tools:+ if isinstance(tool, dict):+ if tool.get("type") == "namespace":+ tool = {+ **tool,+ "tools": self.restore_tools(+ tool.get("tools"), _name(tool), scope+ ),+ }+ else:+ edits = [+ edit+ for edit in self._edits+ if edit.namespace == namespace+ and edit.adapted.get("type") == tool.get("type")+ and edit.adapted.get("name") == tool.get("name")+ ]+ scoped = [edit for edit in edits if edit.scope == scope]+ if scoped:+ edits = scoped+ if edits:+ incoming = tool+ edit = max(+ edits,+ key=lambda edit: sum(+ key in incoming and incoming[key] == value+ for key, value in edit.adapted.items()+ ),+ )+ tool = dict(tool)+ for key in edit.original.keys() | edit.adapted.keys():+ if (key in edit.original) != (+ key in edit.adapted+ ) or edit.original.get(key) != edit.adapted.get(key):+ if key in edit.original:+ tool[key] = deepcopy(edit.original[key])+ else:+ tool.pop(key, None)+ result.append(tool)+ return result++ def restore_choice(self, value: JsonValue) -> JsonValue:+ if not isinstance(value, dict):+ return value+ if (+ value.get("type") == "function"+ and (identity := self._custom(value)) is not None+ ):+ value = {**value, "type": "custom", "name": identity.name}+ if identity.namespace is not None:+ value["namespace"] = identity.namespace+ children = value.get("tools")+ if isinstance(children, list):+ value = {+ **value,+ "tools": [self.restore_choice(tool) for tool in children],+ }+ return value++ def event_adapter(self) -> ResponsesToolEventAdapter | None:+ if self._edits or any(+ identity.kind == "custom" for identity in self._identities.values()+ ):+ return ResponsesToolEventAdapter(self)+ return None+++class ResponsesToolEventAdapter:+ """Undo one request's tool edits with fresh event state for each attempt."""++ def __init__(self, tools: ResponsesToolAdapter) -> None:+ self._tools = tools+ self._custom_items: set[str] = set()+ self._sequence = 0++ def feed(+ self, event_type: str, payload: JsonObject+ ) -> Iterable[tuple[str, JsonObject]]:+ data = deepcopy(payload)+ sequence = data.get("sequence_number")+ if isinstance(sequence, int) and not isinstance(sequence, bool):+ self._sequence = max(self._sequence, sequence)+ original_item = data.get("item")+ item = self._tools.restore_item(original_item)+ if isinstance(item, dict):+ data["item"] = item+ if (+ isinstance(original_item, dict)+ and original_item.get("type") == "function_call"+ and item.get("type") == "custom_tool_call"+ ):+ if isinstance(item_id := item.get("id"), str):+ self._custom_items.add(item_id)+ if event_type == "response.output_item.done":+ coordinates = {+ "item_id": item.get("id"),+ "output_index": data.get("output_index"),+ }+ if item["input"]:+ yield self._emit(+ "response.custom_tool_call_input.delta",+ {**coordinates, "delta": item["input"]},+ )+ yield self._emit(+ "response.custom_tool_call_input.done",+ {**coordinates, "input": item["input"]},+ )+ if (+ event_type+ in {+ "response.function_call_arguments.delta",+ "response.function_call_arguments.done",+ }+ and data.get("item_id") in self._custom_items+ ):+ return+ response = data.get("response")+ if isinstance(response, dict):+ if isinstance(output := response.get("output"), list):+ response["output"] = [+ self._tools.restore_item(value) for value in output+ ]+ if "tools" in response:+ response["tools"] = self._tools.restore_tools(response["tools"])+ if "tool_choice" in response:+ response["tool_choice"] = self._tools.restore_choice(+ response["tool_choice"]+ )+ yield self._emit(event_type, data)++ def _emit(self, event_type: str, payload: JsonObject) -> tuple[str, JsonObject]:+ payload = {**payload, "type": event_type, "sequence_number": self._sequence}+ self._sequence += 1+ return event_type, payload+++def _name(value: Mapping[str, JsonValue]) -> str:+ return required_str(value.get("name"), "tool.name")+++def _namespace(value: Mapping[str, JsonValue]) -> str | None:+ return optional_str(value.get("namespace"))+++def _scope(value: Mapping[str, JsonValue]) -> str | None:+ return optional_str(value.get("call_id")) or optional_str(value.get("id"))diff --git a/src/free_claude_code/core/openai_responses/tool_search.py b/src/free_claude_code/core/openai_responses/tool_search.pynew file mode 100644index 00000000..16e5d50b--- /dev/null+++ b/src/free_claude_code/core/openai_responses/tool_search.py@@ -0,0 +1,47 @@+"""Explicit argument schemas for providers requiring every search property."""++from collections.abc import Mapping++from free_claude_code.core.json_types import JsonObject, JsonValue+++def normalize_tool_search(tool: JsonObject) -> JsonObject:+ """Represent omitted search arguments as null without changing function tools."""+ if tool.get("type") != "tool_search" or tool.get("execution") != "client":+ return tool+ parameters = tool.get("parameters")+ if not isinstance(parameters, Mapping):+ return tool+ return {**tool, "parameters": _explicit_arguments(parameters)}+++def _explicit_arguments(schema: JsonValue) -> JsonValue:+ if not isinstance(schema, Mapping):+ return schema+ result = dict(schema)+ for keyword in ("properties", "$defs", "definitions"):+ children = schema.get(keyword)+ if isinstance(children, Mapping):+ result[keyword] = {+ name: _explicit_arguments(child) for name, child in children.items()+ }+ for keyword in ("items", "additionalProperties"):+ if keyword in schema:+ result[keyword] = _explicit_arguments(schema[keyword])+ for keyword in ("anyOf", "oneOf", "allOf", "prefixItems"):+ children = schema.get(keyword)+ if isinstance(children, list):+ result[keyword] = [_explicit_arguments(child) for child in children]+ properties = result.get("properties")+ if isinstance(properties, Mapping):+ required = schema.get("required")+ names = required if isinstance(required, list) else []+ result["properties"] = {+ name: child if name in names else {"anyOf": [child, {"type": "null"}]}+ for name, child in properties.items()+ }+ result["required"] = [+ *names,+ *(name for name in properties if name not in names),+ ]+ return resultdiff --git a/src/free_claude_code/core/openai_responses/tools.py b/src/free_claude_code/core/openai_responses/tools.pyindex 259e75e7..cb8eaee5 100644--- a/src/free_claude_code/core/openai_responses/tools.py+++ b/src/free_claude_code/core/openai_responses/tools.py@@ -7,14 +7,13 @@ from collections.abc import Mappingfrom dataclasses import dataclassfrom typing import Any, Literal+from free_claude_code.core.json_types import JsonObject+from .errors import ResponsesConversionErrorfrom .ids import new_call_id-_MAX_ANTHROPIC_TOOL_NAME_LEN = 64+_MAX_TOOL_NAME_LEN = 64_NAMESPACE_TOOL_SEPARATOR = "__"-_UNSUPPORTED_PASSIVE_TOOL_TYPES = frozenset(- {"web_search", "image_generation", "tool_search"}-)_INVALID_TOOL_NAME_CHARS = re.compile(r"[^A-Za-z0-9_-]+")@@ -25,87 +24,8 @@ class ResponsesToolIdentity:namespace: str | None = None-def convert_tools(value: Any) -> list[dict[str, Any]] | None:- if value is None:- return None- if not isinstance(value, list):- raise ResponsesConversionError("Responses tools must be a list")-- tools: list[dict[str, Any]] = []- for tool in value:- if not isinstance(tool, dict):- raise ResponsesConversionError(- f"Unsupported Responses tool: {type(tool).__name__}"- )- tool_type = tool.get("type")- if tool_type == "function":- tools.append(_convert_function_tool(tool, namespace=None))- continue- if tool_type == "custom":- tools.append(_convert_custom_tool(tool, namespace=None))- continue- if tool_type == "namespace":- tools.extend(_convert_namespace_tool(tool))- continue- if tool_type in _UNSUPPORTED_PASSIVE_TOOL_TYPES:- continue- if tool_type != "function":- raise ResponsesConversionError(- f"Unsupported Responses tool type: {tool_type!r}"- )- return tools---def convert_tool_choice(value: Any) -> dict[str, Any] | None:- if value is None or value == "auto":- return None- if value == "none":- return None- if value == "required":- return {"type": "any"}- if isinstance(value, dict):- choice_type = value.get("type")- if choice_type == "function":- namespace = optional_str(value.get("namespace"))- name = required_str(value.get("name"), "tool_choice.name")- return {- "type": "tool",- "name": responses_tool_name_to_anthropic_name(- name, namespace=namespace- ),- }- if choice_type == "custom":- source = _custom_source(value)- namespace = optional_str(source.get("namespace")) or optional_str(- value.get("namespace")- )- name = required_str(source.get("name"), "tool_choice.name")- return {- "type": "tool",- "name": responses_tool_name_to_anthropic_name(- name, namespace=namespace- ),- }- if choice_type == "tool":- namespace = optional_str(value.get("namespace"))- name = optional_str(value.get("name"))- if name:- return {- "type": "tool",- "name": responses_tool_name_to_anthropic_name(- name, namespace=namespace- ),- }- return dict(value)- if choice_type in {"auto", "any"}:- return dict(value)- raise ResponsesConversionError(f"Unsupported Responses tool_choice: {value!r}")---def responses_tool_name_to_anthropic_name(- name: str, *, namespace: str | None = None-) -> str:- """Return a deterministic Anthropic tool name for a Responses tool identity."""+def flatten_responses_tool_name(name: str, *, namespace: str | None = None) -> str:+ """Return a deterministic flat tool name for a Responses tool identity."""if not namespace:return name@@ -114,20 +34,20 @@ def responses_tool_name_to_anthropic_name(f"{_NAMESPACE_TOOL_SEPARATOR}"f"{_tool_name_part(name)}")- if len(combined) <= _MAX_ANTHROPIC_TOOL_NAME_LEN:+ if len(combined) <= _MAX_TOOL_NAME_LEN:return combineddigest = hashlib.sha1(combined.encode("utf-8")).hexdigest()[:8]- prefix_len = _MAX_ANTHROPIC_TOOL_NAME_LEN - len(digest) - 1+ prefix_len = _MAX_TOOL_NAME_LEN - len(digest) - 1return f"{combined[:prefix_len]}_{digest}"-def responses_tool_identity_from_anthropic_name(- tools: list[dict[str, Any]] | None, anthropic_name: str+def responses_tool_identity_from_wire_name(+ tools: list[dict[str, Any]] | None, wire_name: str) -> ResponsesToolIdentity:- """Return the Responses namespace/name represented by an Anthropic tool name."""+ """Return the Responses namespace/name represented by a flat tool name."""if tools is None:- return ResponsesToolIdentity(kind="function", name=anthropic_name)+ return ResponsesToolIdentity(kind="function", name=wire_name)for tool in tools:if not isinstance(tool, dict):continue@@ -136,14 +56,14 @@ def responses_tool_identity_from_anthropic_name(source = tool.get("function")function = source if isinstance(source, dict) else toolif (name := optional_str(function.get("name"))) and (- responses_tool_name_to_anthropic_name(name) == anthropic_name+ flatten_responses_tool_name(name) == wire_name):return ResponsesToolIdentity(kind="function", name=name)continueif tool_type == "custom":- source = _custom_source(tool)+ source = custom_tool_source(tool)if (name := optional_str(source.get("name"))) and (- responses_tool_name_to_anthropic_name(name) == anthropic_name+ flatten_responses_tool_name(name) == wire_name):return ResponsesToolIdentity(kind="custom", name=name)continue@@ -161,23 +81,21 @@ def responses_tool_identity_from_anthropic_name(source = nested_tool.get("function")function = source if isinstance(source, dict) else nested_toolif (name := optional_str(function.get("name"))) and (- responses_tool_name_to_anthropic_name(name, namespace=namespace)- == anthropic_name+ flatten_responses_tool_name(name, namespace=namespace) == wire_name):return ResponsesToolIdentity(kind="function", name=name, namespace=namespace)continueif nested_tool_type == "custom":- source = _custom_source(nested_tool)+ source = custom_tool_source(nested_tool)if (name := optional_str(source.get("name"))) and (- responses_tool_name_to_anthropic_name(name, namespace=namespace)- == anthropic_name+ flatten_responses_tool_name(name, namespace=namespace) == wire_name):return ResponsesToolIdentity(kind="custom", name=name, namespace=namespace)- return ResponsesToolIdentity(kind="function", name=anthropic_name)+ return ResponsesToolIdentity(kind="function", name=wire_name)def parse_arguments(value: Any) -> dict[str, Any]:@@ -204,10 +122,6 @@ def normalized_function_call_arguments(value: Any) -> str:return json.dumps(parse_arguments(value), separators=(",", ":"))-def custom_tool_input_to_anthropic(value: Any) -> dict[str, str]:- return {"input": custom_tool_input_text(value)}--def custom_tool_input_text(value: Any) -> str:if value is None:return ""@@ -216,7 +130,7 @@ def custom_tool_input_text(value: Any) -> str:return _json_dumps(value)-def custom_tool_input_text_from_anthropic(value: Any) -> str:+def custom_tool_input_text_from_wrapper(value: Any) -> str:if isinstance(value, Mapping):raw_input = value.get("input")if isinstance(raw_input, str):@@ -236,7 +150,7 @@ def custom_tool_input_text_from_arguments(arguments: str) -> str:parsed = json.loads(arguments)except json.JSONDecodeError:return arguments- return custom_tool_input_text_from_anthropic(parsed)+ return custom_tool_input_text_from_wrapper(parsed)def call_id_from_item(item: Mapping[str, Any]) -> str:@@ -258,88 +172,12 @@ def optional_str(value: Any) -> str | None:return value if isinstance(value, str) else None-def _convert_namespace_tool(tool: Mapping[str, Any]) -> list[dict[str, Any]]:- namespace = required_str(tool.get("name"), "tool.namespace.name")- nested_tools = tool.get("tools")- if not isinstance(nested_tools, list):- raise ResponsesConversionError(- f"Responses namespace tool {namespace!r} tools must be a list"- )-- converted_tools: list[dict[str, Any]] = []- for nested_tool in nested_tools:- if not isinstance(nested_tool, dict):- raise ResponsesConversionError(- f"Unsupported Responses namespace tool: {type(nested_tool).__name__}"- )- nested_tool_type = nested_tool.get("type")- if nested_tool_type == "function":- converted_tools.append(- _convert_function_tool(nested_tool, namespace=namespace)- )- continue- if nested_tool_type == "custom":- converted_tools.append(- _convert_custom_tool(nested_tool, namespace=namespace)- )- continue- raise ResponsesConversionError(- f"Unsupported Responses namespace tool type: {nested_tool_type!r}"- )- return converted_tools---def _convert_function_tool(- tool: Mapping[str, Any], *, namespace: str | None-) -> dict[str, Any]:- function = tool.get("function")- source = function if isinstance(function, dict) else tool- name = required_str(source.get("name"), "tool.name")- schema = source.get("parameters")- if schema is None:- schema = {"type": "object", "properties": {}}- if not isinstance(schema, dict):- raise ResponsesConversionError(- f"Responses tool {name!r} parameters must be an object"- )- converted: dict[str, Any] = {- "name": responses_tool_name_to_anthropic_name(name, namespace=namespace),- "input_schema": schema,- }- if description := optional_str(source.get("description")):- converted["description"] = description- return converted---def _convert_custom_tool(- tool: Mapping[str, Any], *, namespace: str | None-) -> dict[str, Any]:- source = _custom_source(tool)- name = required_str(source.get("name"), "tool.name")- converted: dict[str, Any] = {- "name": responses_tool_name_to_anthropic_name(name, namespace=namespace),- "input_schema": {- "type": "object",- "properties": {- "input": {- "type": "string",- "description": "Free-form input for the custom tool.",- }- },- "required": ["input"],- },- }- if description := _custom_tool_description(source):- converted["description"] = description- return converted---def _custom_source(tool: Mapping[str, Any]) -> Mapping[str, Any]:+def custom_tool_source(tool: Mapping[str, Any]) -> Mapping[str, Any]:custom = tool.get("custom")return custom if isinstance(custom, Mapping) else tool-def _custom_tool_description(source: Mapping[str, Any]) -> str | None:+def custom_tool_description(source: Mapping[str, Any]) -> str | None:parts: list[str] = []if description := optional_str(source.get("description")):parts.append(description)@@ -373,3 +211,16 @@ def _json_dumps(value: Any) -> str:return json.dumps(value)except TypeError:return str(value)+++def custom_tool_input_schema(+ *, description: str | None = "Free-form input for the custom tool."+) -> JsonObject:+ input_property: JsonObject = {"type": "string"}+ if description is not None:+ input_property["description"] = description+ return {+ "type": "object",+ "properties": {"input": input_property},+ "required": ["input"],+ }diff --git a/src/free_claude_code/providers/openai_chat/stream_output.py b/src/free_claude_code/providers/openai_chat/stream_output.pyindex a574fe8b..288299e4 100644--- a/src/free_claude_code/providers/openai_chat/stream_output.py+++ b/src/free_claude_code/providers/openai_chat/stream_output.py@@ -33,7 +33,7 @@ from free_claude_code.core.openai_responses import (openai_error_from_failure,reasoning_output_item,replay_unsafe_function_call_error,- responses_tool_identity_from_anthropic_name,+ responses_tool_identity_from_wire_name,tool_item,)from free_claude_code.core.token_estimation import estimate_text_tokens@@ -608,7 +608,7 @@ class ResponsesChatStreamOutput(ChatStreamOutput):return self._completer.complete_block(state)def _start_tool_block(self, tool_index: int, state: ChatToolState) -> str:- identity = responses_tool_identity_from_anthropic_name(+ identity = responses_tool_identity_from_wire_name(self._request.tools, state.name)output_index = self._ledger.reserve_output_slot()diff --git a/src/free_claude_code/providers/openai_responses/presentation.py b/src/free_claude_code/providers/openai_responses/presentation.pyindex 7c469632..8322e2aa 100644--- a/src/free_claude_code/providers/openai_responses/presentation.py+++ b/src/free_claude_code/providers/openai_responses/presentation.py@@ -10,6 +10,7 @@ from free_claude_code.core.openai_responses import (NativeResponsesRelay,ResponsesProviderStream,ResponsesStreamFailure,+ ResponsesToolEventAdapter,)@@ -65,8 +66,11 @@ class MessagesResponsesPresenter:class NativeResponsesPresenter:"""Relay one Responses attempt as native Responses SSE."""- def __init__(self, *, public_model: str) -> None:+ def __init__(+ self, *, public_model: str, tool_events: ResponsesToolEventAdapter | None = None+ ) -> None:self._relay = NativeResponsesRelay(public_model=public_model)+ self._tool_events = tool_events@propertydef completed(self) -> bool:@@ -80,6 +84,11 @@ class NativeResponsesPresenter:return ()def feed(self, event_type: str, payload: JsonObject) -> Iterable[str]:+ if self._tool_events is not None:+ return tuple(+ self._relay.feed(kind, value)+ for kind, value in self._tool_events.feed(event_type, payload)+ )return (self._relay.feed(event_type, payload),)def terminal_failure(@@ -92,7 +101,7 @@ class NativeResponsesPresenter:and raw_error.event_type == "response.failed"and raw_error.payload is not None):- return (self._relay.feed(raw_error.event_type, raw_error.payload),)+ return self.feed(raw_error.event_type, raw_error.payload)return (self._relay.synthesize_failure(failure),)diff --git a/src/free_claude_code/providers/openai_responses/transport.py b/src/free_claude_code/providers/openai_responses/transport.pyindex 4683bb11..9b4e000f 100644--- a/src/free_claude_code/providers/openai_responses/transport.py+++ b/src/free_claude_code/providers/openai_responses/transport.py@@ -21,6 +21,8 @@ from free_claude_code.core.openai_responses import (ResponsesConversionError,ResponsesProviderStream,ResponsesStreamFailure,+ ResponsesToolAdapter,+ ResponsesToolPolicy,build_native_responses_request,build_responses_provider_request,responses_stream_failure_from_event,@@ -93,11 +95,13 @@ class OpenAIResponsesTransport:endpoint_transport: httpx2.AsyncBaseTransport | None = None,event_adapter_factory: Callable[[], ResponsesEventAdapter] | None = None,omitted_request_fields: frozenset[str] = frozenset(),+ tool_policy: ResponsesToolPolicy = ResponsesToolPolicy(),) -> None:self._client = clientself._endpoint_transport = endpoint_transportself._event_adapter_factory = event_adapter_factoryself._omitted_request_fields = omitted_request_fields+ self._tool_policy = tool_policyself._admission = admissionself._provider_name = provider_nameself._read_timeout_s = read_timeout_s@@ -159,14 +163,14 @@ class OpenAIResponsesTransport:endpoint_context: EndpointContext | None = None,) -> AsyncIterator[str]:del input_tokens- body = self._build_native_body(request, reasoning=reasoning)+ body, tools = self._build_native_body(request, reasoning=reasoning)return self._run_stream(body,endpoint_context=endpoint_context,request_id=request_id,response_model=response_model,presenter_factory=lambda: NativeResponsesPresenter(- public_model=response_model+ public_model=response_model, tool_events=tools.event_adapter()),)@@ -194,18 +198,23 @@ class OpenAIResponsesTransport:request: OpenAIResponsesRequest,*,reasoning: ReasoningPolicy,- ) -> JsonObject:+ ) -> tuple[JsonObject, ResponsesToolAdapter]:if not request.model.strip():raise InvalidRequestError("Responses request model must not be empty.")if request.input is None or request.input == "" or request.input == []:raise InvalidRequestError("Responses request input must not be empty.")- return self._prepare_body(+ try:+ tools = ResponsesToolAdapter(request, self._tool_policy)+ except ResponsesConversionError as error:+ raise InvalidRequestError(str(error)) from error+ body = self._prepare_body(build_native_responses_request(- request,+ tools.request,model=request.model,reasoning=reasoning,))+ return body, toolsdef _prepare_body(self, body: JsonObject) -> JsonObject:for field in self._omitted_request_fields:diff --git a/src/free_claude_code/providers/opencode/provider.py b/src/free_claude_code/providers/opencode/provider.pyindex 0b39638f..ecdc2818 100644--- a/src/free_claude_code/providers/opencode/provider.py+++ b/src/free_claude_code/providers/opencode/provider.py@@ -10,7 +10,10 @@ from free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.core.anthropic import ReasoningReplayModefrom free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.openai_responses import OpenAIResponsesRequest+from free_claude_code.core.openai_responses import (+ OpenAIResponsesRequest,+ ResponsesToolPolicy,+)from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.base import ProviderConfig@@ -99,6 +102,11 @@ class OpenCodeProvider(OpenAIChatProvider):provider_name=profile.provider_name,read_timeout_s=config.http_read_timeout,log_raw_sse_events=config.log_raw_sse_events,+ tool_policy=ResponsesToolPolicy(+ custom_tools_as_functions=True,+ explicit_search_parameters=True,+ text_only_web_search=True,+ ),)async def cleanup(self) -> None:diff --git a/tests/core/openai_responses/test_tool_adaptation.py b/tests/core/openai_responses/test_tool_adaptation.pynew file mode 100644index 00000000..97a8c62c--- /dev/null+++ b/tests/core/openai_responses/test_tool_adaptation.py@@ -0,0 +1,523 @@+import pytest++from free_claude_code.core.anthropic import ReasoningReplayMode+from free_claude_code.core.anthropic.stream_contracts import parse_sse_text+from free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.json_types import JsonObject+from free_claude_code.core.openai_responses import (+ OpenAIResponsesRequest,+ ResponsesConversionError,+ ResponsesStreamFailure,+ ResponsesToolAdapter,+ ResponsesToolPolicy,+ build_responses_chat_request,+)+from free_claude_code.providers.openai_responses.presentation import (+ NativeResponsesPresenter,+)+++def _adapter(request: OpenAIResponsesRequest) -> ResponsesToolAdapter:+ return ResponsesToolAdapter(request, ResponsesToolPolicy(True, True, True))+++def _presenter(adapter: ResponsesToolAdapter) -> NativeResponsesPresenter:+ return NativeResponsesPresenter(+ public_model="example", tool_events=adapter.event_adapter()+ )+++def test_custom_tool_identity_and_history_preserve_namespaces() -> None:+ request = OpenAIResponsesRequest(+ model="example",+ input=[+ {+ "type": "custom_tool_call",+ "id": "custom",+ "call_id": "call_custom",+ "namespace": "editor",+ "name": "edit",+ "input": "patch",+ },+ {"type": "reasoning", "id": "reasoning", "encrypted_content": "opaque"},+ ],+ tools=[+ {"type": "custom", "name": "edit", "format": {"type": "text"}},+ {+ "type": "namespace",+ "name": "editor",+ "tools": [+ {"type": "custom", "name": "edit", "format": {"type": "text"}}+ ],+ },+ {+ "type": "namespace",+ "name": "ordinary",+ "tools": [+ {+ "type": "function",+ "name": "edit",+ "parameters": {"type": "object"},+ }+ ],+ },+ ],+ tool_choice={"type": "custom", "namespace": "editor", "name": "edit"},+ )+ original = request.model_dump()+ adapter = _adapter(request)+ wire = adapter.request.model_dump()+ nested = wire["tools"][1]["tools"][0]+ assert nested["type"] == "function"+ assert wire["input"][0]["name"] == nested["name"]+ assert wire["tool_choice"] == {+ "type": "function",+ "namespace": "editor",+ "name": nested["name"],+ }+ assert wire["input"][1] == original["input"][1]++ output = [+ {+ "type": "function_call",+ "name": nested["name"],+ "namespace": "editor",+ "call_id": "one",+ "arguments": '{"input":"patch"}',+ },+ {+ "type": "function_call",+ "name": "edit",+ "namespace": "ordinary",+ "call_id": "two",+ "arguments": "{}",+ },+ ]+ event: JsonObject = {+ "type": "response.completed",+ "sequence_number": 10,+ "response": {+ "id": "resp_one",+ "model": "example",+ "status": "completed",+ "output": output,+ "tools": wire["tools"],+ },+ }+ stream = "".join(_presenter(adapter).feed("response.completed", event))+ restored = parse_sse_text(stream)[0].data["response"]+ assert restored["output"][0]["type"] == "custom_tool_call"+ assert restored["output"][0]["name"] == "edit"+ assert restored["output"][0]["namespace"] == "editor"+ assert restored["output"][0]["input"] == "patch"+ assert restored["output"][1] == output[1]+ assert restored["tools"] == original["tools"]+ assert request.model_dump() == original+++def test_image_only_web_search_is_not_silently_replaced_with_text_search() -> None:+ request = OpenAIResponsesRequest(+ model="example",+ input="hello",+ tools=[{"type": "web_search", "search_content_types": ["image"]}],+ )+ with pytest.raises(ResponsesConversionError, match="text web search only"):+ _adapter(request)+++def test_custom_and_function_names_cannot_collide_after_conversion() -> None:+ request = OpenAIResponsesRequest(+ model="example",+ input="hello",+ tools=[+ {"type": "custom", "name": "edit"},+ {"type": "function", "name": "edit", "parameters": {"type": "object"}},+ ],+ )+ with pytest.raises(ResponsesConversionError, match="names collide"):+ _adapter(request)+++ "field,value", [("defer_loading", True), ("allowed_callers", ["programmatic"])]+)+def test_custom_conversion_preserves_tool_settings(field: str, value: object) -> None:+ request = OpenAIResponsesRequest.model_validate(+ {+ "model": "example",+ "input": "hello",+ "tools": [+ {+ "type": "custom",+ "name": "edit",+ "format": {"type": "text"},+ field: value,+ }+ ],+ }+ )+ converted = _adapter(request).request.model_dump()["tools"][0]+ assert converted[field] == value+++def test_client_discovery_converts_customs_and_preserves_each_definition() -> None:+ first = {+ "type": "namespace",+ "name": "editor",+ "description": "Original group",+ "tools": [+ {+ "type": "custom",+ "name": "edit",+ "description": "First definition",+ "defer_loading": True,+ }+ ],+ }+ second = {+ **first,+ "tools": [+ {+ **first["tools"][0],+ "description": "Current definition",+ "defer_loading": False,+ }+ ],+ }+ request = OpenAIResponsesRequest.model_validate(+ {+ "model": "example",+ "tools": [second],+ "input": [+ {+ "type": "tool_search_output",+ "call_id": "search_one",+ "execution": "client",+ "status": "completed",+ "tools": [first],+ },+ {+ "type": "tool_search_output",+ "call_id": "search_two",+ "execution": "client",+ "status": "completed",+ "tools": [second],+ },+ ],+ }+ )+ original = request.model_dump()+ adapter = _adapter(request)+ wire = adapter.request.model_dump()+ assert wire["input"][0]["tools"][0]["tools"][0]["type"] == "function"+ assert wire["input"][1]["tools"][0]["tools"][0]["type"] == "function"+ assert wire["input"][0]["tools"][0]["description"] == "Original group"+ event: JsonObject = {+ "type": "response.completed",+ "response": {+ "id": "response",+ "status": "completed",+ "model": "example",+ "output": wire["input"],+ "tools": wire["tools"],+ },+ }+ stream = "".join(_presenter(adapter).feed("response.completed", event))+ restored = parse_sse_text(stream)[0].data["response"]+ assert restored["output"] == original["input"]+ assert restored["tools"] == original["tools"]+ assert request.model_dump() == original+++def test_flattened_custom_call_without_namespace_is_restored() -> None:+ request = OpenAIResponsesRequest(+ model="example",+ input="hello",+ tools=[+ {+ "type": "namespace",+ "name": "editor",+ "tools": [{"type": "custom", "name": "edit"}],+ }+ ],+ )+ adapter = _adapter(request)+ wire = adapter.request.model_dump()+ event: JsonObject = {+ "type": "response.completed",+ "response": {+ "id": "response",+ "status": "completed",+ "model": "example",+ "output": [+ {+ "type": "function_call",+ "id": "item_one",+ "call_id": "call_one",+ "name": wire["tools"][0]["tools"][0]["name"],+ "arguments": '{"input":"patch"}',+ }+ ],+ },+ }+ stream = "".join(_presenter(adapter).feed("response.completed", event))+ item = parse_sse_text(stream)[0].data["response"]["output"][0]+ assert item == {+ "type": "custom_tool_call",+ "id": "item_one",+ "call_id": "call_one",+ "name": "edit",+ "namespace": "editor",+ "input": "patch",+ }+++ "namespace,expected",+ [+ (None, "function_call"),+ ("other", "function_call"),+ ("editor", "custom_tool_call"),+ ],+)+def test_omitted_namespace_cannot_misidentify_an_ordinary_function(+ namespace: str | None, expected: str+) -> None:+ request = OpenAIResponsesRequest(+ model="example",+ input="hello",+ tools=[+ {+ "type": "namespace",+ "name": "editor",+ "tools": [{"type": "custom", "name": "edit"}],+ },+ {+ "type": "function",+ "name": "editor__edit",+ "parameters": {"type": "object"},+ },+ ],+ )+ adapter = _adapter(request)+ call: JsonObject = {+ "type": "function_call",+ "name": "editor__edit",+ "call_id": "one",+ "arguments": '{"input":"value"}',+ }+ if namespace is not None:+ call["namespace"] = namespace+ restored = adapter.restore_item(call)+ assert isinstance(restored, dict)+ assert restored["type"] == expected+ if expected == "function_call":+ assert restored == call+++def test_default_policy_preserves_native_tools_and_history() -> None:+ request = OpenAIResponsesRequest(+ model="example",+ tools=[+ {+ "type": "custom",+ "name": "edit",+ "defer_loading": True,+ "extra": {"x": 1},+ },+ {"type": "web_search", "search_content_types": ["image"]},+ ],+ input=[+ {+ "type": "custom_tool_call",+ "call_id": "one",+ "name": "edit",+ "input": "patch",+ }+ ],+ )+ adapter = ResponsesToolAdapter(request, ResponsesToolPolicy())+ assert adapter.request == request+ assert adapter.request is not request+ assert adapter.event_adapter() is None+++def test_custom_conversion_keeps_unrelated_fields_and_restores_allowed_choices() -> (+ None+):+ tool: JsonObject = {+ "type": "custom",+ "name": "edit",+ "format": {"type": "text"},+ "defer_loading": False,+ "allowed_callers": ["direct"],+ "extension": {"a": [1, 2]},+ }+ choice: JsonObject = {+ "type": "allowed_tools",+ "mode": "required",+ "tools": [{"type": "custom", "name": "edit"}],+ }+ request = OpenAIResponsesRequest(+ model="example", input="hello", tools=[tool], tool_choice=choice+ )+ adapter = _adapter(request)+ wire = adapter.request.model_dump()+ for field in ("defer_loading", "allowed_callers", "extension"):+ assert wire["tools"][0][field] == tool[field]+ assert adapter.restore_choice(wire["tool_choice"]) == choice+ echoed = [{**wire["tools"][0], "provider_extension": "keep"}]+ assert adapter.restore_tools(echoed) == [{**tool, "provider_extension": "keep"}]+++def test_separate_attempts_do_not_share_custom_item_ids_or_sequences() -> None:+ adapter = _adapter(+ OpenAIResponsesRequest(+ model="example",+ input="hello",+ tools=[+ {"type": "custom", "name": "edit"},+ {+ "type": "function",+ "name": "lookup",+ "parameters": {"type": "object"},+ },+ ],+ )+ )+ first, second = adapter.event_adapter(), adapter.event_adapter()+ assert first is not None and second is not None+ list(+ first.feed(+ "response.output_item.added",+ {+ "sequence_number": 100,+ "item": {+ "type": "function_call",+ "id": "reused",+ "name": "edit",+ "call_id": "first",+ "arguments": "",+ },+ },+ )+ )+ ordinary: JsonObject = {"sequence_number": 0, "item_id": "reused", "delta": "{}"}+ result = list(second.feed("response.function_call_arguments.delta", ordinary))+ assert result == [+ (+ "response.function_call_arguments.delta",+ {**ordinary, "type": "response.function_call_arguments.delta"},+ )+ ]+++def test_already_native_custom_calls_pass_through_without_extra_input_events() -> None:+ adapter = _adapter(+ OpenAIResponsesRequest(+ model="example", input="hello", tools=[{"type": "custom", "name": "edit"}]+ )+ ).event_adapter()+ assert adapter is not None+ item: JsonObject = {+ "type": "custom_tool_call",+ "id": "native",+ "call_id": "call_native",+ "name": "native_tool",+ "input": "text",+ "status": "completed",+ }+ done: JsonObject = {+ "type": "response.output_item.done",+ "sequence_number": 4,+ "output_index": 0,+ "item": item,+ }+ assert list(adapter.feed("response.output_item.done", done)) == [+ ("response.output_item.done", done)+ ]+++ "format_value,description",+ [+ ({"type": "text"}, "Custom tool input format: unconstrained text."),+ (+ {"type": "grammar", "syntax": "lark", "definition": "start: /.+/"},+ "Custom tool input format: grammar (lark): start: /.+/",+ ),+ ({"type": "future"}, "Custom tool input format: future."),+ ],+)+def test_chat_and_native_adaptation_share_custom_input_and_description(+ format_value: JsonObject, description: str+) -> None:+ request = OpenAIResponsesRequest(+ model="example",+ input="hello",+ tools=[{"type": "custom", "name": "edit", "format": format_value}],+ )+ native = _adapter(request).request.model_dump()["tools"][0]+ chat_tools = build_responses_chat_request(+ request, reasoning_replay=ReasoningReplayMode.DISABLED+ ).body["tools"]+ assert isinstance(chat_tools, list)+ chat = chat_tools[0]["function"]+ assert native["parameters"] == chat["parameters"]+ assert native["description"] == chat["description"] == description++[email protected]("upstream_failure", [False, True])+def test_adapted_presenter_preserves_terminal_failure_and_original_tool_metadata(+ upstream_failure: bool,+) -> None:+ tool: JsonObject = {+ "type": "custom",+ "name": "edit",+ "format": {"type": "text"},+ "defer_loading": True,+ }+ adapter = _adapter(+ OpenAIResponsesRequest(model="example", input="hello", tools=[tool])+ )+ presenter = _presenter(adapter)+ response: JsonObject = {+ "id": "resp_one",+ "model": "upstream",+ "status": "in_progress",+ "tools": adapter.request.model_dump()["tools"],+ "output": [],+ }+ list(+ presenter.feed(+ "response.created",+ {"type": "response.created", "sequence_number": 0, "response": response},+ )+ )+ list(+ presenter.feed(+ "response.output_text.delta", {"sequence_number": 1, "delta": "partial"}+ )+ )+ failure = ExecutionFailure(FailureKind.UPSTREAM, 502, "failed", False)+ raw: Exception = RuntimeError("stream ended")+ if upstream_failure:+ raw = ResponsesStreamFailure(+ "failed",+ event_type="response.failed",+ payload={+ "type": "response.failed",+ "sequence_number": 2,+ "response": {+ **response,+ "status": "failed",+ "error": {"message": "failed"},+ },+ },+ )+ events = parse_sse_text("".join(presenter.terminal_failure(raw, failure)))+ assert len(events) == 1 and events[0].event == "response.failed"+ assert events[0].data["sequence_number"] == 2+ assert events[0].data["response"]["tools"] == [tool]+ assert events[0].data["response"]["status"] == "failed"+ assert presenter.completeddiff --git a/tests/core/openai_responses/test_tool_search.py b/tests/core/openai_responses/test_tool_search.pynew file mode 100644index 00000000..d4329030--- /dev/null+++ b/tests/core/openai_responses/test_tool_search.py@@ -0,0 +1,83 @@+from copy import deepcopy++import pytest+from jsonschema import Draft202012Validator++from free_claude_code.core.json_types import JsonObject+from free_claude_code.core.openai_responses.tool_search import normalize_tool_search+++def test_nested_search_arguments_keep_constraints_and_literal_data() -> None:+ tool: JsonObject = {+ "type": "tool_search",+ "execution": "client",+ "parameters": {+ "type": "object",+ "properties": {+ "query": {"type": "string"},+ "filters": {+ "type": "array",+ "items": {"$ref": "#/$defs/filter"},+ },+ },+ "required": ["query"],+ "additionalProperties": False,+ "$defs": {+ "filter": {+ "type": "object",+ "properties": {+ "kind": {"enum": ["file", "directory"]},+ "count": {+ "anyOf": [+ {"type": "integer", "minimum": 1},+ {"type": "string", "enum": ["all"]},+ ]+ },+ },+ "required": ["kind"],+ "additionalProperties": False,+ }+ },+ "examples": [{"properties": {"literal": "untouched"}}],+ },+ }+ original = deepcopy(tool)+ normalized = normalize_tool_search(tool)+ schema = normalized["parameters"]+ assert isinstance(schema, dict)+ validator = Draft202012Validator(schema)+ assert validator.is_valid({"query": "files", "filters": None})+ assert validator.is_valid(+ {"query": "files", "filters": [{"kind": "file", "count": None}]}+ )+ assert validator.is_valid(+ {"query": "files", "filters": [{"kind": "file", "count": 2}]}+ )+ assert not validator.is_valid(+ {"query": "files", "filters": [{"kind": "file", "count": 0}]}+ )+ assert not validator.is_valid(+ {"query": "files", "filters": [{"kind": "unknown", "count": None}]}+ )+ assert not validator.is_valid({"query": "files", "filters": [{"kind": "file"}]})+ assert schema["examples"] == [{"properties": {"literal": "untouched"}}]+ assert normalize_tool_search(normalized) == normalized+ assert tool == original+++ "tool",+ [+ {"type": "tool_search"},+ {"type": "tool_search", "execution": "server"},+ {"type": "tool_search", "execution": "client"},+ {+ "type": "function",+ "name": "search",+ "strict": False,+ "parameters": {"type": "object", "properties": {"x": {"type": "string"}}},+ },+ ],+)+def test_other_tool_definitions_are_preserved(tool: JsonObject) -> None:+ assert normalize_tool_search(tool) == tooldiff --git a/tests/providers/test_openai_responses_transport.py b/tests/providers/test_openai_responses_transport.pyindex ad1ab3b5..62e3c876 100644--- a/tests/providers/test_openai_responses_transport.py+++ b/tests/providers/test_openai_responses_transport.py@@ -17,7 +17,10 @@ from free_claude_code.core.anthropic.stream_contracts import (thinking_content,)from free_claude_code.core.failures import ExecutionFailure, FailureKind-from free_claude_code.core.openai_responses import OpenAIResponsesRequest+from free_claude_code.core.openai_responses import (+ OpenAIResponsesRequest,+ ResponsesToolPolicy,+)from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.openai_responses import OpenAIResponsesTransportfrom tests.providers.support import REASONING_ON, immediate_admission@@ -117,7 +120,12 @@ def _client()-def _transport(client: AsyncOpenAI, *, max_attempts: int = 5):+def _transport(+ client: AsyncOpenAI,+ *,+ max_attempts: int = 5,+ tool_policy: ResponsesToolPolicy = ResponsesToolPolicy(),+):return OpenAIResponsesTransport(client=client,admission=immediate_admission(@@ -127,6 +135,7 @@ def _transport(client: AsyncOpenAI, *, max_attempts: int = 5):provider_name="TEST_RESPONSES",read_timeout_s=120.0,log_raw_sse_events=False,+ tool_policy=tool_policy,)@@ -164,6 +173,183 @@ async def _collect_native(]+async def test_default_transport_keeps_native_tool_capabilities() -> None:+ tools = [+ {+ "type": "custom",+ "name": "edit",+ "format": {"type": "text"},+ "defer_loading": True,+ "allowed_callers": ["direct"],+ },+ {"type": "web_search", "search_content_types": ["text", "image"]},+ ]+ history = [+ {"type": "custom_tool_call", "call_id": "c", "name": "edit", "input": "patch"}+ ]++ def handler(request: httpx2.Request) -> httpx2.Response:+ payload = json.loads(request.content)+ assert payload["tools"] == tools and payload["input"] == history+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text=_sse(_completed_event()),+ )++ client = _client(handler)+ try:+ await _collect_native(+ _transport(client),+ OpenAIResponsesRequest(model="example", tools=tools, input=history),+ )+ finally:+ await client.close()+++async def test_tool_adaptation_retries_start_with_fresh_event_state() -> None:+ attempts = 0++ def handler(request: httpx2.Request) -> httpx2.Response:+ nonlocal attempts+ attempts += 1+ wire = json.loads(request.content)+ assert wire["tools"][0]["type"] == "function"+ created = {+ "type": "response.created",+ "sequence_number": 100 if attempts == 1 else 0,+ "response": {**_completed_response(), "status": "in_progress"},+ }+ text = (+ _sse(created)+ if attempts == 1+ else _sse(+ created, _text_delta("hello", sequence=1), _completed_event(sequence=2)+ )+ )+ return httpx2.Response(+ 200, headers={"content-type": "text/event-stream"}, text=text+ )++ client = _client(handler)+ try:+ transport = _transport(+ client,+ max_attempts=2,+ tool_policy=ResponsesToolPolicy(custom_tools_as_functions=True),+ )+ chunks = await _collect_native(+ transport,+ OpenAIResponsesRequest(+ model="example",+ input="hello",+ tools=[{"type": "custom", "name": "edit"}],+ ),+ )+ finally:+ await client.close()+ events = parse_sse_text("".join(chunks))+ assert attempts == 2+ assert [event.data["sequence_number"] for event in events] == [0, 1, 2]+++async def test_concurrent_requests_do_not_share_tool_identities() -> None:+ started = 0+ both_started = asyncio.Event()++ class ResponseStream(httpx2.AsyncByteStream):+ def __init__(self, content: str) -> None:+ self.content = content++ async def __aiter__(self):+ await asyncio.wait_for(both_started.wait(), timeout=5)+ yield self.content.encode()++ def handler(request: httpx2.Request) -> httpx2.Response:+ nonlocal started+ started += 1+ if started == 2:+ both_started.set()+ body = json.loads(request.content)+ call = {+ "type": "function_call",+ "id": "same_item",+ "call_id": "same_call",+ "name": "edit",+ "arguments": '{"input":"patch"}',+ "status": "completed",+ }+ response = {+ **_completed_response(),+ "output": [call],+ "metadata": {"owner": body["input"]},+ }+ events = _sse(+ {+ "type": "response.output_item.added",+ "sequence_number": 0,+ "output_index": 0,+ "item": {**call, "arguments": "", "status": "in_progress"},+ },+ {+ "type": "response.function_call_arguments.delta",+ "sequence_number": 1,+ "item_id": "same_item",+ "output_index": 0,+ "delta": call["arguments"],+ },+ {+ "type": "response.output_item.done",+ "sequence_number": 2,+ "output_index": 0,+ "item": call,+ },+ {"type": "response.completed", "sequence_number": 3, "response": response},+ )+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ stream=ResponseStream(events),+ )++ client = _client(handler)+ transport = _transport(+ client, tool_policy=ResponsesToolPolicy(custom_tools_as_functions=True)+ )+ try:+ chunks = await asyncio.gather(+ *[+ _collect_native(+ transport,+ OpenAIResponsesRequest(+ model="example",+ input=kind,+ tools=[{"type": kind, "name": "edit"}],+ ),+ )+ for kind in ("custom", "function")+ ]+ )+ finally:+ await client.close()+ custom_events, function_events = [+ parse_sse_text("".join(output)) for output in chunks+ ]+ assert custom_events[-1].data["response"]["output"][0]["type"] == "custom_tool_call"+ assert function_events[-1].data["response"]["output"][0]["type"] == "function_call"+ assert not any(+ event.event == "response.function_call_arguments.delta"+ for event in custom_events+ )+ assert any(+ event.event == "response.function_call_arguments.delta"+ for event in function_events+ )++@pytest.mark.asyncioasync def test_native_responses_preserves_request_and_upstream_event_identity() -> None:captured: list[dict[str, object]] = []diff --git a/tests/providers/test_opencode.py b/tests/providers/test_opencode.pyindex 41581f49..77f4d3d3 100644--- a/tests/providers/test_opencode.py+++ b/tests/providers/test_opencode.py@@ -3,11 +3,13 @@import asyncioimport jsonfrom collections.abc import Callable+from copy import deepcopyfrom unittest.mock import AsyncMock, patchimport httpximport httpx2import pytest+from jsonschema import Draft202012Validatorfrom openai import AsyncOpenAIfrom free_claude_code.application.errors import InvalidRequestError@@ -665,6 +667,207 @@ async def test_responses_ingress_uses_catalog_responses_transport_natively() ->assert events[-1].data["response"]["model"] == "responses-selector"+async def test_responses_tool_search_accepts_optional_codex_arguments() -> None:+ # Captured from Codex 0.153.0: OpenCode rejects this client's optional limit.+ parameters = {+ "type": "object",+ "properties": {+ "limit": {+ "type": "number",+ "description": "Maximum number of tools to return. Defaults to 8.",+ },+ "query": {"type": "string"},+ },+ "required": ["query"],+ "additionalProperties": False,+ }+ tools = [+ {"type": "tool_search", "execution": "client", "parameters": parameters},+ {+ "type": "function",+ "name": "ordinary_search",+ "parameters": deepcopy(parameters),+ "strict": False,+ },+ ]+ request = _responses_request("responses-selector", tools=tools)+ original = request.model_dump()++ def upstream(wire_request: httpx2.Request) -> httpx2.Response:+ schema = json.loads(wire_request.content)["tools"][0]["parameters"]+ if set(schema["required"]) != set(schema["properties"]):+ return httpx2.Response(+ 400,+ json={+ "error": {+ "type": "invalid_request_error",+ "param": "parameters",+ "message": "'required' must include every property. Missing 'limit'.",+ }+ },+ )+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text=_responses_event_stream("hello"),+ )++ provider, wire_requests, _ = _provider_with_wire_transports(+ _catalog_payload(), generation_response=upstream+ )+ try:+ await provider.list_model_infos()+ provider.preflight_responses(request)+ body = "".join([chunk async for chunk in provider.stream_responses(request)])+ finally:+ await provider.cleanup()++ assert len(wire_requests) == 1+ assert "hello" in body+ forwarded = json.loads(wire_requests[0].content)["tools"]+ validator = Draft202012Validator(forwarded[0]["parameters"])+ assert validator.is_valid({"query": "files", "limit": None})+ assert validator.is_valid({"query": "files", "limit": 3})+ assert not validator.is_valid({"query": "files", "limit": "three"})+ assert not validator.is_valid({"query": None, "limit": 3})+ assert forwarded[1] == tools[1]+ assert request.model_dump() == original+++async def test_codex_custom_tool_round_trip_uses_opencode_function_tools() -> None:+ patch_text = "*** Begin Patch\n*** Add File: hello.txt\n+hello 🌍\n*** End Patch"+ custom_tool = {+ "type": "custom",+ "name": "edit_file",+ "description": "Edit a file with a raw patch.",+ "format": {"type": "text"},+ }+ tools = [+ custom_tool,+ {+ "type": "web_search",+ "external_web_access": False,+ "search_content_types": ["text", "image"],+ },+ ]++ def upstream(wire_request: httpx2.Request) -> httpx2.Response:+ wire = json.loads(wire_request.content)+ if any(+ tool["type"] == "custom" or "search_content_types" in tool+ for tool in wire["tools"]+ ):+ return httpx2.Response(+ 400,+ json={+ "error": {+ "type": "invalid_request_error",+ "message": "Unsupported tool format",+ }+ },+ )+ packets = [+ json.loads(line[6:])+ for line in _responses_event_stream("done").splitlines()+ if line.startswith("data: ")+ ]+ item = {+ "type": "function_call",+ "id": "item_custom",+ "call_id": "call_custom",+ "name": wire["tools"][0]["name"],+ "arguments": json.dumps({"input": patch_text}),+ "status": "completed",+ }+ packets = [+ packets[0],+ {+ "type": "response.output_item.added",+ "output_index": 0,+ "item": {**item, "arguments": "", "status": "in_progress"},+ },+ {+ "type": "response.function_call_arguments.delta",+ "item_id": item["id"],+ "output_index": 0,+ "delta": item["arguments"],+ },+ {+ "type": "response.function_call_arguments.done",+ "item_id": item["id"],+ "output_index": 0,+ "arguments": item["arguments"],+ },+ {"type": "response.output_item.done", "output_index": 0, "item": item},+ {**packets[-1], "response": {**packets[-1]["response"], "output": [item]}},+ ]+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text="".join(+ "data: " + json.dumps({**packet, "sequence_number": index}) + "\n\n"+ for index, packet in enumerate(packets)+ ),+ )++ provider, wire_requests, _ = _provider_with_wire_transports(+ _catalog_payload(), generation_response=upstream+ )+ try:+ output = await _collect_responses(provider, "responses-selector", tools=tools)+ events = parse_sse_text(output)+ call = events[-1].data["response"]["output"][0]+ assert call == {+ "type": "custom_tool_call",+ "id": "item_custom",+ "call_id": "call_custom",+ "name": "edit_file",+ "input": patch_text,+ "status": "completed",+ }+ assert any(+ event.event == "response.custom_tool_call_input.done"+ and event.data["input"] == patch_text+ for event in events+ )+ assert not any(+ event.event.startswith("response.function_call_arguments")+ for event in events+ )+ sequences = [event.data["sequence_number"] for event in events]+ assert sequences == sorted(set(sequences))+ await _collect_responses(+ provider,+ "responses-selector",+ tools=tools,+ input=[+ call,+ {+ "type": "custom_tool_call_output",+ "call_id": "call_custom",+ "output": "Patch applied",+ },+ ],+ )+ finally:+ await provider.cleanup()++ first = json.loads(wire_requests[0].content)+ assert first["tools"][0]["type"] == "function"+ assert first["tools"][1] == {"type": "web_search", "external_web_access": False}+ replay = json.loads(wire_requests[1].content)["input"]+ assert replay[0]["type"] == "function_call"+ assert json.loads(replay[0]["arguments"]) == {"input": patch_text}+ assert replay[1] == {+ "type": "function_call_output",+ "call_id": "call_custom",+ "output": "Patch applied",+ }+ assert tools[0] == custom_tool++@pytest.mark.asyncioasync def test_responses_ingress_uses_catalog_chat_transport_directly() -> None:provider, generation_requests, catalog_requests = _provider_with_wire_transports(@@ -689,6 +892,120 @@ async def test_responses_ingress_uses_catalog_chat_transport_directly() -> None:assert events[-1].data["response"]["output"][0]["content"][0]["text"] == ("chat-ok")[email protected]("execution", ["client", "server"])+async def test_discovered_custom_tools_survive_sdk_calls_and_replay(+ execution: str,+) -> None:+ definition = {+ "type": "namespace",+ "name": "editor",+ "description": "Editing tools",+ "tools": [+ {+ "type": "custom",+ "name": "edit",+ "format": {"type": "text"},+ "defer_loading": True,+ "allowed_callers": ["direct"],+ "extension": {"keep": True},+ }+ ],+ }+ expected_tool = definition["tools"][0]+ assert isinstance(expected_tool, dict)+ discovery = {+ "type": "tool_search_output",+ "call_id": "search_one",+ "execution": execution,+ "status": "completed",+ "tools": [definition],+ }+ history = [discovery, {**discovery, "call_id": "search_two"}]++ def upstream(request: httpx2.Request) -> httpx2.Response:+ body = json.loads(request.content)+ for loaded in body["input"][:2]:+ assert loaded["execution"] == execution+ tool = loaded["tools"][0]["tools"][0]+ assert tool["type"] == "function"+ for field in ("defer_loading", "allowed_callers", "extension"):+ assert tool[field] == expected_tool[field]+ if len(body["input"]) > 2:+ assert body["input"][2]["type"] == "function_call"+ assert json.loads(body["input"][2]["arguments"]) == {"input": "patch"}+ assert body["input"][3] == {+ "type": "function_call_output",+ "call_id": "edit_one",+ "output": "applied",+ }+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text=_responses_event_stream("done"),+ )+ packets = [+ json.loads(line[6:])+ for line in _responses_event_stream("done").splitlines()+ if line.startswith("data: ")+ ]+ call = {+ "type": "function_call",+ "id": "edit_item",+ "call_id": "edit_one",+ "name": tool["name"],+ "arguments": '{"input":"patch"}',+ "status": "completed",+ }+ events = [+ packets[0],+ {+ "type": "response.output_item.added",+ "output_index": 0,+ "item": {**call, "status": "in_progress", "arguments": ""},+ },+ {"type": "response.output_item.done", "output_index": 0, "item": call},+ {**packets[-1], "response": {**packets[-1]["response"], "output": [call]}},+ ]+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text="".join(+ "data: " + json.dumps({**event, "sequence_number": i}) + "\n\n"+ for i, event in enumerate(events)+ ),+ )++ provider, requests, _ = _provider_with_wire_transports(+ _catalog_payload(), generation_response=upstream+ )+ try:+ response = await _collect_responses(+ provider, "responses-selector", input=history+ )+ call = parse_sse_text(response)[-1].data["response"]["output"][0]+ assert call["type"] == "custom_tool_call"+ assert call["name"] == "edit" and call["namespace"] == "editor"+ reply = await _collect_responses(+ provider,+ "responses-selector",+ input=[+ *history,+ call,+ {+ "type": "custom_tool_call_output",+ "call_id": "edit_one",+ "output": "applied",+ },+ ],+ )+ assert "done" in reply+ finally:+ await provider.cleanup()+ assert len(requests) == 2+ assert history[0]["tools"] == [definition]++@pytest.mark.parametrize(("wire_api",diff --git a/uv.lock b/uv.lockindex ad86cbbe..60af40fb 100644--- a/uv.lock+++ b/uv.lock@@ -598,7 +598,7 @@ wheels = [[[package]]name = "free-claude-code"-version = "5.22.8"+version = "5.22.9"source = { editable = "." }dependencies = [{ name = "aiohttp" },