pydantic/pydantic-ai

Pydantic AI is a Python framework for building and running AI agents, featuring a modular architecture that supports native tool integration, durable execution across engines like Temporal and DBOS, and real-time voice interactions. It provides comprehensive evaluation tooling for assessing agent performance and includes a CLI and web interface for interactive agent testing. The system also offers adapters for standard protocols like AG-UI and Vercel AI to facilitate frontend integration.

38 changes.

The project underwent a major structural overhaul, migrating to a uv workspace with six distinct packages and introducing a new type-hinted graph library for agent loops. Significant features included durable execution integrations for Temporal, DBOS, and Prefect, alongside a comprehensive evaluation toolkit and expanded provider support via a new model profile system.

15 changes.

This period focused on introducing a composable capabilities system to unify agent behavior and adding native realtime speech-to-speech support for voice-first models. Significant effort was also directed toward expanding test coverage for new features like durable execution and WebRTC, alongside enhancing CI reliability and adding new model providers.

Users can now easily use LangChain community tools in PydanticAI. The new \pydantic\_ai.ext.langchain\ module provides \LangChainToolset\ and \tool\_from\_langchain\ to wrap LangChain tools as PydanticAI tools, allowing seamless integration of existing LangChain tooling into PydanticAI agents.

_pydantic\_ai\_slim/pydantic\ai/ext · high confidence

The Vercel AI adapter module is introduced, providing \VercelAIAdapter\ and \VercelAIEventStream\ to enable streaming event-based communication between Pydantic AI agents and Vercel AI frontends. The adapter's request and response type definitions are updated to match the Vercel AI SDK v6 protocol, adding support for tool approval workflows (requiring human-in-the-loop decisions), reasoning text parts, and dynamic data chunks. Strict boolean validation is enforced on tool approval responses to prevent silent coercion of non-boolean values, and the adapter now correctly handles provider metadata and tool execution states across the protocol boundary.

_pydantic\_ai\_slim/pydantic\_ai/ui/vercel\ai · high confidence

A new example demonstrating a realtime WebRTC voice agent topology is added to the documentation. This example allows browsers to exchange audio directly with OpenAI over WebRTC for low latency, while a Pydantic AI server-side sideband handles tool execution and conversation history, keeping API keys secure. The entry includes the frontend interface (HTML/JS) for microphone capture and status logging, alongside the backend logic and documentation explaining the SDP negotiation and session management.

_examples/pydantic\_ai\_examples/realtime\webrtc · high confidence

The repository is initialized with the core structure for the Pydantic AI project, including a \uv\ workspace defining packages like \pydantic-ai-slim\, \pydantic-graph\, and \clai\. A \Makefile\ is added to standardize development tasks such as formatting, linting, type-checking, and testing. The setup includes a \pre-commit\ configuration to enforce code quality, a \CLAUDE.md\ symlink pointing to \AGENTS.md\ for AI contributor guidance, and a \CITATION.cff\ file for academic referencing.

(repo-wide) · high confidence

This change adds the \ag\ui\ module to Pydantic AI, providing an adapter and event stream for the AG-UI protocol. It introduces version-aware handling for the \ag-ui-protocol\ library, automatically detecting the installed version to support features like reasoning events (REASONING\\* vs THINKING\\), multimodal input content (images, audio, video, documents), and tool availability deltas. The integration includes forward-compatibility logic to gracefully skip unknown message tags from newer clients when the installed protocol version is older, preventing validation errors. It also ensures round-trip preservation of tool kinds, file metadata, and compaction parts across the AG-UI and Vercel AI adapters.

_pydantic\_ai\_slim/pydantic\_ai/ui/ag\ui · high confidence

