Structured Output fail with Claude Sonnet and DeepSeek providers

[sebastianherreramonterrosa]

Structured Output have problems parsing the answer when the provider is Claude and Deepseek. It is working with models of openai, google, xai.

Example code

from agents import Agent, OpenAIChatCompletionsModel, Runner, set_tracing_disabled
from openai import AsyncOpenAI
from pydantic import BaseModel


set_tracing_disabled(disabled=True)

## Claude Provider
claude_api_key = "..."
provider = AsyncOpenAI(api_key=claude_api_key, base_url="https://api.anthropic.com/v1/")
model = OpenAIChatCompletionsModel(model="claude-sonnet-4-5", openai_client=provider)

## Deepseek Provider
deepseek_api_key = "..."
provider = AsyncOpenAI(api_key=deepseek_api_key, base_url="https://api.deepseek.com")
model = OpenAIChatCompletionsModel(model="deepseek-reasoner", openai_client=provider)

class CalendarEvent(BaseModel):
    name: str
    date: str
    participants: list[str]


agent = Agent(
    name="Calendar extractor",
    instructions="Extract calendar events from text and return them in structured JSON format.",
    output_type=CalendarEvent,
    model=model,
)


input_text = """
Let's schedule a team meeting called 'Product Kickoff' on October 15th, 2025.
Participants will be Alice, Bob, and Charlie.
"""


result = Runner.run_sync(agent, input_text)
print(result.final_output)


result.final_output.model_dump()

Error

Claude Error:

ValidationError: 1 validation error for CalendarEvent
  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='```json\n{\n  "events": ...  ]\n    }\n  ]\n}\n```', input_type=str]
    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid
