Merge main

Author: dmontagu

.github/workflows/after-ci.yml

@@ -17,12 +17,12 @@ jobs:
       - uses: astral-sh/setup-uv@v5
         with:
           enable-cache: true
-          python-version: '3.12'
+          python-version: "3.12"
 
       - uses: dawidd6/action-download-artifact@v6
         with:
           workflow: ci.yml
-          name: '(diff-)?coverage-html.*'
+          name: "(diff-)?coverage-html.*"
           name_is_regexp: true
           commit: ${{ github.event.workflow_run.head_sha }}
           allow_forks: true
@@ -39,16 +39,6 @@ jobs:
           SMOKESHOW_GITHUB_PR_HEAD_SHA: ${{ github.event.workflow_run.head_sha }}
           SMOKESHOW_AUTH_KEY: ${{ secrets.SMOKESHOW_AUTH_KEY }}
 
-      - run: uvx smokeshow upload diff-coverage-html
-        if: hashFiles('diff-coverage-html/*.html') != ''
-        env:
-          SMOKESHOW_GITHUB_STATUS_DESCRIPTION: Diff coverage {coverage-percentage}
-          SMOKESHOW_GITHUB_COVERAGE_THRESHOLD: 95
-          SMOKESHOW_GITHUB_CONTEXT: diff-coverage
-          SMOKESHOW_GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          SMOKESHOW_GITHUB_PR_HEAD_SHA: ${{ github.event.workflow_run.head_sha }}
-          SMOKESHOW_AUTH_KEY: ${{ secrets.SMOKESHOW_AUTH_KEY }}
-
   deploy-docs-preview:
     runs-on: ubuntu-latest
     if: github.event.workflow_run.event == 'pull_request'
@@ -65,7 +55,7 @@ jobs:
       - uses: astral-sh/setup-uv@v5
         with:
           enable-cache: true
-          python-version: '3.12'
+          python-version: "3.12"
 
       - uses: dawidd6/action-download-artifact@v6
         with:

.github/workflows/ci.yml

@@ -266,6 +266,13 @@ jobs:
         env:
           COVERAGE_FILE: .coverage/.coverage
 
+      - run: uv run coverage html --show-contexts --title "Pydantic AI coverage for ${{ github.sha }}"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: coverage-html
+          path: htmlcov
+          include-hidden-files: true
+
   test-mcp-run-python:
     runs-on: ubuntu-latest
     timeout-minutes: 5
@@ -292,7 +299,16 @@ jobs:
   # https://github.com/marketplace/actions/alls-green#why used for branch protection checks
   check:
     if: always()
-    needs: [lint, mypy, docs, test-live, test, test-lowest-versions, test-examples, coverage, test-mcp-run-python]
+    needs:
+      - lint
+      - mypy
+      - docs
+      - test-live
+      - test
+      - test-lowest-versions
+      - test-examples
+      - coverage
+      - test-mcp-run-python
     runs-on: ubuntu-latest
 
     steps:

AGENTS.md

@@ -0,0 +1 @@
+CLAUDE.md

docs/builtin-tools.md

@@ -4,10 +4,11 @@ Builtin tools are native tools provided by LLM providers that can be used to enh
 
 ## Overview
 
-PydanticAI supports two types of builtin tools:
+PydanticAI supports the following builtin tools:
 
 - **[`WebSearchTool`][pydantic_ai.builtin_tools.WebSearchTool]**: Allows agents to search the web
 - **[`CodeExecutionTool`][pydantic_ai.builtin_tools.CodeExecutionTool]**: Enables agents to execute code in a secure environment
+- **[`UrlContextTool`][pydantic_ai.builtin_tools.UrlContextTool]**: Enables agents to pull URL contents into their context
 
 These tools are passed to the agent via the `builtin_tools` parameter and are executed by the model provider's infrastructure.
 
@@ -26,7 +27,7 @@ making it ideal for queries that require up-to-date data.
 | OpenAI | ✅ | Full feature support |
 | Anthropic | ✅ | Full feature support |
 | Groq | ✅ | Limited parameter support |
-| Google | ❌ | Not supported |
+| Google | ✅ | No parameter support |
 | Bedrock | ❌ | Not supported |
 | Mistral | ❌ | Not supported |
 | Cohere | ❌ | Not supported |
