Skip to content

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.toml
index 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__.py
index 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_error
from .streaming.event_builders import ResponseEventBuilder
from .streaming.ledger import ResponsesOutputLedger
from .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.py
index 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_egress
from .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, obj
def _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 tool
name = 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 tool
name = 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"] = description
return {"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 None
return {"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.py
index 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 OpenAIToolNameCodec
from .errors import ResponsesConversionError
from .models import OpenAIResponsesRequest
from .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, body
def 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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 result
diff --git a/src/free_claude_code/core/openai_responses/tools.py b/src/free_claude_code/core/openai_responses/tools.py
index 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 Mapping
from dataclasses import dataclass
from typing import Any, Literal
+from free_claude_code.core.json_types import JsonObject
+
from .errors import ResponsesConversionError
from .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 combined
digest = 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) - 1
return 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 tool
if (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)
continue
if 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_tool
if (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
)
continue
if 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.py
index 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.py
index 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
@property
def 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.py
index 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 = client
self._endpoint_transport = endpoint_transport
self._event_adapter_factory = event_adapter_factory
self._omitted_request_fields = omitted_request_fields
+ self._tool_policy = tool_policy
self._admission = admission
self._provider_name = provider_name
self._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, tools
def _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.py
index 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 InvalidRequestError
from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.core.anthropic import ReasoningReplayMode
from 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, ReasoningPolicy
from free_claude_code.providers.admission import ProviderAdmissionController
from 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.py
new file mode 100644
index 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.completed
diff --git a/tests/core/openai_responses/test_tool_search.py b/tests/core/openai_responses/test_tool_search.py
new file mode 100644
index 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) == tool
diff --git a/tests/providers/test_openai_responses_transport.py b/tests/providers/test_openai_responses_transport.py
index 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, ReasoningPolicy
from free_claude_code.providers.openai_responses import OpenAIResponsesTransport
from 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.asyncio
async 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.py
index 41581f49..77f4d3d3 100644
--- a/tests/providers/test_opencode.py
+++ b/tests/providers/test_opencode.py
@@ -3,11 +3,13 @@
import asyncio
import json
from collections.abc import Callable
+from copy import deepcopy
from unittest.mock import AsyncMock, patch
import httpx
import httpx2
import pytest
+from jsonschema import Draft202012Validator
from openai import AsyncOpenAI
from 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.asyncio
async 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.lock
index 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" },