Merge branch 'main' into add-langwatch

Author: DouweM

.github/workflows/ci.yml

@@ -137,7 +137,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
         install:
           - name: pydantic-ai-slim
             command: "--package pydantic-ai-slim"
@@ -169,7 +169,6 @@ jobs:
 
       - name: store coverage files
         uses: actions/upload-artifact@v4
-        if: matrix.python-version != '3.9'
         with:
           name: coverage-${{ matrix.python-version }}-${{ matrix.install.name }}
           path: .coverage

CLAUDE.md

@@ -91,7 +91,7 @@ This is a uv workspace with multiple packages:
 - **VCR cassettes**: `tests/cassettes/` for recorded LLM API interactions
 - **Test models**: Use `TestModel` for deterministic testing
 - **Examples testing**: `tests/test_examples.py` validates all documentation examples
-- **Multi-version testing**: Python 3.9-3.13 support
+- **Multi-version testing**: Python 3.10-3.13 support
 
 ## Key Configuration Files
 

Makefile

@@ -19,7 +19,6 @@ install: .uv .pre-commit .deno ## Install the package, dependencies, and pre-com
 
 .PHONY: install-all-python
 install-all-python: ## Install and synchronize an interpreter for every python version
-	UV_PROJECT_ENVIRONMENT=.venv39 uv sync --python 3.9 --frozen --all-extras --all-packages --group lint --group docs
 	UV_PROJECT_ENVIRONMENT=.venv310 uv sync --python 3.10 --frozen --all-extras --all-packages --group lint --group docs
 	UV_PROJECT_ENVIRONMENT=.venv311 uv sync --python 3.11 --frozen --all-extras --all-packages --group lint --group docs
 	UV_PROJECT_ENVIRONMENT=.venv312 uv sync --python 3.12 --frozen --all-extras --all-packages --group lint --group docs
@@ -60,13 +59,12 @@ typecheck-both: typecheck-pyright typecheck-mypy
 
 .PHONY: test
 test: ## Run tests and collect coverage data
-	uv run coverage run -m pytest -n auto --dist=loadgroup
+	uv run coverage run -m pytest -n auto --dist=loadgroup --durations=20
 	@uv run coverage combine
 	@uv run coverage report
 
 .PHONY: test-all-python
-test-all-python: ## Run tests on Python 3.9 to 3.13
-	UV_PROJECT_ENVIRONMENT=.venv39 uv run --python 3.9 --all-extras --all-packages coverage run -p -m pytest
+test-all-python: ## Run tests on Python 3.10 to 3.13
 	UV_PROJECT_ENVIRONMENT=.venv310 uv run --python 3.10 --all-extras --all-packages coverage run -p -m pytest
 	UV_PROJECT_ENVIRONMENT=.venv311 uv run --python 3.11 --all-extras --all-packages coverage run -p -m pytest
 	UV_PROJECT_ENVIRONMENT=.venv312 uv run --python 3.12 --all-extras --all-packages coverage run -p -m pytest

clai/pyproject.toml

