---
type: "post"
id: "pydantic-ai-v2-65-0-adds-refusal-aware-773ea1"
slug: "pydantic-ai-v2-65-0-adds-refusal-aware-773ea1"
title: "Pydantic AI v2.65.0 adds refusal-aware fallback behavior"
description: "Pydantic AI v2.65.0 changes model fallback so an agent can move to the next configured model when one refuses, and lets ContentFilterError match refusals through fallback_on."
retrieval_nugget: "Pydantic AI v2.65.0 changes model fallback so an agent can move to the next configured model when one refuses, and lets ContentFilterError match refusals through fallbackon. For teams using the framework, this makes refusal handling an explicit part of multi-model recovery rather than a dead end in a fallback chain."
published_at: "2026-11-16"
updated_at: "2026-11-16"
record_date: "2026-11-16"
date_kind: "published_at"
topics: ["model-routing"]
entities: ["Pydantic AI","OpenAI Responses API","OpenRouter","Temporal"]
related_patterns: ["harness-architecture-outlives-model-choice"]
novelty_label: "new_fact"
what_changed: null
prior_refs: ["https://newruntime.com/posts/pydantic-ai-v2-64-0-adds-a-modelfallback-2b5ea5/"]
source_url: "https://github.com/pydantic/pydantic-ai/releases/tag/v2.65.0"
source_urls: ["https://github.com/pydantic/pydantic-ai/releases/tag/v2.65.0"]
schema_version: "newruntime-agent-readable-v0.2"
stable_id: "post:pydantic-ai-v2-65-0-adds-refusal-aware-773ea1"
status: "published"
visuals: []
editor: {"role":"editor","name":"Andrey Reshetnikov","profile":"https://newruntime.com/owner-profile.md","profile_json":"https://newruntime.com/owner-profile.json","same_as":["https://www.linkedin.com/in/reshetnikov1/","https://t.me/lapetuse"]}
routes: {"html":"https://newruntime.com/posts/pydantic-ai-v2-65-0-adds-refusal-aware-773ea1/","markdown":"https://newruntime.com/posts/pydantic-ai-v2-65-0-adds-refusal-aware-773ea1.md","json":"https://newruntime.com/posts/pydantic-ai-v2-65-0-adds-refusal-aware-773ea1.json"}
markdown_url: "https://newruntime.com/posts/pydantic-ai-v2-65-0-adds-refusal-aware-773ea1.md"
---

# Pydantic AI v2.65.0 adds refusal-aware fallback behavior

## Retrieval answer

Pydantic AI v2.65.0 changes model fallback so an agent can move to the next configured model when one refuses, and lets ContentFilterError match refusals through fallbackon. For teams using the framework, this makes refusal handling an explicit part of multi-model recovery rather than a dead end in a fallback chain.

## Summary

Pydantic AI v2.65.0 changes model fallback so an agent can move to the next configured model when one refuses, and lets `ContentFilterError` match refusals through `fallback_on`. For teams using the framework, this makes refusal handling an explicit part of multi-model recovery rather than a dead end in a fallback chain.

## What happened

Pydantic AI’s GitHub release page lists v2.65.0, dated 2026-11-02. Among its compatibility notes and features, the release says `ModelFallback` now falls back to the next model when a model refuses. It also says `ContentFilterError` can match refusals in the `fallback_on` setting. The release page does not give a code example or describe the exact configuration syntax beyond naming that setting.

In practical terms, this separates a refusal from the narrower set of failures commonly treated as transient infrastructure problems. A team that has configured several models in a fallback chain can now make a refusal eligible for the same next-model transition. The release does not say that all refusals should be retried, nor does it prescribe a default policy for deciding which ones should end a request. It announces framework behavior that an application must still configure and govern.

The behavior arrives with several other additions. Pydantic AI adds a WebSocket transport for OpenAI Responses and a `ConversationStore`, which keeps a conversation as a log of messages stored once. It also adds `Conversation.revision`, intended to catch conflicting saves. These changes concern distinct layers of an agent application: a transport option for a provider API and a mechanism for managing persistence conflicts in stored conversations.

The release adds support for 12-hour prompt-cache retention on the OpenAI Responses API for GPT-5.6 and later. It also adds native mid-conversation system prompts on OpenRouter OpenAI routes and Claude models that support them. For Anthropic web tools, Pydantic AI adds `anthropic_web_tools_allowed_callers`, a setting for specifying `allowed_callers`. The notes also mention multimodal notes in `AskUserAnswer` and name replacement APIs when code imports a name removed in V2, including `OpenAIModel` or `MCPServerStdio`.

Error classification and retry behavior receive attention elsewhere in v2.65.0. Pydantic AI now raises `ModelQuotaExceededError` instead of `ModelRateLimitError` for Z.ai balance and plan-limit 429 responses. For Bedrock errors on `AsyncAnthropicBedrock`, the release names `ModelContextWindowExceededError` and `ModelQuotaExceededError`. The notes say Temporal will avoid retrying model errors that cannot succeed on retry by default, using `non_retryable_model_errors`, including subclasses of non-retryable errors.