...
  ]
}
``` for TypeAdapter(CalendarEvent); 1 validation error for CalendarEvent
  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='```json\n{\n  "events": ...  ]\n    }\n  ]\n}\n```', input_type=str]
    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid

Deepseek Error:

---------------------------------------------------------------------------
BadRequestError                           Traceback (most recent call last)
Cell In[14], [line 1](vscode-notebook-cell:?execution_count=14&line=1)
----> [1](vscode-notebook-cell:?execution_count=14&line=1) result = Runner.run_sync(agent, input_text)
      2 print(result.final_output)

File c:\Users\sejohermo\AppData\Local\Programs\Python\Python312\Lib\site-packages\agents\run.py:324, in Runner.run_sync(cls, starting_agent, input, context, max_turns, hooks, run_config, previous_response_id, conversation_id, session)
    293 """Run a workflow synchronously, starting at the given agent. Note that this just wraps the
    294 `run` method, so it will not work if there's already an event loop (e.g. inside an async
    295 function, or in a Jupyter notebook or async context like FastAPI). For those cases, use
   (...)
    321     agent. Agents may perform handoffs, so we don't know the specific type of the output.
    322 """
    323 runner = DEFAULT_AGENT_RUNNER
--> [324](file:///C:/Users/sejohermo/AppData/Local/Programs/Python/Python312/Lib/site-packages/agents/run.py:324) return runner.run_sync(
    325     starting_agent,
    326     input,
    327     context=context,
    328     max_turns=max_turns,
    329     hooks=hooks,
    330     run_config=run_config,
    331     previous_response_id=previous_response_id,
    332     conversation_id=conversation_id,
    333     session=session,
    334 )
...
-> [1594](file:///C:/Users/sejohermo/AppData/Local/Programs/Python/Python312/Lib/site-packages/openai/_base_client.py:1594)         raise self._make_status_error_from_response(err.response) from None
   1596     break
   1598 assert response is not None, "could not resolve response (should never happen)"

BadRequestError: Error code: 400 - {'error': {'message': 'This response_format type is unavailable now', 'type': 'invalid_request_error', 'param': None, 'code': 'invalid_request_error'}}

Debug information

• Agents SDK version: 0.2.11
• Python version: 3.12.7

[ihower]

@sebastianherreramonterrosa I think this is not an OpenAI Agents SDK bug. The root cause is that both Claude and DeepSeek APIs don’t support structured outputs. Their API endpoints don’t support passing a JSON schema to define the output structure.

You can achieve the same structured output result by using function calling instead. that is, by forcing the model to call a fake function and then retrieving the structured arguments from that call. Here’s a modified version of your example that works without relying on output_type:

from agents import Agent, OpenAIChatCompletionsModel, Runner, set_tracing_disabled, FunctionTool, ModelSettings, RunContextWrapper
from agents.agent import StopAtTools

from openai import AsyncOpenAI
from pydantic import BaseModel

set_tracing_disabled(disabled=True)

## Claude Provider
claude_api_key = '...'
provider = AsyncOpenAI(api_key=claude_api_key, base_url="https://api.anthropic.com/v1/")
model = OpenAIChatCompletionsModel(model="claude-sonnet-4-5", openai_client=provider)

class CalendarEvent(BaseModel):
    name: str
    date: str
    participants: list[str]


input_text = """
Let's schedule a team meeting called 'Product Kickoff' on October 15th, 2025.
Participants will be Alice, Bob, and Charlie.
"""

async def extract_calendar_event(ctx: RunContextWrapper, args: str) -> str:
    parsed = CalendarEvent.model_validate_json(args)
    print(f"Extracting calendar event: {parsed.name}, {parsed.date}, {parsed.participants}")
    return parsed

tool = FunctionTool(
    name="extract_calendar_event",
    description="Extracts calendar events from text",
    params_json_schema=CalendarEvent.model_json_schema(),
    on_invoke_tool=extract_calendar_event,
)

agent = Agent(
    name="Calendar extractor",
    instructions="Extract calendar events from text and return them in structured JSON format.",
    tools=[tool],
    model=model,
    tool_use_behavior=StopAtTools(stop_at_tool_names=["extract_calendar_event"]),
    model_settings=ModelSettings( tool_choice="required" )
)


result = Runner.run_sync(agent, input_text)
print(result.final_output)

Alternatively, a simpler workaround is to use LiteLLM. They’ve added a workaround BerriAI/litellm#6748 for Claude that automatically wraps structured outputs as function calls and then converts them back.

Example:

from agents import Agent, OpenAIChatCompletionsModel, Runner, set_tracing_disabled

from openai import AsyncOpenAI
from pydantic import BaseModel

from agents.extensions.models.litellm_model import LitellmModel


set_tracing_disabled(disabled=True)

class CalendarEvent(BaseModel):
    name: str
    date: str
    participants: list[str]


agent = Agent(
    name="Calendar extractor",
    instructions="Extract calendar events from text and return them in structured JSON format.",
    output_type=CalendarEvent,
    model=LitellmModel(model="anthropic/claude-sonnet-4-5", api_key="...")
)


input_text = """
Let's schedule a team meeting called 'Product Kickoff' on October 15th, 2025.
Participants will be Alice, Bob, and Charlie.
"""


result = Runner.run_sync(agent, input_text)
print(result.final_output)

But this LiteLLM workaround is currently implemented only for Claude, and not for DeepSeek.

[sebastianherreramonterrosa]

@ihower Thanks for the response — both solutions work perfectly! I wasn’t aware of them before.

My suggestion is for the framework to include a Structured Output layer for providers and models that don’t natively support this feature. The first solution you shared could actually serve as a great foundation for such an implementation.

I opened this feature request because in Pydantic AI, structured output works seamlessly with any provider, and it would be amazing to have similar support in the OAI Agents SDK.

For reference, one of the models that doesn’t currently support this is gpt-oss-120b.

[ihower]

@sebastianherreramonterrosa Well, the OpenAI Agents SDK’s current approach is to rely on LiteLLM as the adapter layer for non-OpenAI models, just like Google’s ADK also depends on LiteLLM for non-Gemini models.

I think this is a second-best solution because it involves two layers of conversion (the provider's format → ChatML format → Responses API format), which makes it somewhat fragile and less reliable overall. This SDK essentially delegates the adapter responsibility to LiteLLM. So if you want to improve compatibility across different providers, the right place to do it often is in LiteLLM, not in the OpenAI Agents SDK itself.

In contrast, frameworks like Pydantic AI or LangChain do not rely on LiteLLM. They each integrate directly with every provider’s SDK, handling the conversion only once within the framework. That’s a more controllable design if the framework’s core team have enough engineering resources to maintain it.

Just my two cents.

[devv-shayan]

@ihower thanks for explanation , can we use structured output and call tools at the same time, like this

agent = Agent(
    name="Calendar extractor",
    instructions="Extract calendar events from text and return them in structured JSON format.",
    tools=[tool]
    output_type=CalendarEvent,
    model=gemini model using litellm or using gemini directly
)

as in ai-studio we can't use search tool or any other tool if we enable structured output

[seratch]

My understanding is that you cannot use tools and structured outputs via this Agents SDK + LiteLLM: #1575 If there is a way to support the use case just by updating our LiteLLM adapter, we may consider enhancing the module for it.

[devv-shayan]

agno-agi/agno#2225 (comment)

this can be a fix if we add parser for support like this ,just like how agno did it

[ihower]

@devv-shayan Whether structured output and tool calling can be used together really depends on the model provider’s native support. OpenAI models can handle both at the same time, but many other providers currently cannot.

Some frameworks introduce hacks to make this work. For example, I shared an example in #1778 (comment)
showing how Google’s ADK handles this, and how you can achieve a similar feature with the OpenAI Agents SDK.

Agno’s “Parser Model” feature seems to just use a chaining prompt to convert the final text into JSON, so it’s not something that really needs to be built into the SDK. You can easily implement that logic yourself.