Revert "Merge branch 'main' into patch-3323"

This reverts commit 2674863, reversing
changes made to 8267b71.

Author: anirbanbasu

.github/workflows/ci.yml

@@ -157,9 +157,6 @@ jobs:
     env:
       CI: true
       COVERAGE_PROCESS_START: ./pyproject.toml
-      # We only run the llama_cpp tests on the latest Python as they have been regularly failing in CI with `Fatal Python error: Illegal instruction`:
-      # https://github.com/pydantic/pydantic-ai/actions/runs/19547773220/job/55970947389
-      RUN_LLAMA_CPP_TESTS: ${{ matrix.python-version == '3.13' && matrix.install.name == 'all-extras' }}
     steps:
       - uses: actions/checkout@v4
 
@@ -210,7 +207,6 @@ jobs:
     env:
       CI: true
       COVERAGE_PROCESS_START: ./pyproject.toml
-      RUN_LLAMA_CPP_TESTS: false
     steps:
       - uses: actions/checkout@v4
 

Makefile

@@ -43,7 +43,6 @@ typecheck-pyright:
 .PHONY: typecheck-mypy
 typecheck-mypy:
 	uv run mypy
-	uv run mypy typings/ --strict
 
 .PHONY: typecheck
 typecheck: typecheck-pyright ## Run static type checking

docs/mcp/client.md

@@ -365,67 +365,6 @@ async def main():
 
 MCP tools can include metadata that provides additional information about the tool's characteristics, which can be useful when [filtering tools][pydantic_ai.toolsets.FilteredToolset]. The `meta`, `annotations`, and `output_schema` fields can be found on the `metadata` dict on the [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] object that's passed to filter functions.
 