This change adds a new DBOS integration module (\pydantic\_ai/durable\_exec/dbos\) that enables Pydantic AI agents to run as durable workflows. It introduces \DBOSAgent\ (now deprecated in favor of the \DBOSDurability\ capability) and \DBOSDurability\ to wrap agent operations—such as model requests, tool calls, and MCP server communication—into DBOS steps. This ensures that agent runs are checkpointed and can be automatically recovered from failures, with support for configurable step settings, parallel execution modes, and unique run IDs for correlation.

_pydantic\_ai\_slim/pydantic\_ai/durable\exec/dbos · high confidence

Added a new \WrapperAgent\ class that acts as a base for wrapping other agents, forwarding properties like \model\, \name\, \description\, and \toolsets\ to the wrapped instance. This enables users to create composed agent behaviors by extending this wrapper, supporting features such as dynamic capabilities, toolset overrides, and metadata propagation within the agent hierarchy.

_pydantic\_ai\_slim/pydantic\ai/agent · high confidence

This change adds the foundational classes and configuration for embedding models, introducing the \EmbeddingModel\ abstract base class and \EmbeddingSettings\ TypedDict. Users can now define custom embedding providers by implementing the base class, which standardizes input preparation, settings merging, and token counting across supported providers like OpenAI, Cohere, Google, Bedrock, and VoyageAI.

_pydantic\_ai\_slim/pydantic\ai/embeddings · high confidence

This change adds a new \pydantic\_ai.durable\_exec.temporal\ module that enables Pydantic AI agents to run reliably inside Temporal workflows. It provides a \TemporalAgent\ and \TemporalDurability\ capability to move model requests, tool calls, and MCP interactions into Temporal activities, ensuring deterministic replay and resilience. The integration includes a custom \PydanticAIPayloadConverter\ with memoized \TypeAdapter\ caching for efficient serialization, a sandboxed workflow runner that passes through necessary SDKs (like \openai\, \anthropic\, \httpx\, and \fastmcp\), and support for dynamic, function, and MCP toolsets within the durable context. It also features a \LogfirePlugin\ for tracing and metrics, and fixes a potential livelock in activity cancellation handling to prevent workflow hangs.

_pydantic\_ai\_slim/pydantic\_ai/durable\exec/temporal · high confidence

The toolsets module now supports building tool collections dynamically based on the run context via the new \DynamicToolset\, which allows tool availability to change during execution, and \ExternalToolset\, which defines tools whose results are produced outside the agent run. These additions provide a structured way to handle context-sensitive tool selection and cross-boundary tool interactions within the agent's lifecycle.

_pydantic\_ai\_slim/pydantic\ai/toolsets · high confidence

Adds a new \pydantic\_ai.realtime\ package enabling bidirectional, persistent streaming sessions for voice-first models. Users can now call \Agent.realtime()\ to connect to OpenAI, Azure OpenAI, Gemini Live, and xAI Grok Voice, receiving structured events for speech, transcription, and tool calls over a single WebSocket connection. The feature includes provider-specific capability profiles to handle differences in turn-taking, interruption, and audio retention, along with OpenTelemetry instrumentation for tracing these long-lived sessions.

_pydantic\_ai\_slim/pydantic\ai/realtime · high confidence

The new \pydantic\_evals\ package provides a toolkit for evaluating stochastic functions like LLM calls, including creating and loading test datasets, running evaluations with various metrics, and generating reports. Key capabilities include \CaseLifecycle\ hooks for per-case setup, context preparation, and teardown during evaluation, as well as online evaluation support via OpenTelemetry event emission (\gen\_ai.evaluation.result\). The package also includes utilities for generating sample datasets using LLMs and ensures type-checking support via a \py.typed\ marker file.

_pydantic\_evals/pydantic\evals · high confidence

