iCode-TUI 0.29.1__py3-none-any.whl

chrys/service/llm/anthropic_messages/history.py

@@ -0,0 +1,279 @@
+# Copyright (c) Microsoft. All rights reserved.
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+# Contains code adapted from Microsoft Agent Framework (MIT License; see NOTICE).
+
+"""Encode chat history as Messages API messages.
+
+A chat message becomes one wire message per run of blocks that share a wire
+role, in their original order: tool calls go out as ``assistant`` and local
+tool results as ``user`` whatever message carries them; other blocks, hosted
+results included, keep their message's role. Repairs keep the request
+valid: thinking without a signature is dropped (the API rejects it), and so
+are blank text and a wire message left with no blocks; a tool-call id another
+provider minted (``functions.read_file:0``) is sent as an id the API accepts,
+the same for the call and its result. Thinking another endpoint issued is
+left out: only its issuer can check the signature, and so is thinking a
+request was accepted without after the service refused it as bound to a
+different conversation (:data:`THINKING_STRIPPED_KEY`).
+
+Hosted-tool history from another provider is replaced by the neutral summary
+:func:`cross_provider_hosted_degradations` writes, sent as assistant context.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+import re
+from collections.abc import Collection, Mapping, Sequence
+from dataclasses import dataclass, replace
+from typing import TYPE_CHECKING, Any, Final
+
+from chrys.foundation.hosted_tools import ANTHROPIC_HOSTED_WIRE_BLOCK_KEY
+from chrys.foundation.models.history_markers import ANTHROPIC_THINKING_STRIPPED_KEY as THINKING_STRIPPED_KEY
+from chrys.foundation.reasoning_origin import replays_to
+from chrys.kernel._content import _ANTHROPIC_REDACTED_THINKING_KEY
+from chrys.service.agent_middleware.events.hosted_tools import cross_provider_hosted_degradations
+from chrys.service.llm.images import UNSUPPORTED_IMAGE_TEXT, wire_image
+
+if TYPE_CHECKING:
+    from chrys.foundation.reasoning_origin import ReasoningOrigin
+    from chrys.kernel import Content, Message
+
+logger = logging.getLogger(__name__)
+
+# Wire roles fixed by a block's type; other blocks take their message's role.
+_ROLE_OF_BLOCK_TYPE: Final[Mapping[str, str]] = {
+    "tool_use": "assistant",
+    "mcp_tool_use": "assistant",
+    "server_tool_use": "assistant",
+    "tool_result": "user",
+}
+
+
+# The tool-use ids the API accepts.
+_TOOL_ID: Final = re.compile(r"[A-Za-z0-9_-]+")
+
+
+@dataclass(frozen=True, slots=True)
+class _Block:
+    """One encoded content block."""
+
+    wire: dict[str, Any]
+    assistant_context: bool = False
+    """Sent as ``assistant`` whatever its type: a summary of foreign hosted-tool history."""
+    thinking: tuple[Content, ...] = ()
+    """The reasoning contents a thinking or redacted thinking block is encoded from, a signature it took included."""
+
+    def role(self, message_role: str) -> str:
+        if self.assistant_context:
+            return "assistant"
+        return _ROLE_OF_BLOCK_TYPE.get(self.wire.get("type"), message_role)
+
+
+@dataclass(frozen=True, slots=True)
+class EncodedHistory:
+    """The wire messages of a history and the reasoning contents their thinking blocks replay."""
+
+    messages: list[dict[str, Any]]
+    thinking: tuple[Content, ...]
+    """Every content a sent thinking or redacted thinking block is encoded from, each once, in order."""
+
+
+def encode_messages(messages: Sequence[Message], *, origin: ReasoningOrigin | None = None) -> list[dict[str, Any]]:
+    """Encode *messages* after a leading system message, which the request sends as ``system``.
+
+    *origin* is the endpoint the request goes to: thinking, signatures and
+    redacted thinking another endpoint issued are left out.
+    """
+    return encode_history(messages, origin=origin).messages
+
+
+def encode_history(
+    messages: Sequence[Message], *, origin: ReasoningOrigin | None = None, skip: Collection[Content] = ()
+) -> EncodedHistory:
+    """Encode *messages* like :func:`encode_messages`, leaving out the thinking of the contents in *skip*.
+
+    A thinking block is left out when any content it is encoded from is in
+    *skip* (by identity) or carries :data:`THINKING_STRIPPED_KEY`. Blocks are
+    matched with their signatures first and left out after, so a signature
+    never moves to the thinking before the block left out.
+    """
+    history = messages[1:] if messages and messages[0].role == "system" else messages
+    summaries = cross_provider_hosted_degradations(history, target_provider="anthropic")
+    skipped = {id(content) for content in skip}
+    wire_messages: list[dict[str, Any]] = []
+    thinking: dict[int, Content] = {}
+    for message in history:
+        role = "assistant" if message.role == "assistant" else "user"
+        blocks = [
+            block
+            for block in _encode_blocks(message, summaries, origin)
+            if not any(id(content) in skipped or _was_stripped(content) for content in block.thinking)
+        ]
+        for block in blocks:
+            thinking.update((id(content), content) for content in block.thinking)
+        wire_messages.extend(_by_role(blocks, role))
+    return EncodedHistory(wire_messages, tuple(thinking.values()))
+
+
+def _was_stripped(content: Content) -> bool:
+    return content.additional_properties.get(THINKING_STRIPPED_KEY) is True
+
+
+def _by_role(blocks: list[_Block], message_role: str) -> list[dict[str, Any]]:
+    """Group consecutive blocks with the same wire role into one wire message each."""
+    grouped: list[dict[str, Any]] = []
+    for block in blocks:
+        role = block.role(message_role)
+        if grouped and grouped[-1]["role"] == role:
+            grouped[-1]["content"].append(block.wire)
+        else:
+            grouped.append({"role": role, "content": [block.wire]})
+    return grouped
+
+
+def _encode_blocks(
+    message: Message, summaries: Mapping[int, str | None], origin: ReasoningOrigin | None
+) -> list[_Block]:
+    blocks: list[_Block] = []
+    for content in message.contents:
+        if id(content) in summaries:
+            if summary := summaries[id(content)]:
+                blocks.append(_Block({"type": "text", "text": summary}, assistant_context=True))
+            continue
+        # Anthropic's own hosted blocks replay exactly as they were received.
+        received = content.additional_properties.get(ANTHROPIC_HOSTED_WIRE_BLOCK_KEY)
+        if content.hosted_provider == "anthropic" and isinstance(received, Mapping):
+            blocks.append(_Block(dict(received)))
+        elif content.type == "text_reasoning":
+            if replays_to(content.additional_properties, origin):
+                _add_thinking(content, blocks)
+        elif (wire := _encode_content(content)) is not None:
+            blocks.append(_Block(wire))
+    return [block for block in blocks if not _is_unsigned_thinking(block.wire)]
+
+
+def _is_unsigned_thinking(wire: Mapping[str, Any]) -> bool:
+    # Some gateways omit thinking signatures, and replayed thinking without one
+    # fails the request ("signature: Field required"). The reasoning is dropped
+    # rather than replayed as visible text.
+    return wire.get("type") == "thinking" and not wire.get("signature")
+
+
+def _add_thinking(content: Content, blocks: list[_Block]) -> None:
+    properties = content.additional_properties
+    if properties.get(_ANTHROPIC_REDACTED_THINKING_KEY):
+        blocks.append(_Block({"type": "redacted_thinking", "data": content.protected_data}, thinking=(content,)))
+        return
+    if content.id or properties.get("reasoning_text") or properties.get("openai_reasoning_format"):
+        # Another protocol's reasoning (Responses items carry an id and a
+        # marker, Chat Completions dialects stamp their format): sending it as
+        # thinking would forge a signature.
+        return
+    if content.text is None and content.protected_data:
+        # A streamed signature arrives as its own fragment and signs the
+        # thinking block before it.
+        previous = blocks[-1] if blocks else None
+        if previous is not None and previous.wire.get("type") == "thinking" and "signature" not in previous.wire:
+            previous.wire["signature"] = content.protected_data
+            blocks[-1] = replace(previous, thinking=(*previous.thinking, content))
+        return
+    # Thinking streamed without its text (an empty start and an empty delta)
+    # assembles with no text and the start's empty signature: it is an empty
+    # block, which the signature fragment after it signs; without one, the
+    # block is unsigned and dropped.
+    thinking: dict[str, Any] = {"type": "thinking", "thinking": content.text or ""}
+    if content.protected_data:
+        thinking["signature"] = content.protected_data
+    blocks.append(_Block(thinking, thinking=(content,)))
+
+
+def _encode_content(content: Content) -> dict[str, Any] | None:
+    match content.type:
+        case "text":
+            # The API rejects blank text blocks.
+            return {"type": "text", "text": content.text} if content.text and not content.text.isspace() else None
+        case "data" | "uri":
+            if (image := _image_block(content)) is None:
+                logger.debug("Ignoring unsupported data content media type: %s", content.media_type)
+            return image
+        case "function_call":
+            return {
+                "type": "tool_use",
+                "id": _wire_tool_id(content.call_id),
+                "name": content.name,
+                "input": content.parse_arguments(),
+            }
+        case "function_result":
+            return {
+                "type": "tool_result",
+                "tool_use_id": _wire_tool_id(content.call_id),
+                "content": _tool_result_blocks(content) or _tool_result_text(content.result),
+                "is_error": content.exception is not None,
+            }
+        case "mcp_server_tool_call":
+            return {
+                "type": "mcp_tool_use",
+                "id": _wire_tool_id(content.call_id),
+                "name": content.tool_name,
+                "server_name": content.server_name or "",
+                "input": content.parse_arguments() or {},
+            }
+        case "mcp_server_tool_result":
+            return {
+                "type": "mcp_tool_result",
+                "tool_use_id": _wire_tool_id(content.call_id),
+                "content": content.output if content.output is not None else "",
+            }
+        case _:
+            logger.debug("Ignoring unsupported content type: %s", content.type)
+            return None
+
+
+def _wire_tool_id(call_id: str | None) -> str | None:
+    """*call_id* as an id the API accepts.
+
+    An id it rejects maps to one derived from its value, so a call and its
+    result keep matching. An empty id is sent as it is.
+    """
+    if not call_id or _TOOL_ID.fullmatch(call_id):
+        return call_id
+    digest = hashlib.sha256(call_id.encode("utf-8", "surrogatepass")).hexdigest()
+    return f"toolu_chrys_{digest[:32]}"
+
+
+def _tool_result_text(result: Any) -> Any:
+    """A tool result's own value, or ``""`` for none or blank text, which the API rejects."""
+    if result is None or (isinstance(result, str) and result.isspace()):
+        return ""
+    return result
+
+
+def _tool_result_blocks(result: Content) -> list[dict[str, Any]]:
+    """The text and image items of a tool result; blank text and other items are not sent."""
+    blocks: list[dict[str, Any]] = []
+    for item in result.items or ():
+        if item.type == "text":
+            if item.text and not item.text.isspace():
+                blocks.append({"type": "text", "text": item.text})
+        elif item.type in ("data", "uri") and (image := _image_block(item)) is not None:
+            blocks.append(image)
+        else:
+            logger.debug("Ignoring unsupported rich content media type in tool result: %s", item.media_type)
+    return blocks
+
+
+def _image_block(content: Content) -> dict[str, Any] | None:
+    """A ``data`` or ``uri`` content as an image block; None when it is no image.
+
+    An image the API can't read goes out as a text block saying so; a link
+    saved without a type (older sessions kept MCP links that way) is no image.
+    """
+    if content.media_type is None or not content.has_top_level_media_type("image"):
+        return None
+    if (image := wire_image(content)) is None:
+        return {"type": "text", "text": UNSUPPORTED_IMAGE_TEXT}
+    if image.data is not None:
+        return {"type": "image", "source": {"data": image.data, "media_type": image.media_type, "type": "base64"}}
+    return {"type": "image", "source": {"type": "url", "url": image.uri}}