-## Resources
-
-MCP servers can provide [resources](https://modelcontextprotocol.io/docs/concepts/resources) - files, data, or content that can be accessed by the client. Resources in MCP are application-driven, with host applications determining how to incorporate context manually, based on their needs. This means they will _not_ be exposed to the LLM automatically (unless a tool returns a `ResourceLink` or `EmbeddedResource`).
-
-Pydantic AI provides methods to discover and read resources from MCP servers:
-
-- [`list_resources()`][pydantic_ai.mcp.MCPServer.list_resources] - List all available resources on the server
-- [`list_resource_templates()`][pydantic_ai.mcp.MCPServer.list_resource_templates] - List resource templates with parameter placeholders
-- [`read_resource(uri)`][pydantic_ai.mcp.MCPServer.read_resource] - Read the contents of a specific resource by URI
-
-Resources are automatically converted: text content is returned as `str`, and binary content is returned as [`BinaryContent`][pydantic_ai.messages.BinaryContent].
-
-Before consuming resources, we need to run a server that exposes some:
-
-```python {title="mcp_resource_server.py"}
-from mcp.server.fastmcp import FastMCP
-
-mcp = FastMCP('Pydantic AI MCP Server')
-log_level = 'unset'
-
-
-@mcp.resource('resource://user_name.txt', mime_type='text/plain')
-async def user_name_resource() -> str:
-    return 'Alice'
-
-
-if __name__ == '__main__':
-    mcp.run()
-```
-
-Then we can create the client:
-
-```python {title="mcp_resources.py", requires="mcp_resource_server.py"}
-import asyncio
-
-from pydantic_ai.mcp import MCPServerStdio
-
-
-async def main():
-    server = MCPServerStdio('python', args=['-m', 'mcp_resource_server'])
-
-    async with server:
-        # List all available resources
-        resources = await server.list_resources()
-        for resource in resources:
-            print(f' - {resource.name}: {resource.uri} ({resource.mime_type})')
-            #>  - user_name_resource: resource://user_name.txt (text/plain)
-
-        # Read a text resource
-        user_name = await server.read_resource('resource://user_name.txt')
-        print(f'Text content: {user_name}')
-        #> Text content: Alice
-
-
-if __name__ == '__main__':
-    asyncio.run(main())
-```
-
-_(This example is complete, it can be run "as is")_
-
-
 ## Custom TLS / SSL configuration
 
 In some environments you need to tweak how HTTPS connections are established –

docs/models/openai.md

@@ -233,7 +233,7 @@ agent = Agent(model)
 ```
 
 Various providers also have their own provider classes so that you don't need to specify the base URL yourself and you can use the standard `<PROVIDER>_API_KEY` environment variable to set the API key.
-When a provider has its own provider class, you can use the `Agent("<provider>:<model>")` shorthand, e.g. `Agent("deepseek:deepseek-chat")` or `Agent("moonshotai:kimi-k2-0711-preview")`, instead of building the `OpenAIChatModel` explicitly. Similarly, you can pass the provider name as a string to the `provider` argument on `OpenAIChatModel` instead of building instantiating the provider class explicitly.
+When a provider has its own provider class, you can use the `Agent("<provider>:<model>")` shorthand, e.g. `Agent("deepseek:deepseek-chat")` or `Agent("openrouter:google/gemini-2.5-pro-preview")`, instead of building the `OpenAIChatModel` explicitly. Similarly, you can pass the provider name as a string to the `provider` argument on `OpenAIChatModel` instead of building instantiating the provider class explicitly.
 
 #### Model Profile
 
@@ -385,6 +385,34 @@ agent = Agent(model)
 ...
 ```
 
+### OpenRouter
+
+To use [OpenRouter](https://openrouter.ai), first create an API key at [openrouter.ai/keys](https://openrouter.ai/keys).
+
+You can set the `OPENROUTER_API_KEY` environment variable and use [`OpenRouterProvider`][pydantic_ai.providers.openrouter.OpenRouterProvider] by name:
+
+```python
+from pydantic_ai import Agent
+
+agent = Agent('openrouter:anthropic/claude-3.5-sonnet')
+...
+```
+
+Or initialise the model and provider directly:
+
+```python
+from pydantic_ai import Agent
+from pydantic_ai.models.openai import OpenAIChatModel
+from pydantic_ai.providers.openrouter import OpenRouterProvider
+
+model = OpenAIChatModel(
+    'anthropic/claude-3.5-sonnet',
+    provider=OpenRouterProvider(api_key='your-openrouter-api-key'),
+)
+agent = Agent(model)
+...
+```
+
 ### Vercel AI Gateway
 
 To use [Vercel's AI Gateway](https://vercel.com/docs/ai-gateway), first follow the [documentation](https://vercel.com/docs/ai-gateway) instructions on obtaining an API key or OIDC token.

docs/models/openrouter.md

@@ -5,32 +5,32 @@ Pydantic AI is model-agnostic and has built-in support for multiple model provid
 * [OpenAI](openai.md)
 * [Anthropic](anthropic.md)
 * [Gemini](google.md) (via two different APIs: Generative Language API and VertexAI API)
-* [Bedrock](bedrock.md)
-* [Cohere](cohere.md)
 * [Groq](groq.md)
-* [Hugging Face](huggingface.md)
 * [Mistral](mistral.md)
-* [OpenRouter](openrouter.md)
+* [Cohere](cohere.md)
+* [Bedrock](bedrock.md)
+* [Hugging Face](huggingface.md)
 * [Outlines](outlines.md)
 
 ## OpenAI-compatible Providers
 
 In addition, many providers are compatible with the OpenAI API, and can be used with `OpenAIChatModel` in Pydantic AI:
 
-- [Azure AI Foundry](openai.md#azure-ai-foundry)
-- [Cerebras](openai.md#cerebras)
 - [DeepSeek](openai.md#deepseek)
-- [Fireworks AI](openai.md#fireworks-ai)
-- [GitHub Models](openai.md#github-models)
 - [Grok (xAI)](openai.md#grok-xai)
+- [Ollama](openai.md#ollama)
+- [OpenRouter](openai.md#openrouter)
+- [Vercel AI Gateway](openai.md#vercel-ai-gateway)
+- [Perplexity](openai.md#perplexity)
+- [Fireworks AI](openai.md#fireworks-ai)
+- [Together AI](openai.md#together-ai)
+- [Azure AI Foundry](openai.md#azure-ai-foundry)
 - [Heroku](openai.md#heroku-ai)
+- [GitHub Models](openai.md#github-models)
+- [Cerebras](openai.md#cerebras)
 - [LiteLLM](openai.md#litellm)
 - [Nebius AI Studio](openai.md#nebius-ai-studio)
-- [Ollama](openai.md#ollama)
 - [OVHcloud AI Endpoints](openai.md#ovhcloud-ai-endpoints)
-- [Perplexity](openai.md#perplexity)
-- [Together AI](openai.md#together-ai)
-- [Vercel AI Gateway](openai.md#vercel-ai-gateway)
 
 Pydantic AI also comes with [`TestModel`](../api/models/test.md) and [`FunctionModel`](../api/models/function.md)
 for testing and development.
@@ -180,7 +180,7 @@ contains all the exceptions encountered during the `run` execution.
 === "Python >=3.11"
 
     ```python {title="fallback_model_failure.py" py="3.11"}
-    from pydantic_ai import Agent, ModelAPIError
+    from pydantic_ai import Agent, ModelHTTPError
     from pydantic_ai.models.anthropic import AnthropicModel
     from pydantic_ai.models.fallback import FallbackModel
     from pydantic_ai.models.openai import OpenAIChatModel
@@ -192,7 +192,7 @@ contains all the exceptions encountered during the `run` execution.
     agent = Agent(fallback_model)
     try:
         response = agent.run_sync('What is the capital of France?')
-    except* ModelAPIError as exc_group:
+    except* ModelHTTPError as exc_group:
         for exc in exc_group.exceptions:
             print(exc)
     ```
@@ -206,7 +206,7 @@ contains all the exceptions encountered during the `run` execution.
     ```python {title="fallback_model_failure.py" noqa="F821" test="skip"}
     from exceptiongroup import catch
 
-    from pydantic_ai import Agent, ModelAPIError
+    from pydantic_ai import Agent, ModelHTTPError
     from pydantic_ai.models.anthropic import AnthropicModel
     from pydantic_ai.models.fallback import FallbackModel
     from pydantic_ai.models.openai import OpenAIChatModel
@@ -222,11 +222,10 @@ contains all the exceptions encountered during the `run` execution.
     fallback_model = FallbackModel(openai_model, anthropic_model)
 
     agent = Agent(fallback_model)
-    with catch({ModelAPIError: model_status_error_handler}):
+    with catch({ModelHTTPError: model_status_error_handler}):
         response = agent.run_sync('What is the capital of France?')
     ```
 
 By default, the `FallbackModel` only moves on to the next model if the current model raises a
-[`ModelAPIError`][pydantic_ai.exceptions.ModelAPIError], which includes
 [`ModelHTTPError`][pydantic_ai.exceptions.ModelHTTPError]. You can customize this behavior by
 passing a custom `fallback_on` argument to the `FallbackModel` constructor.

docs/models/overview.md

@@ -178,8 +178,6 @@ validate state contained in [`RunAgentInput.state`](https://docs.ag-ui.com/sdk/j
 
     If the `state` field's type is a Pydantic `BaseModel` subclass, the raw state dictionary on the request is automatically validated. If not, you can validate the raw value yourself in your dependencies dataclass's `__post_init__` method.
 
-    If AG-UI state is provided but your dependencies do not implement [`StateHandler`][pydantic_ai.ag_ui.StateHandler], Pydantic AI will emit a warning and ignore the state. Use [`StateDeps`][pydantic_ai.ag_ui.StateDeps] or a custom [`StateHandler`][pydantic_ai.ag_ui.StateHandler] implementation to receive and validate the incoming state.
-
 
 ```python {title="ag_ui_state.py"}
 from pydantic import BaseModel

docs/ui/ag-ui.md

@@ -32,9 +32,8 @@ nav:
           - models/bedrock.md
           - models/cohere.md
           - models/groq.md
-          - models/huggingface.md
           - models/mistral.md
-          - models/openrouter.md
+          - models/huggingface.md
           - models/outlines.md
       - Tools & Toolsets:
           - tools.md

mkdocs.yml

@@ -24,7 +24,6 @@
     CallDeferred,
     FallbackExceptionGroup,
     IncompleteToolCall,
-    ModelAPIError,
     ModelHTTPError,
     ModelRetry,
     UnexpectedModelBehavior,
@@ -127,7 +126,6 @@
     'CallDeferred',
     'ApprovalRequired',
     'ModelRetry',
-    'ModelAPIError',
     'ModelHTTPError',
     'FallbackExceptionGroup',
     'IncompleteToolCall',