A new \pydantic\_graph\ package is introduced, providing a library for constructing and executing typed state machines (graphs) that power the Pydantic AI agent loop. Users can now define graph workflows using \GraphBuilder\, \BaseNode\, and step functions, and execute them via \Graph\ or \GraphRun\. The library includes primitives for starting (\StartNode\), ending (\EndNode\), branching (\Fork\, \Decision\), joining (\Join\), and reducing state, along with specific error types like \GraphSetupError\ and \GraphRuntimeError\. It also handles synchronous execution via \run\_until\_complete\ with robust cleanup on interruption and support for OpenTelemetry/Logfire tracing.

_pydantic\_graph/pydantic\graph · high confidence

The \pydantic\_evals.otel\ module now provides a \context\_subtree\ context manager that captures OpenTelemetry spans into a \SpanTree\ during evaluation runs. This enables new span-based evaluators (such as ToolCorrectness and TrajectoryMatch) to inspect the execution trace. The implementation includes a custom in-memory exporter with context-aware caching to prevent processor leaks, and gracefully degrades by yielding a \SpanTreeRecordingError\ if no tracer provider is configured or if the provider lacks \add\_span\_processor\ support.

_pydantic\_evals/pydantic\evals/otel · high confidence

The \pydantic\_evals\ package is now available, providing a comprehensive suite of evaluators for assessing AI agent performance. This release introduces agentic-specific evaluators such as \ToolCorrectness\, \TrajectoryMatch\, and \ArgumentCorrectness\ to analyze tool usage and decision paths, alongside report-level metrics like \ROCAUCEvaluator\ and \ConfusionMatrixEvaluator\ for statistical analysis. The package also includes standard quality rubrics via \GEval\ and \LLMJudge\, while removing the insecure \Python\ evaluator and enforcing non-finite output validation to ensure robust evaluation results.

_pydantic\_evals/pydantic\evals/evaluators · high confidence

The \clai\ package is introduced as the new command-line interface for Pydantic AI, replacing the previous CLI implementation. This tool provides an interactive chat session with LLMs, supporting one-shot prompts, streaming output, and special commands like \/cp\ to copy responses. It allows users to specify models (defaulting to \openai:gpt-5\), custom agents, and code themes, and includes a \web\ subcommand to launch a web-based chat interface. The package includes its own MIT license and documentation.

clai · high confidence

A new example application has been added at \examples/pydantic\_ai\_examples/ag\_ui\ that demonstrates how to integrate Pydantic AI agents with the AG-UI protocol using the \AGUIAdapter\. This FastAPI-based server exposes distinct endpoints for various agentic patterns, including agentic chat, human-in-the-loop workflows, tool-based generative UI, shared state, predictive state updates, and tool approval (interrupts). Users can run this local server to interact with these examples via an AG-UI compatible frontend.

_examples/pydantic\_ai\_examples/ag\ui · high confidence

The \clai\ command-line interface is now available, allowing users to interact with Pydantic AI agents directly from the terminal with features like prompt history, custom markdown rendering, and a first-run banner. Additionally, a new \clai web\ command (and \Agent.to\_web()\) launches a local web-based chat UI for any agent, supporting configuration of models, native tools, system instructions, and custom HTML sources. The CLI also introduces a \/usage\ slash command to track cumulative token usage and supports MCP configuration via \--mcp-config\.

_pydantic\_ai\_slim/pydantic\_ai/\cli · high confidence

The examples directory now includes a CLI entry point (\\_\main\\_.py\) to copy example files to a new directory, a browser-based chat application (\chat\_app.html\/\.ts\) that streams responses, and several new realtime examples: a camera assistant (\realtime\_camera/\) with watch, search, and drawing features; a minimal text-to-audio example (\realtime\_text\_to\_audio.py\); and a voice assistant (\realtime\_voice.py\) using the \listentome\ package with barge-in support. Additionally, a Gradio-based weather agent demo (\weather\_agent\_gradio.py\) is added, and the \py.typed\ marker file is moved into the examples package.

_examples/pydantic\_ai\examples · high confidence