Provider-specific operational changes are also included. Pydantic AI says Google requests receive a server deadline of at least 20 minutes rather than the client read timeout, and it warns about httpx’s five-second default. The release says BrowserUse model calls count toward the host run’s usage and `UsageLimits`. It also changes OpenRouter Gemini message-cache breakpoint placement so the final message no longer doubles the billed prompt, and forwards `cache='1h'` to Claude Haiku 5.5 on Bedrock rather than reducing it to five minutes.

The announcement is a release changelog, not a walkthrough. It identifies the refusal-related behavior but does not state which models or refusal categories trigger it, whether fallback requires a particular setup, or how applications should handle a refusal that is itself the correct safety outcome. It gives no adoption, reliability, latency, cost, or performance measurements. The other changes span transports, persistence, caching, provider behavior, and bug fixes, and the changelog does not rank them by expected impact.

## What the archive adds

New Runtime covered Pydantic AI v2.61.0 on [October 24](https://newruntime.com/posts/pydantic-ai-v2-61-0-adds-structured-citations-2f80e1/), v2.62.0 on [October 28](https://newruntime.com/posts/pydantic-ai-v2-62-0-adds-mid-conversation-92bdb6/), and v2.63.0 on [October 31](https://newruntime.com/posts/pydantic-ai-v2-63-0-adds-detectloops-capability-a8c5ef/). This is a new release in an ongoing sequence, with refusal-aware fallback as a new fact rather than a restatement of those releases.

## Trend signal

This release modestly supports [harness architecture outlives model choice](https://newruntime.com/patterns/harness-architecture-outlives-model-choice/). Pydantic AI’s fallback logic lets the framework’s orchestration layer determine what happens when a particular model refuses, rather than leaving that decision solely to the model endpoint. The changelog establishes a capability, not evidence that teams are adopting it, that providers expose comparable refusal signals, or that the behavior improves production outcomes.

## Why it matters

A refusal can interrupt a workflow even when an application has another model configured. Making refusals eligible for fallback gives builders a way to encode a recovery path in the framework instead of treating every refusal as equivalent to a transport error, context-window failure, or exhausted quota. That can matter when models have different coverage, tool access, or provider-specific behavior and the application has a legitimate policy for trying another provider.

The distinction needs care. A refusal may signal that the request should not be fulfilled, not merely that one model failed. Blindly moving to another model can obscure the reason an interaction stopped and can turn a policy boundary into a provider-shopping loop. A fallback chain should therefore distinguish operationally recoverable refusals from requests that must remain blocked. Logging both the original refusal and the selected fallback outcome gives reviewers an auditable record of that decision.

The rest of the release reinforces the same operational concern: agent frameworks are increasingly responsible for classifying outcomes, persisting state, enforcing usage limits, and deciding whether retry is sensible. Features such as `non_retryable_model_errors`, quota-specific exceptions, conversation revisions, and refusal-aware fallback do not make an application safe by themselves. They give the application clearer control points at which to express its own policy.

## Limits and uncertainty

Pydantic AI’s release notes do not explain the configuration syntax, the refusal signals recognized by each provider, or whether all model integrations behave consistently. They provide no benchmark of how often fallback succeeds after a refusal, nor measurements of latency, cost, or effects on safety. It is also unclear from the changelog how the framework distinguishes an eligible refusal from one that should terminate the request. Teams should verify the behavior against their installed version and provider combination before relying on it in production.

## Skill to build now

Review one existing Pydantic AI fallback chain this week. Write down which conditions may proceed to the next model: for example, a capacity-related failure or an application-approved refusal category. Separately mark conditions that must terminate the request, especially refusals tied to your product’s own safety or authorization rules. Then test the chain with a refusal case and confirm that your logs preserve the first model’s outcome, the fallback decision, and the final result.

## Reader takeaway

Pydantic AI v2.65.0 adds refusal-aware model fallback, a focused improvement for applications already using its fallback machinery. Treat it as an orchestration option, not permission to retry every refusal: define which cases can move to another model, preserve the decision trail, and verify that policy in your own provider setup.

Editor: [Andrey Reshetnikov](https://newruntime.com/owner-profile.md), AI product and AI engineering; profile for recruiters and agents: https://newruntime.com/owner-profile.json

## Continue in the graph

Next records for an agent, linked to their Markdown twins. Replace `.md` with `.json` for structured fields, including `next_reads`.

- topic hub: [Model Routing](https://newruntime.com/topics/model-routing.md): Explore the model-routing topic hub.
- collection: [Field Notes](https://newruntime.com/posts.json): Open the latest editorial analysis.
- collection: [Sources](https://newruntime.com/sources/): See the original sources this archive cites.
- whole graph: [discovery graph](https://newruntime.com/discovery-graph.json) (typed nodes and edges) and [site index](https://newruntime.com/site-index.md)