chrys/service/llm/anthropic_messages/request.py

@@ -0,0 +1,323 @@
+# Copyright (c) Microsoft. All rights reserved.
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+# Contains code adapted from Microsoft Agent Framework (MIT License; see NOTICE).
+
+"""Build the ``messages.create`` arguments of one call.
+
+:func:`build_request` decides every request field: the renamed chat options,
+the default output cap, the encoded history and system prompt, the thinking
+block binding, the ``anthropic-beta`` header, the user id, tool declarations
+and structured output. The client stamps its Chrys headers on the result.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Collection, Iterable, Mapping, Sequence
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Final
+
+from chrys.kernel import (
+    ChatClientInvalidRequestException,
+    FunctionTool,
+    Message,
+    normalize_tools,
+    prepend_instructions_to_messages,
+    validate_tool_mode,
+)
+from chrys.service.profiles.models.options import AUTO_INTERLEAVED_THINKING_OPTION, THINKING_BLOCK_BINDING_OPTION
+
+from .history import encode_history
+from .thinking_binding import (
+    BINDING_CONTROLS_BETA,
+    INTERLEAVED_THINKING_BETA,
+    ThinkingBindingPolicy,
+    apply_thinking_binding,
+    resolve_thinking_binding,
+)
+
+if TYPE_CHECKING:
+    from pydantic import BaseModel
+
+    from chrys.foundation.reasoning_origin import ReasoningOrigin
+    from chrys.kernel import Content
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_BETAS: Final = ("mcp-client-2025-04-04", "code-execution-2025-08-25")
+"""Betas every request enables unless its ``extra_headers`` name the betas themselves."""
+
+BETA_HEADER: Final = "anthropic-beta"
+
+FALLBACK_MAX_OUTPUT_TOKENS: Final = 16 * 1024
+"""Output cap of a call that sets none: the Messages API requires one.
+
+Profile-driven calls never use it: ``effective_chat_options`` gives every
+live request the profile's ``max_output_tokens``, whose default
+(``DEFAULT_MAX_OUTPUT_TOKENS`` in ``chrys.service.profiles.models.schema``)
+is a deliberately separate constant.
+"""
+
+# (chat option, Messages API field) pairs; an explicit field wins over its option.
+_RENAMED_OPTIONS: Final = (("stop", "stop_sequences"), ("instructions", "system"))
+
+# Chat options build_request reads itself instead of copying them, and ``stream``,
+# which the call site sets.
+_OPTIONS_NOT_COPIED: Final = frozenset(
+    {
+        "instructions",
+        "response_format",
+        "additional_beta_flags",
+        "betas",
+        "allow_multiple_tool_calls",
+        "stream",
+        THINKING_BLOCK_BINDING_OPTION,
+        AUTO_INTERLEAVED_THINKING_OPTION,
+    }
+)
+
+# Call keywords that configure the call and never become request fields. The
+# betas and thinking settings are read from the options only.
+_CALL_SETTINGS: Final = frozenset(
+    {
+        "thread",
+        "middleware",
+        "additional_beta_flags",
+        "betas",
+        THINKING_BLOCK_BINDING_OPTION,
+        AUTO_INTERLEAVED_THINKING_OPTION,
+    }
+)
+
+
+@dataclass(frozen=True, slots=True)
+class BuiltRequest:
+    """The ``messages.create`` arguments of one call and what they replay."""
+
+    request: dict[str, Any]
+    policy: ThinkingBindingPolicy
+    thinking: tuple[Content, ...]
+    """The reasoning contents the request's thinking blocks replay; none when ``extra_body`` sends its own messages."""
+
+
+def build_request(
+    messages: Sequence[Message],
+    options: Mapping[str, Any],
+    call_kwargs: Mapping[str, Any],
+    *,
+    model: str,
+    base_url: object,
+    default_headers: Mapping[str, object],
+    origin: ReasoningOrigin | None = None,
+    skip_thinking: Collection[Content] = (),
+) -> BuiltRequest:
+    """Return the request for *messages* under *options*, without Chrys headers, and what it replays.
+
+    Options set to None are left out. Call keywords become request fields too,
+    except private (underscore) names and :data:`_CALL_SETTINGS`. *model* is
+    used when neither sets one. *base_url* is where the SDK client sends the
+    request and *default_headers* the headers it adds to every request.
+    *origin* is the endpoint the request goes to: thinking another one issued
+    is left out, and so is the thinking of the contents in *skip_thinking*.
+    The result's ``thinking`` lists the reasoning contents the request
+    replays: passed back as *skip_thinking*, they build the same request
+    without that thinking.
+    """
+    if instructions := options.get("instructions"):
+        messages = prepend_instructions_to_messages(list(messages), instructions, role="system")
+
+    request = {key: value for key, value in options.items() if value is not None and key not in _OPTIONS_NOT_COPIED}
+    _rename_options(request)
+    call_fields = {
+        key: value for key, value in call_kwargs.items() if not key.startswith("_") and key not in _CALL_SETTINGS
+    }
+    _rename_options(call_fields)
+    request.update(call_fields)
+
+    if not request.get("model"):
+        if not model:
+            raise ValueError("model must be a non-empty string")
+        request["model"] = model
+    if not request.get("max_tokens"):
+        request["max_tokens"] = FALLBACK_MAX_OUTPUT_TOKENS
+    policy = resolve_thinking_binding(request, options, base_url=base_url)
+    apply_thinking_binding(request, policy)
+    history = encode_history(messages, origin=origin, skip=skip_thinking)
+    request["messages"] = history.messages
+    if messages and isinstance(messages[0], Message) and messages[0].role == "system":
+        request["system"] = messages[0].text
+    request["extra_headers"] = _with_beta_header(request.get("extra_headers"), options, default_headers, policy)
+    if user := request.pop("user", None):
+        # The Messages API takes the end-user id as ``metadata.user_id``.
+        metadata = dict(request.get("metadata") or {})
+        if "user_id" not in metadata:
+            metadata["user_id"] = user
+        request["metadata"] = metadata
+    if tool_fields := encode_tools(options):
+        request.update(tool_fields)
+    if (response_format := options.get("response_format")) is not None:
+        request["output_config"] = _output_config_with_format(request.get("output_config"), response_format)
+    extra_body = request.get("extra_body")
+    sends_own_messages = isinstance(extra_body, Mapping) and "messages" in extra_body
+    return BuiltRequest(request, policy, () if sends_own_messages else history.thinking)
+
+
+def _with_beta_header(
+    extra_headers: object,
+    options: Mapping[str, Any],
+    default_headers: Mapping[str, object],
+    policy: ThinkingBindingPolicy,
+) -> dict[str, Any]:
+    """*extra_headers* with one ``anthropic-beta`` header in place of every spelling of it.
+
+    The header lists :data:`DEFAULT_BETAS`, ``additional_beta_flags``,
+    ``betas`` and the client's default ``anthropic-beta`` header, in that
+    order; an ``anthropic-beta`` header *extra_headers* names itself replaces
+    them all. The betas *policy* needs follow either way. Comma-separated
+    values are split, and each beta is listed once. A request with no beta
+    gets no header.
+    """
+    headers = dict(extra_headers) if isinstance(extra_headers, Mapping) else {}
+    if any(_is_beta_header(name) and not isinstance(value, str) for name, value in headers.items()):
+        # Left as written, so the request's header check refuses the value.
+        return headers
+    explicit = [headers.pop(name) for name in list(headers) if _is_beta_header(name)]
+    sources: list[object] = explicit or [
+        DEFAULT_BETAS,
+        options.get("additional_beta_flags"),
+        options.get("betas"),
+        *(value for name, value in default_headers.items() if _is_beta_header(name) and isinstance(value, str)),
+    ]
+    if policy.controls_beta:
+        sources.append(BINDING_CONTROLS_BETA)
+    if policy.interleaved_beta:
+        sources.append(INTERLEAVED_THINKING_BETA)
+    if betas := dict.fromkeys(beta for source in sources for beta in _betas_in(source)):
+        headers[BETA_HEADER] = ",".join(betas)
+    return headers
+
+
+def _is_beta_header(name: object) -> bool:
+    return isinstance(name, str) and name.lower() == BETA_HEADER
+
+
+def _betas_in(value: object) -> list[str]:
+    """The betas a string, or each item of a list, names: comma-separated, blanks dropped."""
+    if value is None:
+        return []
+    items = value if isinstance(value, Iterable) and not isinstance(value, str | Mapping) else [value]
+    return [beta for item in items for beta in (part.strip() for part in str(item).split(",")) if beta]
+
+
+def _rename_options(fields: dict[str, Any]) -> None:
+    for option, field in _RENAMED_OPTIONS:
+        if option in fields:
+            fields.setdefault(field, fields.pop(option))
+
+
+def encode_tools(options: Mapping[str, Any]) -> dict[str, Any] | None:
+    """Encode the call's tools and tool choice; None when there are neither.
+
+    A function tool becomes a ``custom`` declaration, an ``mcp`` mapping an
+    ``mcp_servers`` entry; any other tool is a provider declaration and is
+    sent as given.
+    """
+    fields: dict[str, Any] = {}
+    if tools := options.get("tools"):
+        declarations: list[Any] = []
+        mcp_servers: list[dict[str, Any]] = []
+        for tool in normalize_tools(tools):
+            if isinstance(tool, FunctionTool):
+                declarations.append(
+                    {
+                        "type": "custom",
+                        "name": tool.name,
+                        "description": tool.description,
+                        "input_schema": tool.parameters(),
+                    }
+                )
+            elif isinstance(tool, Mapping) and tool.get("type") == "mcp":
+                mcp_servers.append(_mcp_server(tool))
+            else:
+                declarations.append(tool)
+        if declarations:
+            fields["tools"] = declarations
+        if mcp_servers:
+            fields["mcp_servers"] = mcp_servers
+    if (tool_choice := _tool_choice(options)) is not None:
+        fields["tool_choice"] = tool_choice
+    return fields or None
+
+
+def _mcp_server(tool: Mapping[str, Any]) -> dict[str, Any]:
+    server: dict[str, Any] = {"type": "url", "name": tool.get("server_label", ""), "url": tool.get("server_url", "")}
+    allowed_tools = tool.get("allowed_tools")
+    if isinstance(allowed_tools, Sequence) and not isinstance(allowed_tools, str):
+        server["tool_configuration"] = {"allowed_tools": [str(name) for name in allowed_tools]}
+    headers = tool.get("headers")
+    authorization = headers.get("authorization") if isinstance(headers, Mapping) else None
+    if isinstance(authorization, str):
+        server["authorization_token"] = authorization
+    return server
+
+
+def _tool_choice(options: Mapping[str, Any]) -> dict[str, Any] | None:
+    if options.get("tool_choice") is None:
+        return None
+    tool_mode = validate_tool_mode(options.get("tool_choice"))
+    if tool_mode is None:
+        return None
+    if "allowed_tools" in tool_mode:
+        logger.warning("allowed_tools is not supported by Anthropic; the setting will be ignored")
+    choice: dict[str, Any]
+    match tool_mode.get("mode"):
+        case "none":
+            return {"type": "none"}
+        case "auto":
+            choice = {"type": "auto"}
+        case "required" if "required_function_name" in tool_mode:
+            choice = {"type": "tool", "name": tool_mode["required_function_name"]}
+        case "required":
+            choice = {"type": "any"}
+        case _:
+            logger.debug("Ignoring unsupported tool choice mode: %s", tool_mode)
+            return None
+    # The choice carries the parallel-call setting; it is no request field of its own.
+    if (allow_multiple := options.get("allow_multiple_tool_calls")) is not None:
+        choice["disable_parallel_tool_use"] = not allow_multiple
+    return choice
+
+
+def _output_config_with_format(output_config: Any, response_format: Any) -> dict[str, Any]:
+    if output_config is None:
+        merged: dict[str, Any] = {}
+    elif isinstance(output_config, Mapping):
+        merged = dict(output_config)
+    else:
+        raise ChatClientInvalidRequestException("output_config must be a mapping.")
+    if merged.get("format") is not None:
+        raise ChatClientInvalidRequestException(
+            "response_format cannot be combined with explicit output_config.format."
+        )
+    merged["format"] = encode_output_format(response_format)
+    return merged
+
+
+def encode_output_format(response_format: type[BaseModel] | dict[str, Any]) -> dict[str, Any]:
+    """The ``output_config.format`` value for a Pydantic model or a JSON-schema mapping.
+
+    A mapping may carry its schema under ``json_schema.schema`` or ``schema``,
+    or be the schema itself. The schema is sent closed to extra properties.
+    """
+    schema = _json_schema(response_format)
+    if isinstance(schema, dict):
+        schema = {**schema, "additionalProperties": False}
+    return {"type": "json_schema", "schema": schema}
+
+
+def _json_schema(response_format: type[BaseModel] | dict[str, Any]) -> Any:
+    if not isinstance(response_format, dict):
+        return response_format.model_json_schema()
+    if "json_schema" in response_format:
+        return response_format["json_schema"].get("schema", {})
+    return response_format.get("schema", response_format)