Added a new example application that demonstrates an AI-powered workflow for qualifying new Slack team members. The example uses Pydantic AI with an OpenAI model to analyze new joiners' profiles via DuckDuckGo search, scoring their relevance to Pydantic Logfire. It includes a FastAPI webhook to receive Slack events, Modal functions for serverless execution, and a daily summary feature that posts the top leads to a Slack channel, all instrumented with Logfire for observability.

_examples/pydantic\_ai\_examples/slack\_lead\qualifier · high confidence

This update introduces several new agent skills to the \.claude/skills\ directory, making them available for use. Specifically, it adds \complete-partial-pr\ to assist with finishing pull requests, \poweruser-feature-audit\ for auditing features, and \i-have-adhd\ to support users with ADHD. Additionally, a \pushing-commits-to-the-repo\ skill is added to facilitate commit workflows. These skills are implemented as symlinks pointing to their definitions in the \.agents/skills\ directory.

.claude/skills · high confidence

Pydantic AI introduces a public, extensible framework for durable execution, providing a standardized way to integrate with engines like Temporal, DBOS, and Prefect. This change adds a new \pydantic\_ai.durable\_exec\ module exposing core abstractions such as \BaseDurabilityCapability\, \DurableOperationBackend\, and serialization codecs (\IDENTITY\_CODEC\, \JSON\_CODEC\) that allow third-party engines to wrap agent operations durably. It also includes specific capability implementations for Temporal, DBOS, and Prefect, alongside a new \AGENTS.md\ guide detailing best practices for building new integrations and handling toolset lifecycles across durable boundaries.

_pydantic\_ai\_slim/pydantic\_ai/durable\exec · high confidence

The \examples/pydantic\_ai\_examples/evals\ directory now provides a complete workflow for evaluating time-range inference agents using the \pydantic\_evals\ library. This includes dataset generation scripts (\example\_01\), custom evaluator integration (\example\_02\), unit testing (\example\_03\), and model comparison (\example\_04\), supported by versioned YAML datasets (\time\_range\_v1\, \time\_range\_v2\) and their corresponding JSON schemas.

_examples/pydantic\_ai\examples/evals · high confidence

Developers now have a dedicated testing skill that provides a structured workflow for recording, verifying, and debugging VCR cassettes. This includes a new \parse\_cassette.py\ utility to inspect HTTP request and response bodies in cassette files with truncated base64 strings for readability, alongside documented pytest flags (such as \--record-mode=rewrite\) and prerequisites for managing API keys via \.env\.

.claude/skills/testing-skill · high confidence

Pydantic AI now supports durable execution with Prefect, allowing agent runs, model requests, and tool calls to be wrapped in Prefect flows and tasks for automatic retry and caching. This includes the \PrefectDurability\ capability (the recommended path), the deprecated \PrefectAgent\ wrapper, and specific toolset wrappers (\PrefectFunctionToolset\, \PrefectMCPToolset\, and dynamic toolset support) that ensure I/O operations are handled durably. The integration provides configurable task settings via \TaskConfig\ and robust cache policies to handle non-serializable dependencies and ensure correct replay behavior.

_pydantic\_ai\_slim/pydantic\_ai/durable\exec/prefect · high confidence

This release introduces Pydantic AI v2, a major update that replaces the legacy tool system with a new native tool and capability architecture. Users can now register built-in tools (such as WebFetch, FileSearch, and MCP server tools) via the \capabilities\ argument on the \Agent\ class, and access a comprehensive event stream for real-time observability of model and tool calls. The library also adds first-class support for cost tracking, concurrency limiting, and a new interactive CLI (\clai\) that displays a first-run banner with setup instructions for observability backends like Logfire.

_pydantic\_ai\_slim/pydantic\ai · high confidence

