This commit is contained in:
ryan-crabbe-berri 2026-10-30 04:36:51 -04:00 • committed by GitHub
commit c1a4054fb9
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
12 changed files with 696 additions and 190 deletions

View file

@ -2,7 +2,7 @@ import copy
import json
import re
import time
from collections.abc import Callable, Mapping, Sequence
from collections.abc import Mapping, Sequence
from types import MappingProxyType
from typing import TYPE_CHECKING, Any, ClassVar, Final, NoReturn, cast
@ -27,15 +27,12 @@ from litellm.constants import (
from litellm.litellm_core_utils.core_helpers import drops_unsupported_params, map_finish_reason
from litellm.litellm_core_utils.prompt_templates.common_utils import (
DEFS_MAX_INLINED_BYTES,
is_object_schema,
sanitize_input_schema_for_anthropic,
schema_fragment_ref,
schema_grammar_branch_count,
schema_has_lookaround_pattern,
schema_has_open_object,
schema_has_unresolvable_ref,
schema_optional_property_count,
schema_string_formats,
schema_union_property_count,
unpack_defs,
)
@ -48,6 +45,9 @@ from litellm.litellm_core_utils.prompt_templates.mid_conversation_system import
place_mid_conversation_system,
split_leading_system_run,
)
from litellm.llms.anthropic.output_schema import (
shape_claude_output_schema,
)
from litellm.llms.base_llm.base_utils import (
ResponseFormatSchema,
as_json_object,
@ -166,9 +166,6 @@ _DEFER_LOADING_ADAPTER: Final = TypeAdapter(bool)
_TOOL_FIELDS_ADAPTER: Final = TypeAdapter(Mapping[str, object])
_TOOLS_ADAPTER: Final = TypeAdapter(list[object])
_LITELLM_PARAMS_ADAPTER: Final = TypeAdapter(Mapping[str, object])
_NATIVE_OUTPUT_STRING_FORMATS: Final = frozenset(
("date-time", "time", "date", "duration", "email", "hostname", "uri", "ipv4", "ipv6", "uuid")
)
NATIVE_OUTPUT_MAX_UNION_PARAMETERS: Final = 16
NATIVE_OUTPUT_MAX_OPTIONAL_PARAMETERS: Final = 24
NATIVE_OUTPUT_MAX_GRAMMAR_BRANCHES: Final = 2048
@ -268,31 +265,6 @@ class _AnthropicToolResultBlock(TypedDict, total=False):
content: ReadOnly[object]
_ENUM_TYPE_CHECKS: Final[Mapping[object, Callable[[object], bool]]] = MappingProxyType(
{
"null": lambda v: v is None,
"boolean": lambda v: isinstance(v, bool),
"integer": lambda v: isinstance(v, int) and not isinstance(v, bool),
"number": lambda v: isinstance(v, (int, float)) and not isinstance(v, bool),
"string": lambda v: isinstance(v, str),
"array": lambda v: isinstance(v, list),
"object": lambda v: isinstance(v, dict),
}
)
def _enum_conflicts_with_declared_type(schema: Mapping[str, object]) -> bool:
"""Whether ``schema``'s ``enum`` cannot match its declared ``type``."""
enum_values: Final = schema.get("enum")
declared_type: Final = schema.get("type")
if not isinstance(enum_values, list) or declared_type is None:
return False
if isinstance(declared_type, list):
return True
check: Final = _ENUM_TYPE_CHECKS.get(declared_type)
return check is not None and not all(check(value) for value in enum_values)
# Single, internal-only key on ``litellm_params`` used to thread the per-
# request reverse map (sanitized -> original) from request build to response
# parsing. ``litellm_params`` is never serialized to a provider; ``optional_
@ -766,149 +738,9 @@ class AnthropicConfig(AnthropicModelInfo, BaseConfig):
return params
@staticmethod
def filter_anthropic_output_schema(schema: dict[str, Any]) -> dict[str, Any]:
"""
Filter out unsupported fields from JSON schema for Anthropic's output_format API.
Anthropic's output_format doesn't support certain JSON schema properties.
These are constraints that cannot be enforced by the constrained-decoding
grammar Anthropic compiles the schema into, so the API rejects them with a
400 ``invalid_request_error`` (e.g. "output_format.schema: For 'array' type,
property 'uniqueItems' is not supported"):
- maxItems/minItems above 1/uniqueItems/contains/minContains/maxContains/prefixItems: array constraints
- minimum/maximum/exclusiveMinimum/exclusiveMaximum/multipleOf: numeric constraints
- minLength/maxLength: string constraints
- minProperties/maxProperties/patternProperties/propertyNames: object constraints
- dependentRequired/dependentSchemas/unevaluatedProperties: object constraints
- if/then/else/not: conditional and negation keywords
``oneOf`` is also rejected ("Schema type 'oneOf' is not supported") and is
rewritten to ``anyOf``, matching the Anthropic SDK. Unknown keywords are
ignored by the API, so anything not listed here passes through untouched.
This mirrors the transformation done by the Anthropic Python SDK.
See: https://platform.claude.com/docs/en/build-with-claude/structured-outputs#how-sdk-transformation-works
The SDK approach:
1. Remove unsupported constraints from schema
2. Add constraint info to description (e.g., "Must be at least 100")
3. Validate responses against original schema
Args:
schema: The JSON schema dictionary to filter
Returns:
A new dictionary with unsupported fields removed and descriptions updated
Related issues:
- https://github.com/BerriAI/litellm/issues/19444
"""
if not isinstance(schema, dict):
return schema
constraint_labels: Final = {
"minItems": "minimum number of items: {}",
"maxItems": "maximum number of items: {}",
"uniqueItems": "all array items must be unique",
"contains": "array must contain an item matching: {}",
"minContains": "minimum number of matching items: {}",
"maxContains": "maximum number of matching items: {}",
"prefixItems": "leading items must match, in order: {}",
"minimum": "minimum value: {}",
"maximum": "maximum value: {}",
"exclusiveMinimum": "exclusive minimum value: {}",
"exclusiveMaximum": "exclusive maximum value: {}",
"multipleOf": "must be a multiple of {}",
"minLength": "minimum length: {}",
"maxLength": "maximum length: {}",
"minProperties": "minimum number of properties: {}",
"maxProperties": "maximum number of properties: {}",
"patternProperties": "properties whose names match each pattern must satisfy: {}",
"propertyNames": "property names must satisfy: {}",
"dependentRequired": "dependent required properties: {}",
"dependentSchemas": "dependent schemas: {}",
"unevaluatedProperties": "unevaluated properties must satisfy: {}",
"if": "conditional (if): {}",
"then": "conditional (then): {}",
"else": "conditional (else): {}",
"not": "must not match: {}",
}
schema_fields: Final[Mapping[str, object]] = MappingProxyType(schema)
min_items: Final = schema.get("minItems")
enforced_min_items: Final = (
isinstance(min_items, int) and not isinstance(min_items, bool) and min_items in (0, 1)
)
unsupported_fields: Final = set(constraint_labels) - ({"minItems"} if enforced_min_items else set())
# Build description additions from removed constraints. Iterating
# constraint_labels (not the set) keeps the note order deterministic across
# processes, so identical requests serialize identically regardless of
# PYTHONHASHSEED and stay cache-friendly.
constraint_descriptions: Final[list] = []
for field, label in constraint_labels.items():
if field not in schema or field not in unsupported_fields:
continue
value = schema_fields[field]
# A falsy boolean constraint (e.g. ``uniqueItems: false``) imposes no
# real requirement, so don't add a misleading advisory note for it.
if isinstance(value, bool) and not value:
continue
# Sub-schema constraints (e.g. ``contains``) are serialized as JSON so
# the advisory note preserves what the constraint actually required,
# instead of just noting that it existed.
note_value = json.dumps(value) if isinstance(value, (dict, list)) else value
constraint_descriptions.append(label.format(note_value))
result: Final[dict[str, Any]] = {}
# Update description with removed constraint info
if constraint_descriptions:
existing_desc: Final = schema.get("description", "")
constraint_note: Final = "Note: " + ", ".join(constraint_descriptions) + "."
if existing_desc:
result["description"] = existing_desc + " " + constraint_note
else:
result["description"] = constraint_note
drops_conflicting_type: Final = _enum_conflicts_with_declared_type(schema)
for key, value in schema_fields.items():
if key in unsupported_fields:
continue
if key == "type" and drops_conflicting_type:
continue
if key == "description" and "description" in result:
# Already handled above
continue
if key in ("properties", "$defs", "definitions") and isinstance(value, dict):
nested_schemas: dict[str, Any] = value # mutable-ok: filter_anthropic_output_schema takes a dict
result[key] = {k: AnthropicConfig.filter_anthropic_output_schema(v) for k, v in nested_schemas.items()}
elif key == "items" and isinstance(value, dict):
nested_schema: dict[str, Any] = value # mutable-ok: filter_anthropic_output_schema takes a dict
result[key] = AnthropicConfig.filter_anthropic_output_schema(nested_schema)
elif key == "anyOf" and isinstance(value, list):
result["anyOf"] = result.get("anyOf", []) + [
AnthropicConfig.filter_anthropic_output_schema(item) for item in value
]
elif key == "allOf" and isinstance(value, list):
result[key] = [AnthropicConfig.filter_anthropic_output_schema(item) for item in value]
elif key == "$ref" and isinstance(value, str):
result[key] = schema_fragment_ref(value)
elif key == "oneOf" and isinstance(value, list):
# Anthropic rejects oneOf ("Schema type 'oneOf' is not supported");
# the Anthropic SDK rewrites it to anyOf, so do the same.
result["anyOf"] = result.get("anyOf", []) + [
AnthropicConfig.filter_anthropic_output_schema(item) for item in value
]
else:
result[key] = value
# Anthropic requires additionalProperties=false for object schemas
# See: https://docs.anthropic.com/en/docs/build-with-claude/structured-outputs
if is_object_schema(result):
result["additionalProperties"] = False
return result
def filter_anthropic_output_schema(schema: Mapping[str, object]) -> dict[str, object]:
"""Shape ``schema`` for Anthropic's ``output_format`` API. See ``shape_claude_output_schema``."""
return shape_claude_output_schema(schema)
def get_json_schema_from_pydantic_object(self, response_format: type[BaseModel] | dict | None) -> dict | None:
return type_to_response_format_param(
@ -1671,7 +1503,6 @@ class AnthropicConfig(AnthropicModelInfo, BaseConfig):
schema_has_unresolvable_ref(json_schema)
or schema_has_open_object(json_schema)
or schema_has_lookaround_pattern(json_schema)
or not schema_string_formats(json_schema) <= _NATIVE_OUTPUT_STRING_FORMATS
or schema_union_property_count(json_schema) > NATIVE_OUTPUT_MAX_UNION_PARAMETERS
or schema_optional_property_count(json_schema) > NATIVE_OUTPUT_MAX_OPTIONAL_PARAMETERS
or schema_grammar_branch_count(json_schema) > NATIVE_OUTPUT_MAX_GRAMMAR_BRANCHES

View file

@ -0,0 +1,217 @@
"""
Shape a JSON schema into what Claude's structured-output grammar accepts, for
Anthropic ``output_format`` and Bedrock Converse and Invoke alike. Mirrors the
Anthropic SDK transform:
https://platform.claude.com/docs/en/build-with-claude/structured-outputs#how-sdk-transformation-works
"""
import json
from collections.abc import Callable, Iterator, Mapping
from types import MappingProxyType
from typing import Final
from pydantic import TypeAdapter, ValidationError
from litellm.litellm_core_utils.prompt_templates.common_utils import schema_fragment_ref
# anthropic SDK ``lib/_parse/_transform.py`` SupportedStringFormats, checked 2026-10-13
NATIVE_OUTPUT_STRING_FORMATS: Final = frozenset(
{"date-time", "time", "date", "duration", "email", "hostname", "uri", "ipv4", "ipv6", "uuid"}
)
_CONSTRAINT_NOTES: Final[Mapping[str, str]] = MappingProxyType(
{
"minItems": "minimum number of items: {}",
"maxItems": "maximum number of items: {}",
"uniqueItems": "all array items must be unique",
"contains": "array must contain an item matching: {}",
"minContains": "minimum number of matching items: {}",
"maxContains": "maximum number of matching items: {}",
"prefixItems": "leading items must match, in order: {}",
"minimum": "minimum value: {}",
"maximum": "maximum value: {}",
"exclusiveMinimum": "exclusive minimum value: {}",
"exclusiveMaximum": "exclusive maximum value: {}",
"multipleOf": "must be a multiple of {}",
"minLength": "minimum length: {}",
"maxLength": "maximum length: {}",
"minProperties": "minimum number of properties: {}",
"maxProperties": "maximum number of properties: {}",
"patternProperties": "properties whose names match each pattern must satisfy: {}",
"propertyNames": "property names must satisfy: {}",
"dependentRequired": "dependent required properties: {}",
"dependentSchemas": "dependent schemas: {}",
"unevaluatedProperties": "unevaluated properties must satisfy: {}",
"if": "conditional (if): {}",
"then": "conditional (then): {}",
"else": "conditional (else): {}",
"not": "must not match: {}",
}
)
_SCHEMA_MAP_KEYS: Final = frozenset({"properties", "$defs", "definitions"})
_COMPOSITION_KEYS: Final = frozenset({"anyOf", "oneOf", "allOf", "$ref"})
_ENUM_TYPE_CHECKS: Final[Mapping[str, Callable[[object], bool]]] = MappingProxyType(
{
"null": lambda v: v is None,
"boolean": lambda v: isinstance(v, bool),
"integer": lambda v: isinstance(v, int) and not isinstance(v, bool),
"number": lambda v: isinstance(v, (int, float)) and not isinstance(v, bool),
"string": lambda v: isinstance(v, str),
"array": lambda v: isinstance(v, list),
"object": lambda v: isinstance(v, dict),
}
)
_SCHEMA: Final = TypeAdapter(Mapping[str, object])
_ITEMS: Final = TypeAdapter(list[object])
_TYPE_NAMES: Final = TypeAdapter(list[str])
def _as_schema(value: object) -> Mapping[str, object] | None:
try:
return _SCHEMA.validate_python(value)
except ValidationError:
return None
def _as_items(value: object) -> list[object] | None:
try:
return _ITEMS.validate_python(value)
except ValidationError:
return None
def _declared_types(value: object) -> frozenset[str]:
if isinstance(value, str):
return frozenset((value,))
try:
return frozenset(_TYPE_NAMES.validate_python(value))
except ValidationError:
return frozenset()
def _enum_conflicts_with_declared_type(schema: Mapping[str, object]) -> bool:
"""Whether ``schema``'s ``enum`` cannot match its declared ``type``."""
enum_values: Final = _as_items(schema.get("enum"))
declared_type: Final = schema.get("type")
if enum_values is None or declared_type is None:
return False
if isinstance(declared_type, str):
check: Final = _ENUM_TYPE_CHECKS.get(declared_type)
return check is not None and not all(check(value) for value in enum_values)
return _as_items(declared_type) is not None
def _note_value(value: object) -> object:
return value if value is None or isinstance(value, (str, int, float)) else json.dumps(value)
def _keeps_min_items(schema: Mapping[str, object]) -> bool:
"""Claude's grammar enforces ``minItems`` of 0 or 1 and rejects anything larger."""
value: Final = schema.get("minItems")
return isinstance(value, int) and not isinstance(value, bool) and value in (0, 1)
def _dropped_constraints(schema: Mapping[str, object]) -> frozenset[str]:
return frozenset(_CONSTRAINT_NOTES) - ({"minItems"} if _keeps_min_items(schema) else frozenset())
def _constraint_notes(schema: Mapping[str, object]) -> Iterator[str]:
dropped: Final = _dropped_constraints(schema)
for key, label in _CONSTRAINT_NOTES.items():
if key in dropped and schema.get(key, False) is not False:
yield label.format(_note_value(schema[key]))
def _may_be_string(declared_type: object) -> bool:
return declared_type is None or "string" in _declared_types(declared_type)
def _unsupported_format(schema: Mapping[str, object], declared_type: object) -> str | None:
"""Claude rejects string formats outside its list, while numeric formats such as ``int64`` pass through."""
value: Final = schema.get("format")
if _may_be_string(declared_type) and isinstance(value, str) and value not in NATIVE_OUTPUT_STRING_FORMATS:
return value
return None
def _description_field(existing: object, notes: tuple[str, ...]) -> Mapping[str, object]:
if not notes:
return {}
note: Final = "Note: " + ", ".join(notes) + "."
if isinstance(existing, str) and existing:
return {"description": existing + " " + note}
return {"description": note}
def _object_fields(declared_type: object, schema: Mapping[str, object]) -> Mapping[str, object]:
"""Claude 400s on any object node not closed with ``additionalProperties: false`` or missing ``type``."""
if "object" in _declared_types(declared_type):
return {"additionalProperties": False}
if (
declared_type is None
and "enum" not in schema
and _as_schema(schema.get("properties")) is not None
and not _COMPOSITION_KEYS & schema.keys()
):
return {"type": "object", "additionalProperties": False}
return {}
def _shape_if_schema(value: object) -> object:
nested: Final = _as_schema(value)
return value if nested is None else shape_claude_output_schema(nested)
def _shape_each(value: object) -> object:
items: Final = _as_items(value)
return value if items is None else [_shape_if_schema(item) for item in items]
def _shape_nested(key: str, value: object) -> object:
if key in _SCHEMA_MAP_KEYS:
members: Final = _as_schema(value)
return value if members is None else {name: _shape_if_schema(member) for name, member in members.items()}
if key == "items":
return _shape_if_schema(value)
if key == "allOf":
return _shape_each(value)
if key == "$ref" and isinstance(value, str):
return schema_fragment_ref(value)
return value
def _any_of_field(schema: Mapping[str, object]) -> Mapping[str, object]:
variants: Final = [*(_as_items(schema.get("anyOf")) or ()), *(_as_items(schema.get("oneOf")) or ())]
return {"anyOf": [_shape_if_schema(variant) for variant in variants]} if variants else {}
def shape_claude_output_schema(schema: Mapping[str, object]) -> dict[str, object]:
"""Return a new schema that Claude's structured-output API accepts. Idempotent."""
drops_type: Final = _enum_conflicts_with_declared_type(schema)
declared_type: Final = None if drops_type else schema.get("type")
object_fields: Final = {} if drops_type else _object_fields(declared_type, schema)
unsupported_format: Final = _unsupported_format(schema, declared_type)
notes: Final = (
*_constraint_notes(schema),
*(() if unsupported_format is None else (f"format: {unsupported_format}",)),
)
dropped: Final = frozenset(
(*_dropped_constraints(schema), "anyOf", "oneOf")
+ (("type",) if drops_type else ())
+ (("additionalProperties",) if object_fields else ())
+ (("description",) if notes else ())
+ (("format",) if unsupported_format is not None else ())
)
kept: Final = {key: _shape_nested(key, value) for key, value in schema.items() if key not in dropped}
return {**_description_field(schema.get("description"), notes), **kept, **_any_of_field(schema), **object_fields}
def shape_claude_output_format(output_format: Mapping[str, object]) -> dict[str, object]:
"""Shape the ``schema`` inside an Anthropic ``output_format`` block, leaving the rest untouched."""
schema: Final = _as_schema(output_format.get("schema"))
if schema is None:
return dict(output_format)
return {**output_format, "schema": shape_claude_output_schema(schema)}

View file

@ -68,6 +68,7 @@ from litellm.llms.bedrock.common_utils import (
bedrock_native_output_is_opt_in,
bedrock_supports_tool_search,
deployment_model_info,
json_object_or_none,
requests_output_config_format,
)
from litellm.llms.bedrock.request_metadata import (
@ -970,17 +971,20 @@ class AmazonConverseConfig(BaseConfig):
def _native_output_schema(
self,
model: str,
json_schema: Mapping[str, object],
json_schema: object,
thinking_requested: bool,
model_info: Mapping[str, object] | None,
) -> Mapping[str, object] | None:
) -> object | None:
if not self._supports_native_structured_outputs(
model, self.custom_llm_provider, thinking_requested, model_info
):
return None
schema: Final = json_object_or_none(json_schema)
if schema is None:
return json_schema
if BedrockModelInfo.get_base_model(model).startswith("anthropic"):
return bedrock_cleaned_output_schema(model, json_schema, self.custom_llm_provider or "bedrock_converse")
return json_schema
return bedrock_cleaned_output_schema(model, schema, self.custom_llm_provider or "bedrock_converse")
return schema
def _output_config_for_anthropic_format(
self, model: str, output_config_format: Mapping[str, object], model_info: Mapping[str, object] | None
@ -999,7 +1003,7 @@ class AmazonConverseConfig(BaseConfig):
@staticmethod
def _create_output_config_for_response_format(
json_schema: dict | None = None,
json_schema: object | None = None,
name: str | None = None,
description: str | None = None,
) -> "OutputConfigBlock":
@ -1022,9 +1026,12 @@ class AmazonConverseConfig(BaseConfig):
}
}
"""
if json_schema is not None:
json_schema = AmazonConverseConfig._add_additional_properties_to_schema(json_schema)
schema_str: Final = json.dumps(json_schema) if json_schema is not None else "{}"
closed_schema: Final = (
AmazonConverseConfig._add_additional_properties_to_schema(json_schema)
if isinstance(json_schema, dict)
else json_schema
)
schema_str: Final = json.dumps(closed_schema) if closed_schema is not None else "{}"
json_schema_def: Final[JsonSchemaDefinition] = {"schema": schema_str}
if name is not None:
json_schema_def["name"] = name
@ -1322,7 +1329,7 @@ class AmazonConverseConfig(BaseConfig):
# Requires an explicit schema — json_object with no schema falls through
# to the tool-call path below.
output_config: Final = self._create_output_config_for_response_format(
json_schema=dict(native_schema),
json_schema=dict(native_schema) if isinstance(native_schema, Mapping) else native_schema,
name=name,
description=description,
)

View file

@ -2,7 +2,7 @@ from __future__ import annotations
from typing import Final
from pydantic import TypeAdapter
from pydantic import BaseModel, ConfigDict, Field, TypeAdapter
SENTIMENT_PROMPT: Final = "Classify the sentiment of this review: 'The battery died after two days.'"
SENTIMENT_LABELS: Final = frozenset({"positive", "negative", "neutral"})
@ -15,10 +15,36 @@ SENTIMENT_OUTPUT_FORMAT: Final[dict[str, object]] = {
"additionalProperties": False,
},
}
CONSTRAINED_SENTIMENT_OUTPUT_FORMAT: Final[dict[str, object]] = {
"type": "json_schema",
"schema": {
"type": "object",
"properties": {
"sentiment": {"type": "string", "enum": sorted(SENTIMENT_LABELS)},
"confidence": {"type": "number", "minimum": 0, "maximum": 1},
"reasons": {"type": "array", "items": {"type": "string"}, "maxItems": 3},
},
"required": ["sentiment", "confidence", "reasons"],
"additionalProperties": False,
},
}
_SENTIMENT_JSON: Final = TypeAdapter(dict[str, str])
class _ConstrainedSentiment(BaseModel):
model_config = ConfigDict(frozen=True, extra="forbid")
sentiment: str
confidence: float = Field(ge=0, le=1)
reasons: tuple[str, ...] = Field(max_length=3)
def assert_sentiment_json(text: str) -> None:
parsed = _SENTIMENT_JSON.validate_json(text)
assert set(parsed) == {"sentiment"}, f"output_format schema not enforced, extra or missing keys: {parsed}"
assert parsed["sentiment"] in SENTIMENT_LABELS, f"sentiment outside the schema enum: {parsed}"
def assert_constrained_sentiment_json(text: str) -> None:
parsed = _ConstrainedSentiment.model_validate_json(text)
assert parsed.sentiment in SENTIMENT_LABELS, f"sentiment outside the schema enum: {parsed}"

View file

@ -10,7 +10,13 @@ from lifecycle import ResourceManager
from models import LiteLLMParamsBody
from proxy_client import ProxyClient
from sdk_clients import NO_PROXY_CACHE, SdkClients
from structured_output import SENTIMENT_OUTPUT_FORMAT, SENTIMENT_PROMPT, assert_sentiment_json
from structured_output import (
CONSTRAINED_SENTIMENT_OUTPUT_FORMAT,
SENTIMENT_OUTPUT_FORMAT,
SENTIMENT_PROMPT,
assert_constrained_sentiment_json,
assert_sentiment_json,
)
pytestmark = pytest.mark.e2e
@ -136,6 +142,32 @@ class TestBedrockMessages:
assert len(texts) == len(message.content), f"structured output came back as non-text blocks: {message!r}"
assert_sentiment_json("".join(texts))
@meta(
Subject(
domain=Domain.LLM_TRANSLATION,
route=Route.MESSAGES,
providers=(Provider.BEDROCK,),
models=(CONVERSE_CLAUDE_BACKEND,),
capabilities=(Capability.RESPONSE_SCHEMA,),
mode=Mode.NONSTREAM,
)
)
def test_converse_output_format_accepts_constraint_keywords(
self, proxy: ProxyClient, resources: ResourceManager, sdk: SdkClients
) -> None:
model = _register(proxy, resources, CONVERSE_CLAUDE_BACKEND)
client = sdk.anthropic(resources.key())
message = client.messages.create(
model=model,
max_tokens=256,
messages=[{"role": "user", "content": SENTIMENT_PROMPT}],
extra_body={**NO_PROXY_CACHE, "output_format": CONSTRAINED_SENTIMENT_OUTPUT_FORMAT},
)
texts = tuple(block.text for block in message.content if isinstance(block, TextBlock))
assert len(texts) == len(message.content), f"structured output came back as non-text blocks: {message!r}"
assert_constrained_sentiment_json("".join(texts))
@pytest.mark.covers("llm.messages.bedrock_converse.basic.stream.works")
@meta(
Subject(

View file

@ -88,6 +88,15 @@ _LIMITS_SCHEMA: Final[dict[str, JsonValue]] = {
"required": ["tier", "summary", "tags", "owner", "backup"],
"$defs": {"Person": {"type": "object", "properties": {"name": {"type": "string"}}, "required": ["name"]}},
}
_UNLISTED_FORMAT_SCHEMA: Final[dict[str, JsonValue]] = {
"type": "object",
"properties": {
"id": {"type": "string", "format": "int64"},
"meta": {"properties": {"a": {"type": "string"}}, "required": ["a"]},
},
"required": ["id", "meta"],
"additionalProperties": False,
}
_OPEN_COUNTS: Final[dict[str, JsonValue]] = {"type": "object", "additionalProperties": {"type": "integer"}}
_DICT_SCHEMA: Final[dict[str, JsonValue]] = {
"type": "object",
@ -754,6 +763,35 @@ def test_native_schema_reaches_bedrock_with_limits_in_descriptions_and_every_obj
assert _JSON_TOOL not in _tools(body, route == "invoke"), body
@pytest.mark.parametrize("route", ["converse", "invoke"])
def test_unlisted_string_format_reaches_bedrock_as_a_description_note_with_the_untyped_node_closed(
gateway: Gateway, route: str
) -> None:
"""Bedrock Claude rejects a string ``format`` outside Claude's list and a node with no ``type``, so the
proxy notes the format in the description and types the node, instead of dropping to the json tool."""
marker, marker_hex = _marker()
with wire_server(_bedrock) as wire, gateway.scenario() as scenario:
model: Final = _deployment(scenario, wire, route, _SONNET)
body: Final = _chat_body(model, marker, response_format=_response_format(_UNLISTED_FORMAT_SCHEMA))
assert _content_json(_chat_message(gateway.request("POST", "/v1/chat/completions", body))) == _payload(
marker_hex
)
_, sent = _one_call(wire, marker_hex)
schema: Final = _native_schema(sent, route == "invoke")
assert schema is not None, sent
assert _bedrock_schema_fault(schema) is None, schema
assert object_value(schema["properties"]) == {
"id": {"type": "string", "description": "Note: format: int64."},
"meta": {
"type": "object",
"properties": {"a": {"type": "string"}},
"required": ["a"],
"additionalProperties": False,
},
}, schema
assert _JSON_TOOL not in _tools(sent, route == "invoke"), sent
@pytest.mark.parametrize("route", ["converse", "invoke"])
def test_open_object_schema_takes_the_json_tool_on_a_native_model_and_keeps_the_dict_open(
gateway: Gateway, route: str

View file

@ -1689,6 +1689,53 @@ def test_vertex_chat_native_schema_keeps_min_items_one_and_closes_a_nullable_obj
assert "tools" not in sent.body, sent.body
def test_anthropic_chat_native_schema_notes_an_unlisted_string_format_and_types_an_untyped_node(
gateway: Gateway,
) -> None:
"""Anthropic 400s on a string ``format`` outside Claude's list ("format 'int64' is not supported") and on
a node with properties but no ``type`` ("Schema type is missing"), so the proxy rewrites both."""
marker, marker_hex = _marker("native")
schema: Final[dict[str, JsonValue]] = {
"type": "object",
"properties": {
"id": {"type": "string", "format": "int64"},
"meta": {"properties": {"a": {"type": "string"}}, "required": ["a"]},
},
"required": ["id", "meta"],
"additionalProperties": False,
}
expected: Final[dict[str, JsonValue]] = {
**schema,
"properties": {
"id": {"description": "Note: format: int64.", "type": "string"},
"meta": {
"properties": {"a": {"type": "string"}},
"required": ["a"],
"type": "object",
"additionalProperties": False,
},
},
}
response_format: Final[dict[str, JsonValue]] = {
"type": "json_schema",
"json_schema": {"name": "record", "schema": schema},
}
with wire_server(_peer) as wire, gateway.scenario() as scenario:
model: Final = _native_deployment(gateway, scenario, wire.url, "anthropic", _NATIVE_MODEL)
response: Final = gateway.request(
"POST", "/v1/chat/completions", _chat_body(model, marker, response_format=response_format)
)
assert _chat_content(response) == _payload(marker_hex), response.text
sent: Final = _one_delivery(wire, marker_hex)
assert _native_format(sent.body) == {"type": "json_schema", "schema": expected}, sent.body
assert "tools" not in sent.body, sent.body
def _native_format(body: Mapping[str, JsonValue]) -> JsonValue:
output_format: Final = body.get("output_format")
return output_format if output_format is not None else object_value(body["output_config"])["format"]
@pytest.mark.parametrize("stream", [False, True], ids=["non_stream", "stream"])
def test_vertex_messages_folds_output_format_into_output_config(gateway: Gateway, stream: bool) -> None:
marker, marker_hex = _marker("native")

View file

@ -0,0 +1,106 @@
"""Tests for the shared Claude structured-output schema shaper."""
import copy
import pytest
from litellm.llms.anthropic.output_schema import (
shape_claude_output_format,
shape_claude_output_schema,
)
_MESSY_SCHEMA = {
"type": "object",
"description": "A record",
"properties": {
"tags": {"type": "array", "items": {"type": "string"}, "maxItems": 3, "uniqueItems": True},
"score": {"type": "number", "minimum": 0, "exclusiveMaximum": 1},
"id": {"type": "string", "format": "int64", "minLength": 1},
"meta": {"type": ["object", "null"], "properties": {"a": {"type": "string"}}},
"kind": {"oneOf": [{"type": "string"}, {"type": "integer"}]},
"labels": {"type": "object", "additionalProperties": {"type": "string"}},
"nested": {"properties": {"b": {"type": "boolean"}}},
},
"required": ["tags", "score", "id"],
"additionalProperties": True,
}
def test_shaping_is_idempotent():
once = shape_claude_output_schema(_MESSY_SCHEMA)
assert shape_claude_output_schema(once) == once
def test_shaping_does_not_mutate_the_input():
before = copy.deepcopy(_MESSY_SCHEMA)
shape_claude_output_schema(_MESSY_SCHEMA)
assert _MESSY_SCHEMA == before
# Claude-supported formats per the anthropic SDK ``lib/_parse/_transform.py`` SupportedStringFormats, checked 2026-10-13
@pytest.mark.parametrize("fmt", ["date-time", "date", "email", "uri", "uuid"])
def test_supported_string_format_is_kept(fmt: str):
assert shape_claude_output_schema({"type": "string", "format": fmt}) == {"type": "string", "format": fmt}
_BOUNDED = {"type": "number", "minimum": 0}
_BOUNDED_SHAPED = {"type": "number", "description": "Note: minimum value: 0."}
@pytest.mark.parametrize(
("schema", "expected"),
[
({"$defs": {"X": _BOUNDED}}, {"$defs": {"X": _BOUNDED_SHAPED}}),
({"definitions": {"X": _BOUNDED}}, {"definitions": {"X": _BOUNDED_SHAPED}}),
({"allOf": [_BOUNDED]}, {"allOf": [_BOUNDED_SHAPED]}),
],
ids=["$defs", "definitions", "allOf"],
)
def test_shapes_schemas_nested_under_definitions_and_all_of(schema: dict[str, object], expected: dict[str, object]):
assert shape_claude_output_schema(schema) == expected
@pytest.mark.parametrize("composition", ["anyOf", "oneOf", "allOf", "$ref"])
def test_untyped_node_with_properties_and_composition_is_not_forced_to_object(composition: str):
value = "#/$defs/X" if composition == "$ref" else [{"type": "object", "properties": {}}]
result = shape_claude_output_schema({"properties": {"a": {"type": "string"}}, composition: value})
assert "type" not in result
assert "additionalProperties" not in result
def test_output_format_block_shapes_only_its_schema():
block = {
"type": "json_schema",
"schema": {"type": "object", "properties": {"n": {"type": "integer", "minimum": 1}}},
}
result = shape_claude_output_format(block)
assert result == {
"type": "json_schema",
"schema": {
"type": "object",
"properties": {"n": {"type": "integer", "description": "Note: minimum value: 1."}},
"additionalProperties": False,
},
}
assert block["schema"]["properties"]["n"] == {"type": "integer", "minimum": 1}
def test_output_format_block_without_schema_is_returned_unchanged():
assert shape_claude_output_format({"type": "json_schema"}) == {"type": "json_schema"}
def test_nullable_object_enum_keeps_its_type_dropped_instead_of_forcing_object() -> None:
"""``enum: [null]`` on an ``["object", "null"]`` node conflicts with the declared type, so the type
is dropped. Re-adding ``type: object`` would make the node impossible to satisfy."""
shaped = shape_claude_output_schema(
{"type": ["object", "null"], "properties": {"a": {"type": "string"}}, "enum": [None]}
)
assert shaped == {"properties": {"a": {"type": "string"}}, "enum": [None]}
assert shape_claude_output_schema(shaped) == shaped

View file

@ -526,3 +526,46 @@ class TestFilterAnthropicOutputSchema:
result = AnthropicConfig.filter_anthropic_output_schema(schema)
assert "type" not in result["properties"]["rows"]["items"]["properties"]["c"]
def test_closes_nullable_object(self):
"""``type: ["object", "null"]`` is still an object and must be closed too,
otherwise the API answers "'additionalProperties' must be explicitly set
to false"."""
schema = {
"type": "object",
"properties": {"meta": {"type": ["object", "null"], "properties": {"a": {"type": "string"}}}},
}
result = AnthropicConfig.filter_anthropic_output_schema(schema)
assert result["properties"]["meta"]["additionalProperties"] is False
assert result["properties"]["meta"]["type"] == ["object", "null"]
def test_closes_untyped_node_that_declares_properties(self):
"""A node with ``properties`` but no ``type`` is an object by structure.
The API rejects it with "Schema type is missing", so it is typed and closed."""
schema = {
"type": "object",
"properties": {"meta": {"properties": {"a": {"type": "string"}}, "required": ["a"]}},
}
result = AnthropicConfig.filter_anthropic_output_schema(schema)
assert result["properties"]["meta"] == {
"properties": {"a": {"type": "string"}},
"required": ["a"],
"type": "object",
"additionalProperties": False,
}
def test_moves_unsupported_string_format_into_description(self):
"""A ``format`` outside the supported set 400s ("format 'int64' is not
supported"), so it is dropped and noted like any other constraint."""
schema = {
"type": "object",
"properties": {"id": {"type": "string", "format": "int64", "description": "row id"}},
}
result = AnthropicConfig.filter_anthropic_output_schema(schema)
assert result["properties"]["id"] == {"type": "string", "description": "row id Note: format: int64."}

View file

@ -5157,9 +5157,8 @@ def test_native_output_schema_drops_keywords_bedrock_rejects_and_closes_objects(
(ROOT_REF_SCHEMA, "$ref"),
(OPEN_OBJECT_SCHEMA, "additionalProperties"),
(LOOKAROUND_PATTERN_SCHEMA, "pattern"),
(UNKNOWN_FORMAT_SCHEMA, "format"),
],
ids=["recursive", "root-ref", "open-object", "lookaround-pattern", "unlisted-format"],
ids=["recursive", "root-ref", "open-object", "lookaround-pattern"],
)
def test_schema_native_output_cannot_hold_keeps_the_tool_path_on_a_native_profile(
set_native_structured_output, schema, kept_keyword, native_key
@ -5175,6 +5174,22 @@ def test_schema_native_output_cannot_hold_keeps_the_tool_path_on_a_native_profil
assert kept_keyword in _schema_keys(tool_spec["inputSchema"]["json"])
@pytest.mark.parametrize("native_key", ["legacy", "bedrock"])
def test_unlisted_string_format_moves_into_the_description_and_keeps_native_output(
set_native_structured_output, native_key
):
"""Claude's grammar rejects a string ``format`` outside its list ("format
'x-litellm-unlisted-format' is not supported"), so the shaper drops it and
notes it, the way it does for other constraints, instead of leaving native output."""
model: Final = "us.anthropic.claude-opus-4-8"
set_native_structured_output(model, native_key)
request: Final = _converse_request_for_schema(model, UNKNOWN_FORMAT_SCHEMA)
sent: Final = json.loads(request["outputConfig"]["textFormat"]["structure"]["jsonSchema"]["schema"])
assert sent["properties"]["blob"] == {"type": "string", "description": "Note: format: x-litellm-unlisted-format."}
def _shared_defs_schema(defs_key: str) -> Mapping[str, object]:
party_ref: Final = {"$ref": f"#/{defs_key}/Party"}
return {
@ -5784,6 +5799,81 @@ def test_output_config_applies_additional_properties():
assert parsed["properties"]["nested"]["additionalProperties"] is False
_SCHEMA_CLAUDE_REJECTS = {
"type": "object",
"properties": {
"score": {"type": "number", "minimum": 0, "maximum": 1},
"tags": {"type": "array", "items": {"type": "string"}, "maxItems": 3},
"meta": {"type": ["object", "null"], "properties": {"a": {"type": "string"}}},
},
"required": ["score"],
}
def _converse_schema_json(model: str, schema: object) -> str:
response_format = {"type": "json_schema", "json_schema": {"name": "Score", "schema": schema}}
result = AmazonConverseConfig()._translate_response_format_param(
value=response_format,
model=model,
optional_params={},
non_default_params={"response_format": response_format},
is_thinking_enabled=False,
)
return result["outputConfig"]["textFormat"]["structure"]["jsonSchema"]["schema"]
def _converse_schema_for(model: str) -> dict:
return json.loads(_converse_schema_json(model, _SCHEMA_CLAUDE_REJECTS))
def test_claude_response_format_schema_shaped_like_anthropic_path(local_model_cost_map):
"""Bedrock relays a Claude schema to Claude's grammar compiler, which 400s on
keywords it cannot enforce ("For 'array' type, property 'maxItems' is not
supported") and on any object that is not closed, so Converse shapes it like
the direct Anthropic path."""
assert _converse_schema_for("us.anthropic.claude-sonnet-4-6") == {
"type": "object",
"properties": {
"score": {"type": "number", "description": "Note: minimum value: 0, maximum value: 1."},
"tags": {"type": "array", "items": {"type": "string"}, "description": "Note: maximum number of items: 3."},
"meta": {
"type": ["object", "null"],
"properties": {"a": {"type": "string"}},
"additionalProperties": False,
},
},
"required": ["score"],
"additionalProperties": False,
}
def test_non_claude_response_format_schema_keeps_constraints(local_model_cost_map):
"""Non-Claude Bedrock models enforce these keywords, so only the missing
``additionalProperties`` is filled in."""
assert _converse_schema_for("qwen.qwen3-32b-v1:0") == {
"type": "object",
"properties": {
"score": {"type": "number", "minimum": 0, "maximum": 1},
"tags": {"type": "array", "items": {"type": "string"}, "maxItems": 3},
"meta": {
"type": ["object", "null"],
"properties": {"a": {"type": "string"}},
"additionalProperties": False,
},
},
"required": ["score"],
"additionalProperties": False,
}
@pytest.mark.parametrize("model", ["us.anthropic.claude-sonnet-4-6", "qwen.qwen3-32b-v1:0"])
@pytest.mark.parametrize("schema", [True, "not a schema"])
def test_non_object_response_format_schema_is_forwarded_unchanged(local_model_cost_map, model: str, schema: object):
"""A schema that is not an object reaches Bedrock as sent, so the caller gets
Bedrock's 400 instead of a 500 from the proxy."""
assert json.loads(_converse_schema_json(model, schema)) == schema
_TOOL_PARAM = [
{
"type": "function",

View file

@ -3376,7 +3376,7 @@ def test_bedrock_messages_legacy_output_format_wins_over_output_config_format(lo
}
newer_format = {
"type": "json_schema",
"schema": {"type": "object", "properties": {"newer_field": {"type": "string"}}},
"schema": {"type": "object", "properties": {"newer_field": {"type": "string"}}, "additionalProperties": False},
}
result = cfg.transform_anthropic_messages_request(

View file

@ -689,6 +689,75 @@ def test_apply_structured_output_prefers_legacy_output_format(local_model_cost_m
assert "output_format" not in body
_SCHEMA_WITH_REJECTED_KEYWORDS = {
"type": "object",
"properties": {
"tags": {"type": "array", "items": {"type": "string"}, "maxItems": 3},
"meta": {"type": ["object", "null"], "properties": {"a": {"type": "string"}}},
},
"required": ["tags"],
}
def test_apply_structured_output_shapes_schema_for_native_models(local_model_cost_map):
"""Bedrock relays the schema to Claude's grammar compiler, which 400s on
keywords it cannot enforce and on open objects, so the Invoke path shapes
the schema like the direct Anthropic path before forwarding it."""
from litellm.llms.bedrock.common_utils import apply_bedrock_invoke_structured_output
body = {
"messages": [{"role": "user", "content": "hi"}],
"output_format": {"type": "json_schema", "schema": _SCHEMA_WITH_REJECTED_KEYWORDS},
}
apply_bedrock_invoke_structured_output(
model="us.anthropic.claude-sonnet-4-5-20250929-v1:0",
request_body=body,
)
assert body["output_config"]["format"] == {
"type": "json_schema",
"schema": {
"type": "object",
"properties": {
"tags": {
"type": "array",
"items": {"type": "string"},
"description": "Note: maximum number of items: 3.",
},
"meta": {
"type": ["object", "null"],
"properties": {"a": {"type": "string"}},
"additionalProperties": False,
},
},
"required": ["tags"],
"additionalProperties": False,
},
}
def test_apply_structured_output_inlines_raw_schema_for_other_models(local_model_cost_map):
"""The prompt-engineered fallback is text the model reads, not a grammar, so
the schema is inlined untouched."""
import json
from litellm.llms.bedrock.common_utils import apply_bedrock_invoke_structured_output
body = {
"messages": [{"role": "user", "content": "hi"}],
"output_format": {"type": "json_schema", "schema": _SCHEMA_WITH_REJECTED_KEYWORDS},
}
apply_bedrock_invoke_structured_output(
model="anthropic.claude-3-haiku-20240307-v1:0",
request_body=body,
)
assert "output_config" not in body
assert json.loads(body["messages"][-1]["content"][-1]["text"]) == _SCHEMA_WITH_REJECTED_KEYWORDS
def test_sign_aws_request_assumes_role_with_external_id(monkeypatch):
"""A trust policy requiring sts:ExternalId must be satisfied when signing batch API requests."""
import datetime