@@ -118,6 +119,35 @@ result = agent.run_sync('Calculate the factorial of 15 and show your work')
 # > The factorial of 15 is **1,307,674,368,000**.
 ```
 
+## URL Context Tool
+
+The [`UrlContextTool`][pydantic_ai.builtin_tools.UrlContextTool] enables your agent to pull URL contents into its context,
+allowing it to pull up-to-date information from the web.
+
+### Provider Support
+
+| Provider | Supported |
+|----------|-----------|
+| Google | ✅ |
+| OpenAI | ❌ |
+| Anthropic | ❌ |
+| Groq | ❌ |
+| Bedrock | ❌ |
+| Mistral | ❌ |
+| Cohere | ❌ |
+| HuggingFace | ❌ |
+
+### Usage
+
+```py title="url_context_basic.py"
+from pydantic_ai import Agent, UrlContextTool
+
+agent = Agent('google-gla:gemini-2.5-flash', builtin_tools=[UrlContextTool()])
+
+result = agent.run_sync('What is this? https://ai.pydantic.dev')
+# > A Python agent framework for building Generative AI applications.
+```
+
 ## API Reference
 
 For complete API documentation, see the [API Reference](api/builtin_tools.md).

docs/mcp/run-python.md

@@ -32,15 +32,16 @@ where:
   so Pyodide can download and cache the Python standard library and packages
 - `--node-modules-dir=auto` tells deno to use a local `node_modules` directory
 - `stdio` runs the server with the
-  [Stdio MCP transport](https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#stdio)
-  — suitable for running the process as a subprocess locally
+  [Stdio MCP transport](https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#stdio) — suitable for
+  running the process as a subprocess locally
 - `streamable_http` runs the server with the
-  [Streamable HTTP MCP transport](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http)
-  — running the server as an HTTP server to connect locally or remotely.
-  This supports stateful requests, but does not require the client to hold a stateful connection like SSE
+  [Streamable HTTP MCP transport](https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#streamable-http) -
+  suitable for running the server as an HTTP server to connect locally or remotely. This supports stateful requests, but does not require the client to hold a stateful connection like SSE
 - `sse` runs the server with the
-  [SSE MCP transport](https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#http-with-sse)
-  — running the server as an HTTP server to connect locally or remotely
+  [SSE MCP transport](https://modelcontextprotocol.io/specification/2024-11-05/basic/transports#http-with-sse) —
+  suitable for running the server as an HTTP server to connect locally or remotely. Note that the SSE transport has been
+  [deprecated in newer MCP protocol versions](https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#backwards-compatibility)
+  and is there to maintain backwards compatibility.
 - `warmup` will run a minimal Python script to download and cache the Python
   standard library. This is also useful to check the server is running
   correctly.

docs/multi-agent-applications.md

@@ -48,7 +48,7 @@ async def joke_factory(ctx: RunContext[None], count: int) -> list[str]:
 
 result = joke_selection_agent.run_sync(
     'Tell me a joke.',
-    usage_limits=UsageLimits(request_limit=5, total_tokens_limit=300),
+    usage_limits=UsageLimits(request_limit=5, total_tokens_limit=500),
 )
 print(result.output)
 #> Did you hear about the toothpaste scandal? They called it Colgate.

docs/tools.md

@@ -471,7 +471,7 @@ _(This example is complete, it can be run "as is")_
 
 ### Custom Tool Schema
 
-If you have a function that lacks appropriate documentation (i.e. poorly named, no type information, poor docstring, use of \*args or \*\*kwargs and suchlike) then you can still turn it into a tool that can be effectively used by the agent with the [`Tool.from_schema`][pydantic_ai.Tool.from_schema] function. With this you provide the name, description and JSON schema for the function directly:
+If you have a function that lacks appropriate documentation (i.e. poorly named, no type information, poor docstring, use of \*args or \*\*kwargs and suchlike) then you can still turn it into a tool that can be effectively used by the agent with the [`Tool.from_schema`][pydantic_ai.Tool.from_schema] function. With this you provide the name, description, JSON schema, and whether the function takes a `RunContext` for the function directly:
 
 ```python
 from pydantic_ai import Agent, Tool
@@ -493,7 +493,8 @@ tool = Tool.from_schema(
         },
         'required': ['a', 'b'],
         'type': 'object',
-    }
+    },
+    takes_ctx=False,
 )
 
 test_model = TestModel()

mcp-run-python/README.md