The web chat UI now validates the \Host\ header of incoming requests to mitigate DNS rebinding attacks, where an attacker might point a controlled domain at the local loopback address. This change introduces a new \allowed\_hosts\ parameter to \Agent.to\web()\ and the \clai web\ command, allowing users to explicitly permit specific hostnames or subdomains (e.g., \\.example.com\) in addition to the default allowance of \localhost\ and IP addresses. Requests with unallowed \Host\ headers are now rejected with a 421 status code, ensuring that the UI cannot be accessed via maliciously resolved domains even if bound to a local interface.

_pydantic\_ai\_slim/pydantic\_ai/ui/\web · high confidence

An empty \_\init\\_.py file was added to the pydantic\_ai\_slim/pydantic\_ai/common\_tools directory. While the commit message indicates the addition of a DuckDuckGoSearch tool, the provided diff shows no actual tool implementation or code changes, only the creation of an empty module file.

_pydantic\_ai\_slim/pydantic\_ai/common\tools · low confidence

The library now uses a \ModelProfile\ system to describe model-family capability facts and schema/request quirks, separating them from provider client and authentication logic. This new profiles module (including provider-specific files like \anthropic.py\, \google.py\, \grok.py\, and \openai.py\) allows the library to handle model-specific behaviors—such as structured output modes, thinking/reasoning configurations, and JSON schema transformations—independently of the model and provider classes. Users benefit from more robust and accurate handling of diverse model capabilities, as the library can now adapt its request construction and response processing based on the specific model being used.

_pydantic\_ai\_slim/pydantic\ai/profiles · high confidence

The \pydantic\_ai.providers\ package is restructured to centralize API clients, authentication, base URLs, and HTTP lifecycle management. A new abstract \Provider\ base class defines the interface, with concrete implementations (e.g., \OpenAIProvider\, \AzureProvider\, \BedrockProvider\) handling provider-specific logic. Model capabilities are now governed by \ModelProfile\ objects, allowing per-provider and per-model behavior configuration (such as thinking support, structured output, and document input handling) independent of the model class. HTTP client management is standardized through \\_OpenAICompatibleProvider\ and \create\_async\_http\_client\, ensuring consistent lifecycle handling across providers. New providers include Alibaba, Bedrock Mantle, Crusoe, and Cerebras, while existing providers are refactored to use the new profile system and shared HTTP client infrastructure.

_pydantic\_ai\_slim/pydantic\ai/providers · high confidence

The \pydantic\_ai.capabilities\ module now provides a unified, composable system for cross-cutting agent behavior, replacing scattered constructor arguments and legacy patterns. Users can now inject features such as tool search, history processing, instrumentation, event streaming, and durable execution directly via the \capabilities\ list on \Agent\ or \agent.run()\. This change introduces a new capability abstraction with strict composition rules, automatic ordering, and merging logic to ensure predictable behavior when multiple capabilities are combined. It also deprecates older patterns like \fallback\_model\ in favor of \fallback\_subagent\_model\ and introduces new capabilities like \ToolSearch\, \ProcessHistory\, \Instrumentation\, and \HandleDeferredToolCalls\ to manage tool discovery, output processing, and event handling in a structured way.

_pydantic\_ai\_slim/pydantic\ai/capabilities · high confidence

The reporting module now includes a new \render\_numbers.py\ component that defines how numerical values, differences, percentages, and durations are displayed in evaluation reports. This change introduces specific formatting rules: integers are formatted with thousand separators, floats use significant figures (default 3) with at least one decimal place, and durations automatically scale to microseconds, milliseconds, or seconds based on magnitude. Differences between values now show both absolute change and relative change (as a percentage or multiplier), with logic to drop relative indicators for very small base values or when the relative change rounds to zero.

_pydantic\_evals/pydantic\evals/reporting · high confidence