@@ -28,7 +28,6 @@ classifiers = [
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
@@ -44,7 +43,7 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Topic :: Internet",
 ]
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 
 [tool.hatch.metadata.hooks.uv-dynamic-versioning]
 dependencies = [

docs/ag-ui.md

@@ -43,24 +43,24 @@ This example uses [`run_ag_ui()`][pydantic_ai.ag_ui.run_ag_ui] and performs its
 This can be modified to work with any web framework.
 
 ```py {title="run_ag_ui.py"}
+import json
+from http import HTTPStatus
+
 from ag_ui.core import RunAgentInput
 from fastapi import FastAPI
-from http import HTTPStatus
 from fastapi.requests import Request
 from fastapi.responses import Response, StreamingResponse
 from pydantic import ValidationError
-import json
 
 from pydantic_ai import Agent
-from pydantic_ai.ag_ui import run_ag_ui, SSE_CONTENT_TYPE
-
+from pydantic_ai.ag_ui import SSE_CONTENT_TYPE, run_ag_ui
 
 agent = Agent('openai:gpt-4.1', instructions='Be fun!')
 
 app = FastAPI()
 
 
-@app.post("/")
+@app.post('/')
 async def run_agent(request: Request) -> Response:
     accept = request.headers.get('accept', SSE_CONTENT_TYPE)
     try:
@@ -97,12 +97,11 @@ from starlette.responses import Response
 from pydantic_ai import Agent
 from pydantic_ai.ag_ui import handle_ag_ui_request
 
-
 agent = Agent('openai:gpt-4.1', instructions='Be fun!')
 
 app = FastAPI()
 
-@app.post("/")
+@app.post('/')
 async def run_agent(request: Request) -> Response:
     return await handle_ag_ui_request(agent, request)
 ```
@@ -119,7 +118,7 @@ This will expose the agent as an AG-UI server, and your frontend can start sendi
 
 This example uses [`Agent.to_ag_ui()`][pydantic_ai.agent.AbstractAgent.to_ag_ui] to turn the agent into a stand-alone ASGI application:
 
-```py {title="agent_to_ag_ui.py" py="3.10" hl_lines="4"}
+```py {title="agent_to_ag_ui.py" hl_lines="4"}
 from pydantic_ai import Agent
 
 agent = Agent('openai:gpt-4.1', instructions='Be fun!')
@@ -171,7 +170,7 @@ 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.
 
 
-```python {title="ag_ui_state.py" py="3.10"}
+```python {title="ag_ui_state.py"}
 from pydantic import BaseModel
 
 from pydantic_ai import Agent
@@ -211,7 +210,7 @@ which returns a (subclass of)
 [`BaseEvent`](https://docs.ag-ui.com/sdk/python/core/events#baseevent), which allows
 for custom events and state updates.
 
-```python {title="ag_ui_tool_events.py" py="3.10"}
+```python {title="ag_ui_tool_events.py"}
 from ag_ui.core import CustomEvent, EventType, StateSnapshotEvent
 from pydantic import BaseModel
 

docs/agents.md

@@ -115,22 +115,19 @@ The example below shows how to stream events and text output. You can also [stre
 import asyncio
 from collections.abc import AsyncIterable
 from datetime import date
-from typing import Union
 
-from pydantic_ai import Agent
+from pydantic_ai import Agent, RunContext
 from pydantic_ai.messages import (
     AgentStreamEvent,
     FinalResultEvent,
     FunctionToolCallEvent,
     FunctionToolResultEvent,
-    HandleResponseEvent,
     PartDeltaEvent,
     PartStartEvent,
     TextPartDelta,
     ThinkingPartDelta,
     ToolCallPartDelta,
 )
-from pydantic_ai.tools import RunContext
 
 weather_agent = Agent(
     'openai:gpt-4o',
@@ -152,7 +149,7 @@ output_messages: list[str] = []
 
 async def event_stream_handler(
     ctx: RunContext,
-    event_stream: AsyncIterable[Union[AgentStreamEvent, HandleResponseEvent]],
+    event_stream: AsyncIterable[AgentStreamEvent],
 ):
     async for event in event_stream:
         if isinstance(event, PartStartEvent):
@@ -217,10 +214,10 @@ Unlike `run_stream()`, it always runs the agent graph to completion even if text
     To get the best of both worlds, at the expense of some additional complexity, you can use [`agent.iter()`][pydantic_ai.agent.AbstractAgent.iter] as described in the next section, which lets you [iterate over the agent graph](#iterating-over-an-agents-graph) and [stream both events and output](#streaming-all-events-and-output) at every step.
 
 ```python {title="run_events.py" requires="run_stream_events.py"}
-from run_stream_events import weather_agent, event_stream_handler, output_messages
-
 import asyncio
 
+from run_stream_events import event_stream_handler, output_messages, weather_agent
+
 
 async def main():
     user_prompt = 'What will the weather be like in Paris on Tuesday?'
@@ -397,7 +394,7 @@ import asyncio
 from dataclasses import dataclass
 from datetime import date
 
-from pydantic_ai import Agent
+from pydantic_ai import Agent, RunContext
 from pydantic_ai.messages import (
     FinalResultEvent,
     FunctionToolCallEvent,
@@ -408,7 +405,6 @@ from pydantic_ai.messages import (
     ThinkingPartDelta,
     ToolCallPartDelta,
 )
-from pydantic_ai.tools import RunContext
 
 
 @dataclass
@@ -550,9 +546,7 @@ You can apply these settings by passing the `usage_limits` argument to the `run{
 Consider the following example, where we limit the number of response tokens:
 
 ```py
-from pydantic_ai import Agent
-from pydantic_ai.exceptions import UsageLimitExceeded
-from pydantic_ai.usage import UsageLimits
+from pydantic_ai import Agent, UsageLimitExceeded, UsageLimits
 
 agent = Agent('anthropic:claude-3-5-sonnet-latest')
 
@@ -580,9 +574,7 @@ Restricting the number of requests can be useful in preventing infinite loops or
 ```py
 from typing_extensions import TypedDict
 
-from pydantic_ai import Agent, ModelRetry
-from pydantic_ai.exceptions import UsageLimitExceeded
-from pydantic_ai.usage import UsageLimits
+from pydantic_ai import Agent, ModelRetry, UsageLimitExceeded, UsageLimits
 
 
 class NeverOutputType(TypedDict):
@@ -638,9 +630,8 @@ For example, if you'd like to set the `temperature` setting to `0.0` to ensure l
 you can do the following:
 
 ```py
-from pydantic_ai import Agent
+from pydantic_ai import Agent, ModelSettings
 from pydantic_ai.models.openai import OpenAIChatModel
-from pydantic_ai.settings import ModelSettings
 
 # 1. Model-level defaults
 model = OpenAIChatModel(

docs/api/output.md

@@ -10,4 +10,4 @@
             - PromptedOutput
             - TextOutput
             - StructuredDict
-            - DeferredToolCalls
+            - DeferredToolRequests

docs/api/toolsets.md

@@ -5,7 +5,8 @@
         members:
         - AbstractToolset
         - CombinedToolset
-        - DeferredToolset
+        - ExternalToolset
+        - ApprovalRequiredToolset
         - FilteredToolset
         - FunctionToolset
         - PrefixedToolset

docs/changelog.md

@@ -12,6 +12,16 @@ Pydantic AI is still pre-version 1, so breaking changes will occur, however:
 !!! note
     Here's a filtered list of the breaking changes for each version to help you upgrade Pydantic AI.
 
+### v0.8.0 (2025-08-26)
+
+See [#2689](https://github.com/pydantic/pydantic-ai/pull/2689) - `AgentStreamEvent` was expanded to be a union of `ModelResponseStreamEvent` and `HandleResponseEvent`, simplifying the `event_stream_handler` function signature. Existing code accepting `AgentStreamEvent | HandleResponseEvent` will continue to work.
+
+### v0.7.6 (2025-08-26)
+
+The following breaking change was inadvertently released in a patch version rather than a minor version:
+
+See [#2670](https://github.com/pydantic/pydantic-ai/pull/2670) - `TenacityTransport` and `AsyncTenacityTransport` now require the use of `pydantic_ai.retries.RetryConfig` (which is just a `TypedDict` containing the kwargs to `tenacity.retry`) instead of `tenacity.Retrying` or `tenacity.AsyncRetrying`.
+
 ### v0.7.0 (2025-08-12)
 
 See [#2458](https://github.com/pydantic/pydantic-ai/pull/2458) - `pydantic_ai.models.StreamedResponse` now yields a `FinalResultEvent` along with the existing `PartStartEvent` and `PartDeltaEvent`. If you're using `pydantic_ai.direct.model_request_stream` or `pydantic_ai.direct.model_request_stream_sync`, you may need to update your code to account for this.

docs/cli.md

@@ -108,3 +108,31 @@ async def main():
 ```
 
 _(You'll need to add `asyncio.run(main())` to run `main`)_
+
+### Message History
+
+Both `Agent.to_cli()` and `Agent.to_cli_sync()` support a `message_history` parameter, allowing you to continue an existing conversation or provide conversation context:
+
+```python {title="agent_with_history.py" test="skip"}
+from pydantic_ai import Agent
+from pydantic_ai.messages import (
+    ModelMessage,
+    ModelRequest,
+    ModelResponse,
+    TextPart,
+    UserPromptPart,
+)
+
+agent = Agent('openai:gpt-4.1')
+
+# Create some conversation history
+message_history: list[ModelMessage] = [
+    ModelRequest([UserPromptPart(content='What is 2+2?')]),
+    ModelResponse([TextPart(content='2+2 equals 4.')])
+]
+
+# Start CLI with existing conversation context
+agent.to_cli_sync(message_history=message_history)
+```
+
+The CLI will start with the provided conversation history, allowing the agent to refer back to previous exchanges and maintain context throughout the session.