@@ -12,7 +12,7 @@ The server can be run with `deno` installed using:
 ```bash
 deno run \
   -N -R=node_modules -W=node_modules --node-modules-dir=auto \
-  jsr:@pydantic/mcp-run-python [stdio|sse|warmup]
+  jsr:@pydantic/mcp-run-python [stdio|streamable_http|sse|warmup]
 ```
 
 where:
@@ -22,11 +22,17 @@ where:
   the Python standard library and packages
 - `--node-modules-dir=auto` tells deno to use a local `node_modules` directory
 - `stdio` runs the server with the
-  [Stdio MCP transport](https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#stdio) —
-  suitable for running the process as a subprocess locally
+  [Stdio MCP transport](https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#stdio) — suitable for
+  running the process as a subprocess locally
+- `streamable_http` runs the server with the
+  [Streamable HTTP MCP transport](https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#streamable-http) -
+  suitable for running the server as an HTTP server to connect locally or remotely. This supports stateful requests, but
+  does not require the client to hold a stateful connection like SSE
 - `sse` runs the server with the
-  [SSE MCP transport](https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#http-with-sse) —
-  running the server as an HTTP server to connect locally or remotely
+  [SSE MCP transport](https://modelcontextprotocol.io/specification/2024-11-05/basic/transports#http-with-sse) —
+  suitable for running the server as an HTTP server to connect locally or remotely. Note that the SSE transport has been
+  [deprecated in newer MCP protocol versions](https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#backwards-compatibility)
+  and is there to maintain backwards compatibility.
 - `warmup` will run a minimal Python script to download and cache the Python standard library. This is also useful to
   check the server is running correctly.
 

pydantic_ai_slim/pydantic_ai/__init__.py

@@ -1,7 +1,7 @@
 from importlib.metadata import version as _metadata_version
 
 from .agent import Agent, CallToolsNode, EndStrategy, ModelRequestNode, UserPromptNode, capture_run_messages
-from .builtin_tools import CodeExecutionTool, WebSearchTool, WebSearchUserLocation
+from .builtin_tools import CodeExecutionTool, UrlContextTool, WebSearchTool, WebSearchUserLocation
 from .exceptions import (
     AgentRunError,
     FallbackExceptionGroup,
@@ -45,6 +45,7 @@
     # builtin_tools
     'WebSearchTool',
     'WebSearchUserLocation',
+    'UrlContextTool',
     'CodeExecutionTool',
     # output
     'ToolOutput',

pydantic_ai_slim/pydantic_ai/_otel_messages.py

@@ -0,0 +1,67 @@
+"""Type definitions of OpenTelemetry GenAI spec message parts.
+
+Based on https://github.com/lmolkova/semantic-conventions/blob/eccd1f806e426a32c98271c3ce77585492d26de2/docs/gen-ai/non-normative/models.ipynb
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import JsonValue
+from typing_extensions import NotRequired, TypeAlias, TypedDict
+
+
+class TextPart(TypedDict):
+    type: Literal['text']
+    content: NotRequired[str]
+
+
+class ToolCallPart(TypedDict):
+    type: Literal['tool_call']
+    id: str
+    name: str
+    arguments: NotRequired[JsonValue]
+
+
+class ToolCallResponsePart(TypedDict):
+    type: Literal['tool_call_response']
+    id: str
+    name: str
+    result: NotRequired[JsonValue]
+
+
+class MediaUrlPart(TypedDict):
+    type: Literal['image-url', 'audio-url', 'video-url', 'document-url']
+    url: NotRequired[str]
+
+
+class BinaryDataPart(TypedDict):
+    type: Literal['binary']
+    media_type: str
+    content: NotRequired[str]
+
+
+class ThinkingPart(TypedDict):
+    type: Literal['thinking']
+    content: NotRequired[str]
+
+
+MessagePart: TypeAlias = 'TextPart | ToolCallPart | ToolCallResponsePart | MediaUrlPart | BinaryDataPart | ThinkingPart'
+
+
+Role = Literal['system', 'user', 'assistant']
+
+
+class ChatMessage(TypedDict):
+    role: Role
+    parts: list[MessagePart]
+
+
+InputMessages: TypeAlias = list[ChatMessage]
+
+
+class OutputMessage(ChatMessage):
+    finish_reason: NotRequired[str]
+
+
+OutputMessages: TypeAlias = list[OutputMessage]