This change introduces several new scripts to the \scripts/\ directory to improve CI reliability and testing workflows. \check\_cassettes.py\ replaces the previous pytest-collection approach with AST parsing to detect orphaned VCR cassettes, ensuring every recorded HTTP interaction has a corresponding test. Two context-gathering scripts, \gather-review-context.sh\ (for the legacy \douwebot\) and \gather-pydantic-ai-review-context.sh\ (for the new Pydantic AI agent), now fetch PR details, comments, and related issues to provide richer context for automated reviews, with the latter writing to the workspace root to avoid path restrictions. Additionally, \upload\_test\_files.py\ automates the upload of test assets to various AI providers (OpenAI, Anthropic, xAI, Google, Vertex, Bedrock), while \scrub\_cassette.py\ applies serializer redaction to existing cassettes. Verification scripts (\verify\_bedrock\_access.py\, \verify\_vertex\_gcs.py\, etc.) are added to validate cloud provider access and file handling capabilities.

scripts · high confidence

The \pydantic\ai/ui\ package has been restructured with a new \\\init\\_.py\ that explicitly exports core components like \UIAdapter\, \UIEventStream\, and \MessagesBuilder\, while lazily loading web-specific constants (\DEFAULT\_HTML\_URL\, \OFFLINE\_HTML\_URL\) to avoid unnecessary dependencies. A new \AGENTS.md\ document establishes a backward-compatibility policy for UI adapters (especially AG-UI), mandating that version requirement bumps are disallowed and new functionality must be gated behind version checks to ensure older versions skip unknown features rather than erroring out. This ensures that UI adapters remain stable across different installed versions of underlying protocols.

_pydantic\_ai\_slim/pydantic\ai/ui · high confidence

This update introduces the OpenAI Codex provider for ChatGPT/Codex subscriptions, which preserves prompt-cache affinity by injecting session and thread headers. It adds a \tool\_choice\ setting that lets users restrict or require specific function tools, and fixes a bug where Anthropic \CodeExecutionTool\ uploads failed to reach fresh containers in multi-turn histories by correcting block placement and adding retry logic. The models directory also includes guidelines for API design and error handling, an abstract model base class, and Bedrock token counting support.

_pydantic\_ai\_slim/pydantic\ai/models · high confidence

The \pydantic\_ai\ package has removed the \agent.py\, \function\_calls.py\, and \result.py\ modules. This eliminates the previous \Agent\ class implementation, the \CallInfo\ and system prompt protocols, and the \RunResult\/\RunStreamResult\ data structures, indicating a significant structural change to how agents are defined and how responses are handled.

_pydantic\ai · high confidence

The pydantic-ai library has undergone a major v2 preparation release, introducing several breaking changes and behavioral updates. The most significant change is the renaming of the \result\ attribute to \output\ on agent run results, affecting how users access the final output of an agent run. Additionally, the \result\ method on \StreamedRunResult\ has been removed in favor of property-style accessors like \.usage\, \.timestamp\, and \.response\. The library has also dropped support for Python 3.9, requiring Python 3.10 or later. Other behavioral changes include the deprecation of specifying a model name without a provider prefix, the removal of the Python evaluator for security reasons, and changes to how evaluation reports and report cases are structured as generic dataclasses. The release also includes updates to the web chat UI, support for new models across various providers, and improvements to streaming and tool handling.

pydantic-ai · high confidence

Added comprehensive test coverage for model profiles and schema transformers; Added comprehensive test suite for durable execution capabilities; Added comprehensive test suite for pydantic-evals; Added comprehensive test suite for the GraphBuilder API; Added test cassettes for Anthropic structured output and tool combinations; Added test cassettes for Azure Realtime WebSocket sessions; Added test cassettes for Google Gemini code execution and validated tool modes; Added tests for OpenRouter prompt caching and cost tracking; Added tests for Temporal durable execution; Added tests for graph utility functions and exception handling; Added tests for xAI model integrations; Bedrock test suite reorganization and expanded coverage; Expanded test coverage for tool approval and streaming teardown; New test infrastructure for model integration tests; Provider test suite added for Alibaba, Anthropic, Azure, Bedrock, Bedrock Mantle, Cerebras, Cohere, Crusoe, and DeepSeek.

The project has been restructured into a uv workspace containing six packages: the main \pydantic-ai\ shim, \pydantic-ai-slim\ (the core agent framework), \pydantic-graph\ (state machine library), \pydantic-evals\ (evaluation framework), \clai\ (CLI), and \examples\. This change introduces a new dynamic versioning system using \uv-dynamic-versioning\ and updates the minimum Python version to 3.10. The \pydantic-ai-slim\ package now declares direct dependencies on \anyio\>=4.7.0\, \griffelib\>=2.0\, \httpx2\>=2.7\, \pydantic\>=2.12\, and \genai-prices\>=0.1.6\, while optional extras have been updated to support newer SDK versions (e.g., \anthropic\>=1.3.0\, \google-genai\>=2.18.0\, \mistralai\>=2.9.2\). The root \pydantic-ai\ package now forwards these extras and adds new ones like \mcp-tasks\ and \spec\. Additionally, the workspace enforces security-driven constraint dependencies for transitive packages such as \urllib3\, \cryptography\, and \pillow\.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 71.

• Code Health 79
• Architecture 99
• Maturity 76
• Readiness 72
• Security 65

• 300 commits — 270 feature/other, 30 fixes

• pydantic_ai_slim/pydantic_ai — 119 commits
• (root) — 25 commits
• .github/workflows — 22 commits
• tests/models — 21 commits
• .github/scripts — 12 commits
• tests/durable_exec — 9 commits
• tests/realtime — 9 commits
• docs/models — 7 commits
• docs/navigation.yml — 7 commits
• docs/realtime — 6 commits
• pydantic_evals/pydantic_evals — 4 commits
• docs/capabilities — 3 commits
• docs/comparisons — 3 commits
• docs/durable_execution — 3 commits
• docs/evals — 3 commits
• docs/examples — 3 commits
• docs/index.md — 3 commits
• tests/test_streaming.py — 3 commits
• docs/enterprise-support.md — 2 commits
• docs/graph — 2 commits

• fix: Add transform_stream teardown regression tests (#7028)
• fix: Fix DeepSeek and Together forced tool_choice handling and support NativeOutput on DeepSeek's Responses API (#7450)
• fix: Fix OpenAI hosted tool_search pairing in AG-UI (#8313)
• fix: Fix CodeExecutionTool uploads never reaching a fresh Anthropic container on a multi-turn history (#7864)
• fix: Fix DeferredToolRequests.remaining resolving cross-category result IDs (#7626)
• fix: Fix TestModel generation for equal inclusive bounds (#7642)
• fix: Fix TestModel generation for narrow exclusive numeric bounds (#7800)
• fix: Fix TestModel generation of falsy JSON Schema const values (#7630)
• fix: Fix VercelAIAdapter rejecting reasoning part id in run input (#7706)
• fix: Fix VercelProvider dropping the Groq profile for groq/-prefixed models (#7551)
• fix: Fix XaiModel streamed text after a native tool call being merged into the ended pre-call part (#7925)
• fix: Fix defer_loading reveal synthesis splitting a parallel batch's tool_result from its tool_use (#7879)
• fix: Fix a SyncStreamBridge test flake: cancel the init watchdog before the liveness check (#7803)
• fix: Fix broken in-page docs links and check heading anchors in CI (#7693)
• fix: Fix dead MCP spec links in MCP client docs (#7220)
• fix: Fix dropped zero-argument tool calls in CohereModel (#7720)
• fix: Fix flaky tests: assert sync client event-loop affinity directly (#7738)
• fix: Fix gateway IDs being misclassified as OpenAI o-series models (#8512)
• fix: Fix real-time maintainer routing for opened issues (#7813)
• fix: Fix realtime and durable-execution skill guidance (#8086)
• …and 280 more

• 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

pydantic/pydantic-ai was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.