pydantic-ai-slim 0.4.10__py3-none-any.whl → 0.4.11__py3-none-any.whl

pydantic_ai/_parts_manager.py

@@ -17,7 +17,6 @@ from collections.abc import Hashable
 from dataclasses import dataclass, field, replace
 from typing import Any, Union
 
-from pydantic_ai._thinking_part import END_THINK_TAG, START_THINK_TAG
 from pydantic_ai.exceptions import UnexpectedModelBehavior
 from pydantic_ai.messages import (
     ModelResponsePart,
@@ -72,7 +71,7 @@ class ModelResponsePartsManager:
         *,
         vendor_part_id: VendorId | None,
         content: str,
-        extract_think_tags: bool = False,
+        thinking_tags: tuple[str, str] | None = None,
     ) -> ModelResponseStreamEvent | None:
         """Handle incoming text content, creating or updating a TextPart in the manager as appropriate.
 
@@ -85,7 +84,7 @@ class ModelResponsePartsManager:
                 of text. If None, a new part will be created unless the latest part is already
                 a TextPart.
             content: The text content to append to the appropriate TextPart.
-            extract_think_tags: Whether to extract `<think>` tags from the text content and handle them as thinking parts.
+            thinking_tags: If provided, will handle content between the thinking tags as thinking parts.
 
         Returns:
             - A `PartStartEvent` if a new part was created.
@@ -110,10 +109,10 @@ class ModelResponsePartsManager:
             if part_index is not None:
                 existing_part = self._parts[part_index]
 
-                if extract_think_tags and isinstance(existing_part, ThinkingPart):
-                    # We may be building a thinking part instead of a text part if we had previously seen a `<think>` tag
-                    if content == END_THINK_TAG:
-                        # When we see `</think>`, we're done with the thinking part and the next text delta will need a new part
+                if thinking_tags and isinstance(existing_part, ThinkingPart):
+                    # We may be building a thinking part instead of a text part if we had previously seen a thinking tag
+                    if content == thinking_tags[1]:
+                        # When we see the thinking end tag, we're done with the thinking part and the next text delta will need a new part
                         self._vendor_id_to_part_index.pop(vendor_part_id)
                         return None
                     else:
@@ -123,8 +122,8 @@ class ModelResponsePartsManager:
                 else:
                     raise UnexpectedModelBehavior(f'Cannot apply a text delta to {existing_part=}')
 
-        if extract_think_tags and content == START_THINK_TAG:
-            # When we see a `<think>` tag (which is a single token), we'll build a new thinking part instead
+        if thinking_tags and content == thinking_tags[0]:
+            # When we see a thinking start tag (which is a single token), we'll build a new thinking part instead
             self._vendor_id_to_part_index.pop(vendor_part_id, None)
             return self.handle_thinking_delta(vendor_part_id=vendor_part_id, content='')
 

pydantic_ai/_thinking_part.py

@@ -2,35 +2,30 @@ from __future__ import annotations as _annotations
 
 from pydantic_ai.messages import TextPart, ThinkingPart
 
-START_THINK_TAG = '<think>'
-END_THINK_TAG = '</think>'
 
-
-def split_content_into_text_and_thinking(content: str) -> list[ThinkingPart | TextPart]:
+def split_content_into_text_and_thinking(content: str, thinking_tags: tuple[str, str]) -> list[ThinkingPart | TextPart]:
     """Split a string into text and thinking parts.
 
     Some models don't return the thinking part as a separate part, but rather as a tag in the content.
     This function splits the content into text and thinking parts.
-
-    We use the `<think>` tag because that's how Groq uses it in the `raw` format, so instead of using `<Thinking>` or
-    something else, we just match the tag to make it easier for other models that don't support the `ThinkingPart`.
     """
+    start_tag, end_tag = thinking_tags
     parts: list[ThinkingPart | TextPart] = []
 
-    start_index = content.find(START_THINK_TAG)
+    start_index = content.find(start_tag)
     while start_index >= 0:
-        before_think, content = content[:start_index], content[start_index + len(START_THINK_TAG) :]
+        before_think, content = content[:start_index], content[start_index + len(start_tag) :]
         if before_think:
             parts.append(TextPart(content=before_think))
-        end_index = content.find(END_THINK_TAG)
+        end_index = content.find(end_tag)
         if end_index >= 0:
-            think_content, content = content[:end_index], content[end_index + len(END_THINK_TAG) :]
+            think_content, content = content[:end_index], content[end_index + len(end_tag) :]
             parts.append(ThinkingPart(content=think_content))
         else:
             # We lose the `<think>` tag, but it shouldn't matter.
             parts.append(TextPart(content=content))
             content = ''
-        start_index = content.find(START_THINK_TAG)
+        start_index = content.find(start_tag)
     if content:
         parts.append(TextPart(content=content))
     return parts

pydantic_ai/ag_ui.py

@@ -8,11 +8,10 @@ from __future__ import annotations
 
 import json
 import uuid
-from collections.abc import Iterable, Mapping, Sequence
-from dataclasses import Field, dataclass, field, replace
+from collections.abc import AsyncIterator, Iterable, Mapping, Sequence
+from dataclasses import Field, dataclass, replace
 from http import HTTPStatus
 from typing import (
-    TYPE_CHECKING,
     Any,
     Callable,
     ClassVar,
@@ -23,10 +22,36 @@ from typing import (
     runtime_checkable,
 )
 
-from pydantic_ai.exceptions import UserError
+from pydantic import BaseModel, ValidationError
 
-if TYPE_CHECKING:
-    pass
+from ._agent_graph import CallToolsNode, ModelRequestNode
+from .agent import Agent, AgentRun
+from .exceptions import UserError
+from .messages import (
+    AgentStreamEvent,
+    FunctionToolResultEvent,
+    ModelMessage,
+    ModelRequest,
+    ModelResponse,
+    PartDeltaEvent,
+    PartStartEvent,
+    SystemPromptPart,
+    TextPart,
+    TextPartDelta,
+    ThinkingPart,
+    ThinkingPartDelta,
+    ToolCallPart,
+    ToolCallPartDelta,
+    ToolReturnPart,
+    UserPromptPart,
+)
+from .models import KnownModelName, Model
+from .output import DeferredToolCalls, OutputDataT, OutputSpec
+from .settings import ModelSettings
+from .tools import AgentDepsT, ToolDefinition
+from .toolsets import AbstractToolset
+from .toolsets.deferred import DeferredToolset
+from .usage import Usage, UsageLimits
 
 try:
     from ag_ui.core import (
@@ -74,43 +99,13 @@ except ImportError as e:  # pragma: no cover
         'you can use the `ag-ui` optional group — `pip install "pydantic-ai-slim[ag-ui]"`'
     ) from e
 
-from collections.abc import AsyncGenerator
-
-from pydantic import BaseModel, ValidationError
-
-from ._agent_graph import CallToolsNode, ModelRequestNode
-from .agent import Agent, AgentRun, RunOutputDataT
-from .messages import (
-    AgentStreamEvent,
-    FunctionToolResultEvent,
-    ModelMessage,
-    ModelRequest,
-    ModelResponse,
-    PartDeltaEvent,
-    PartStartEvent,
-    SystemPromptPart,
-    TextPart,
-    TextPartDelta,
-    ThinkingPart,
-    ThinkingPartDelta,
-    ToolCallPart,
-    ToolCallPartDelta,
-    ToolReturnPart,
-    UserPromptPart,
-)
-from .models import KnownModelName, Model
-from .output import DeferredToolCalls, OutputDataT, OutputSpec
-from .settings import ModelSettings
-from .tools import AgentDepsT, ToolDefinition
-from .toolsets import AbstractToolset
-from .toolsets.deferred import DeferredToolset
-from .usage import Usage, UsageLimits
-
 __all__ = [
     'SSE_CONTENT_TYPE',
     'StateDeps',
     'StateHandler',
     'AGUIApp',
+    'handle_ag_ui_request',
+    'run_ag_ui',
 ]
 
 SSE_CONTENT_TYPE: Final[str] = 'text/event-stream'
@@ -125,7 +120,7 @@ class AGUIApp(Generic[AgentDepsT, OutputDataT], Starlette):
         agent: Agent[AgentDepsT, OutputDataT],
         *,
         # Agent.iter parameters.
-        output_type: OutputSpec[OutputDataT] | None = None,
+        output_type: OutputSpec[Any] | None = None,
         model: Model | KnownModelName | str | None = None,
         deps: AgentDepsT = None,
         model_settings: ModelSettings | None = None,
@@ -142,10 +137,16 @@ class AGUIApp(Generic[AgentDepsT, OutputDataT], Starlette):
         on_shutdown: Sequence[Callable[[], Any]] | None = None,
         lifespan: Lifespan[AGUIApp[AgentDepsT, OutputDataT]] | None = None,
     ) -> None:
-        """Initialise the AG-UI application.
+        """An ASGI application that handles every AG-UI request by running the agent.
+
+        Note that the `deps` will be the same for each request, with the exception of the AG-UI state that's
+        injected into the `state` field of a `deps` object that implements the [`StateHandler`][pydantic_ai.ag_ui.StateHandler] protocol.
+        To provide different `deps` for each request (e.g. based on the authenticated user),
+        use [`pydantic_ai.ag_ui.run_ag_ui`][pydantic_ai.ag_ui.run_ag_ui] or
+        [`pydantic_ai.ag_ui.handle_ag_ui_request`][pydantic_ai.ag_ui.handle_ag_ui_request] instead.
 
         Args:
-            agent: The Pydantic AI `Agent` to adapt.
+            agent: The agent to run.
 
             output_type: Custom output type to use for this run, `output_type` may only be used if the agent has
                 no output validators since output validators would expect an argument that matches the agent's
@@ -156,7 +157,7 @@ class AGUIApp(Generic[AgentDepsT, OutputDataT], Starlette):
             usage_limits: Optional limits on model request count or token usage.
             usage: Optional usage to start with, useful for resuming a conversation or agents used in tools.
             infer_name: Whether to try to infer the agent name from the call frame if it's not set.
-            toolsets: Optional list of toolsets to use for this agent, defaults to the agent's toolset.
+            toolsets: Optional additional toolsets for this run.
 
             debug: Boolean indicating if debug tracebacks should be returned on errors.
             routes: A list of routes to serve incoming HTTP and WebSocket requests.
@@ -185,320 +186,349 @@ class AGUIApp(Generic[AgentDepsT, OutputDataT], Starlette):
             on_shutdown=on_shutdown,
             lifespan=lifespan,
         )
-        adapter = _Adapter(agent=agent)
 
-        async def endpoint(request: Request) -> Response | StreamingResponse:
+        async def endpoint(request: Request) -> Response:
             """Endpoint to run the agent with the provided input data."""
-            accept = request.headers.get('accept', SSE_CONTENT_TYPE)
-            try:
-                input_data = RunAgentInput.model_validate(await request.json())
-            except ValidationError as e:  # pragma: no cover
-                return Response(
-                    content=json.dumps(e.json()),
-                    media_type='application/json',
-                    status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
-                )
-
-            return StreamingResponse(
-                adapter.run(
-                    input_data,
-                    accept,
-                    output_type=output_type,
-                    model=model,
-                    deps=deps,
-                    model_settings=model_settings,
-                    usage_limits=usage_limits,
-                    usage=usage,
-                    infer_name=infer_name,
-                    toolsets=toolsets,
-                ),
-                media_type=SSE_CONTENT_TYPE,
+            return await handle_ag_ui_request(
+                agent,
+                request,
+                output_type=output_type,
+                model=model,
+                deps=deps,
+                model_settings=model_settings,
+                usage_limits=usage_limits,
+                usage=usage,
+                infer_name=infer_name,
+                toolsets=toolsets,
             )
 
         self.router.add_route('/', endpoint, methods=['POST'], name='run_agent')
 
 
-@dataclass(repr=False)
-class _Adapter(Generic[AgentDepsT, OutputDataT]):
-    """An agent adapter providing AG-UI protocol support for Pydantic AI agents.
-
-    This class manages the agent runs, tool calls, state storage and providing
-    an adapter for running agents with Server-Sent Event (SSE) streaming
-    responses using the AG-UI protocol.
+async def handle_ag_ui_request(
+    agent: Agent[AgentDepsT, Any],
+    request: Request,
+    *,
+    output_type: OutputSpec[Any] | None = None,
+    model: Model | KnownModelName | str | None = None,
+    deps: AgentDepsT = None,
+    model_settings: ModelSettings | None = None,
+    usage_limits: UsageLimits | None = None,
+    usage: Usage | None = None,
+    infer_name: bool = True,
+    toolsets: Sequence[AbstractToolset[AgentDepsT]] | None = None,
+) -> Response:
+    """Handle an AG-UI request by running the agent and returning a streaming response.
 
     Args:
-        agent: The Pydantic AI `Agent` to adapt.
+        agent: The agent to run.
+        request: The Starlette request (e.g. from FastAPI) containing the AG-UI run input.
+
+        output_type: Custom output type to use for this run, `output_type` may only be used if the agent has no
+            output validators since output validators would expect an argument that matches the agent's output type.
+        model: Optional model to use for this run, required if `model` was not set when creating the agent.
+        deps: Optional dependencies to use for this run.
+        model_settings: Optional settings to use for this model's request.
+        usage_limits: Optional limits on model request count or token usage.
+        usage: Optional usage to start with, useful for resuming a conversation or agents used in tools.
+        infer_name: Whether to try to infer the agent name from the call frame if it's not set.
+        toolsets: Optional additional toolsets for this run.
+
+    Returns:
+        A streaming Starlette response with AG-UI protocol events.
     """
+    accept = request.headers.get('accept', SSE_CONTENT_TYPE)
+    try:
+        input_data = RunAgentInput.model_validate(await request.json())
+    except ValidationError as e:  # pragma: no cover
+        return Response(
+            content=json.dumps(e.json()),
+            media_type='application/json',
+            status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+        )
 
-    agent: Agent[AgentDepsT, OutputDataT] = field(repr=False)
-
-    async def run(
-        self,
-        run_input: RunAgentInput,
-        accept: str = SSE_CONTENT_TYPE,
-        *,
-        output_type: OutputSpec[RunOutputDataT] | None = None,
-        model: Model | KnownModelName | str | None = None,
-        deps: AgentDepsT = None,
-        model_settings: ModelSettings | None = None,
-        usage_limits: UsageLimits | None = None,
-        usage: Usage | None = None,
-        infer_name: bool = True,
-        toolsets: Sequence[AbstractToolset[AgentDepsT]] | None = None,
-    ) -> AsyncGenerator[str, None]:
-        """Run the agent with streaming response using AG-UI protocol events.
+    return StreamingResponse(
+        run_ag_ui(
+            agent,
+            input_data,
+            accept,
+            output_type=output_type,
+            model=model,
+            deps=deps,
+            model_settings=model_settings,
+            usage_limits=usage_limits,
+            usage=usage,
+            infer_name=infer_name,
+            toolsets=toolsets,
+        ),
+        media_type=accept,
+    )
 
-        The first two arguments are specific to `Adapter` the rest map directly to the `Agent.iter` method.
 
-        Args:
-            run_input: The AG-UI run input containing thread_id, run_id, messages, etc.
-            accept: The accept header value for the run.
+async def run_ag_ui(
+    agent: Agent[AgentDepsT, Any],
+    run_input: RunAgentInput,
+    accept: str = SSE_CONTENT_TYPE,
+    *,
+    output_type: OutputSpec[Any] | None = None,
+    model: Model | KnownModelName | str | None = None,
+    deps: AgentDepsT = None,
+    model_settings: ModelSettings | None = None,
+    usage_limits: UsageLimits | None = None,
+    usage: Usage | None = None,
+    infer_name: bool = True,
+    toolsets: Sequence[AbstractToolset[AgentDepsT]] | None = None,
+) -> AsyncIterator[str]:
+    """Run the agent with the AG-UI run input and stream AG-UI protocol events.
 
-            output_type: Custom output type to use for this run, `output_type` may only be used if the agent has no
-                output validators since output validators would expect an argument that matches the agent's output type.
-            model: Optional model to use for this run, required if `model` was not set when creating the agent.
-            deps: Optional dependencies to use for this run.
-            model_settings: Optional settings to use for this model's request.
-            usage_limits: Optional limits on model request count or token usage.
-            usage: Optional usage to start with, useful for resuming a conversation or agents used in tools.
-            infer_name: Whether to try to infer the agent name from the call frame if it's not set.
-            toolsets: Optional list of toolsets to use for this agent, defaults to the agent's toolset.
+    Args:
+        agent: The agent to run.
+        run_input: The AG-UI run input containing thread_id, run_id, messages, etc.
+        accept: The accept header value for the run.
+
+        output_type: Custom output type to use for this run, `output_type` may only be used if the agent has no
+            output validators since output validators would expect an argument that matches the agent's output type.
+        model: Optional model to use for this run, required if `model` was not set when creating the agent.
+        deps: Optional dependencies to use for this run.
+        model_settings: Optional settings to use for this model's request.
+        usage_limits: Optional limits on model request count or token usage.
+        usage: Optional usage to start with, useful for resuming a conversation or agents used in tools.
+        infer_name: Whether to try to infer the agent name from the call frame if it's not set.
+        toolsets: Optional additional toolsets for this run.
+
+    Yields:
+        Streaming event chunks encoded as strings according to the accept header value.
+    """
+    encoder = EventEncoder(accept=accept)
+    if run_input.tools:
+        # AG-UI tools can't be prefixed as that would result in a mismatch between the tool names in the
+        # Pydantic AI events and actual AG-UI tool names, preventing the tool from being called. If any
+        # conflicts arise, the AG-UI tool should be renamed or a `PrefixedToolset` used for local toolsets.
+        toolset = DeferredToolset[AgentDepsT](
+            [
+                ToolDefinition(
+                    name=tool.name,
+                    description=tool.description,
+                    parameters_json_schema=tool.parameters,
+                )
+                for tool in run_input.tools
+            ]
+        )
+        toolsets = [*toolsets, toolset] if toolsets else [toolset]
+
+    try:
+        yield encoder.encode(
+            RunStartedEvent(
+                thread_id=run_input.thread_id,
+                run_id=run_input.run_id,
+            ),
+        )
 
-        Yields:
-            Streaming SSE-formatted event chunks.
-        """
-        encoder = EventEncoder(accept=accept)
-        if run_input.tools:
-            # AG-UI tools can't be prefixed as that would result in a mismatch between the tool names in the
-            # Pydantic AI events and actual AG-UI tool names, preventing the tool from being called. If any
-            # conflicts arise, the AG-UI tool should be renamed or a `PrefixedToolset` used for local toolsets.
-            toolset = DeferredToolset[AgentDepsT](
-                [
-                    ToolDefinition(
-                        name=tool.name,
-                        description=tool.description,
-                        parameters_json_schema=tool.parameters,
-                    )
-                    for tool in run_input.tools
-                ]
-            )
-            toolsets = [*toolsets, toolset] if toolsets else [toolset]
-
-        try:
-            yield encoder.encode(
-                RunStartedEvent(
-                    thread_id=run_input.thread_id,
-                    run_id=run_input.run_id,
-                ),
-            )
+        if not run_input.messages:
+            raise _NoMessagesError
 
-            if not run_input.messages:
-                raise _NoMessagesError
-
-            raw_state: dict[str, Any] = run_input.state or {}
-            if isinstance(deps, StateHandler):
-                if isinstance(deps.state, BaseModel):
-                    try:
-                        state = type(deps.state).model_validate(raw_state)
-                    except ValidationError as e:  # pragma: no cover
-                        raise _InvalidStateError from e
-                else:
-                    state = raw_state
-
-                deps = replace(deps, state=state)
-            elif raw_state:
-                raise UserError(
-                    f'AG-UI state is provided but `deps` of type `{type(deps).__name__}` does not implement the `StateHandler` protocol: it needs to be a dataclass with a non-optional `state` field.'
-                )
+        raw_state: dict[str, Any] = run_input.state or {}
+        if isinstance(deps, StateHandler):
+            if isinstance(deps.state, BaseModel):
+                try:
+                    state = type(deps.state).model_validate(raw_state)
+                except ValidationError as e:  # pragma: no cover
+                    raise _InvalidStateError from e
             else:
-                # `deps` not being a `StateHandler` is OK if there is no state.
-                pass
-
-            messages = _messages_from_ag_ui(run_input.messages)
+                state = raw_state
 
-            async with self.agent.iter(
-                user_prompt=None,
-                output_type=[output_type or self.agent.output_type, DeferredToolCalls],
-                message_history=messages,
-                model=model,
-                deps=deps,
-                model_settings=model_settings,
-                usage_limits=usage_limits,
-                usage=usage,
-                infer_name=infer_name,
-                toolsets=toolsets,
-            ) as run:
-                async for event in self._agent_stream(run):
-                    yield encoder.encode(event)
-        except _RunError as e:
-            yield encoder.encode(
-                RunErrorEvent(message=e.message, code=e.code),
-            )
-        except Exception as e:
-            yield encoder.encode(
-                RunErrorEvent(message=str(e)),
+            deps = replace(deps, state=state)
+        elif raw_state:
+            raise UserError(
+                f'AG-UI state is provided but `deps` of type `{type(deps).__name__}` does not implement the `StateHandler` protocol: it needs to be a dataclass with a non-optional `state` field.'
             )
-            raise e
         else:
-            yield encoder.encode(
-                RunFinishedEvent(
-                    thread_id=run_input.thread_id,
-                    run_id=run_input.run_id,
-                ),
-            )
+            # `deps` not being a `StateHandler` is OK if there is no state.
+            pass
 
-    async def _agent_stream(
-        self,
-        run: AgentRun[AgentDepsT, Any],
-    ) -> AsyncGenerator[BaseEvent, None]:
-        """Run the agent streaming responses using AG-UI protocol events.
+        messages = _messages_from_ag_ui(run_input.messages)
+
+        async with agent.iter(
+            user_prompt=None,
+            output_type=[output_type or agent.output_type, DeferredToolCalls],
+            message_history=messages,
+            model=model,
+            deps=deps,
+            model_settings=model_settings,
+            usage_limits=usage_limits,
+            usage=usage,
+            infer_name=infer_name,
+            toolsets=toolsets,
+        ) as run:
+            async for event in _agent_stream(run):
+                yield encoder.encode(event)
+    except _RunError as e:
+        yield encoder.encode(
+            RunErrorEvent(message=e.message, code=e.code),
+        )
+    except Exception as e:
+        yield encoder.encode(
+            RunErrorEvent(message=str(e)),
+        )
+        raise e
+    else:
+        yield encoder.encode(
+            RunFinishedEvent(
+                thread_id=run_input.thread_id,
+                run_id=run_input.run_id,
+            ),
+        )
 
-        Args:
-            run: The agent run to process.
 
-        Yields:
-            AG-UI Server-Sent Events (SSE).
-        """
-        async for node in run:
-            stream_ctx = _RequestStreamContext()
-            if isinstance(node, ModelRequestNode):
-                async with node.stream(run.ctx) as request_stream:
-                    async for agent_event in request_stream:
-                        async for msg in self._handle_model_request_event(stream_ctx, agent_event):
+async def _agent_stream(run: AgentRun[AgentDepsT, Any]) -> AsyncIterator[BaseEvent]:
+    """Run the agent streaming responses using AG-UI protocol events.
+
+    Args:
+        run: The agent run to process.
+
+    Yields:
+        AG-UI Server-Sent Events (SSE).
+    """
+    async for node in run:
+        stream_ctx = _RequestStreamContext()
+        if isinstance(node, ModelRequestNode):
+            async with node.stream(run.ctx) as request_stream:
+                async for agent_event in request_stream:
+                    async for msg in _handle_model_request_event(stream_ctx, agent_event):
+                        yield msg
+
+                if stream_ctx.part_end:  # pragma: no branch
+                    yield stream_ctx.part_end
+                    stream_ctx.part_end = None
+        elif isinstance(node, CallToolsNode):
+            async with node.stream(run.ctx) as handle_stream:
+                async for event in handle_stream:
+                    if isinstance(event, FunctionToolResultEvent):
+                        async for msg in _handle_tool_result_event(stream_ctx, event):
                             yield msg
 
-                    if stream_ctx.part_end:  # pragma: no branch
-                        yield stream_ctx.part_end
-                        stream_ctx.part_end = None
-            elif isinstance(node, CallToolsNode):
-                async with node.stream(run.ctx) as handle_stream:
-                    async for event in handle_stream:
-                        if isinstance(event, FunctionToolResultEvent):
-                            async for msg in self._handle_tool_result_event(stream_ctx, event):
-                                yield msg
-
-    async def _handle_model_request_event(
-        self,
-        stream_ctx: _RequestStreamContext,
-        agent_event: AgentStreamEvent,
-    ) -> AsyncGenerator[BaseEvent, None]:
-        """Handle an agent event and yield AG-UI protocol events.
 
-        Args:
-            stream_ctx: The request stream context to manage state.
-            agent_event: The agent event to process.
+async def _handle_model_request_event(
+    stream_ctx: _RequestStreamContext,
+    agent_event: AgentStreamEvent,
+) -> AsyncIterator[BaseEvent]:
+    """Handle an agent event and yield AG-UI protocol events.
 
-        Yields:
-            AG-UI Server-Sent Events (SSE) based on the agent event.
-        """
-        if isinstance(agent_event, PartStartEvent):
-            if stream_ctx.part_end:
-                # End the previous part.
-                yield stream_ctx.part_end
-                stream_ctx.part_end = None
-
-            part = agent_event.part
-            if isinstance(part, TextPart):
-                message_id = stream_ctx.new_message_id()
-                yield TextMessageStartEvent(
-                    message_id=message_id,
-                )
-                if part.content:  # pragma: no branch
-                    yield TextMessageContentEvent(
-                        message_id=message_id,
-                        delta=part.content,
-                    )
-                stream_ctx.part_end = TextMessageEndEvent(
+    Args:
+        stream_ctx: The request stream context to manage state.
+        agent_event: The agent event to process.
+
+    Yields:
+        AG-UI Server-Sent Events (SSE) based on the agent event.
+    """
+    if isinstance(agent_event, PartStartEvent):
+        if stream_ctx.part_end:
+            # End the previous part.
+            yield stream_ctx.part_end
+            stream_ctx.part_end = None
+
+        part = agent_event.part
+        if isinstance(part, TextPart):
+            message_id = stream_ctx.new_message_id()
+            yield TextMessageStartEvent(
+                message_id=message_id,
+            )
+            if part.content:  # pragma: no branch
+                yield TextMessageContentEvent(
                     message_id=message_id,
+                    delta=part.content,
                 )
-            elif isinstance(part, ToolCallPart):  # pragma: no branch
-                message_id = stream_ctx.message_id or stream_ctx.new_message_id()
-                yield ToolCallStartEvent(
-                    tool_call_id=part.tool_call_id,
-                    tool_call_name=part.tool_name,
-                    parent_message_id=message_id,
-                )
-                if part.args:
-                    yield ToolCallArgsEvent(
-                        tool_call_id=part.tool_call_id,
-                        delta=part.args if isinstance(part.args, str) else json.dumps(part.args),
-                    )
-                stream_ctx.part_end = ToolCallEndEvent(
+            stream_ctx.part_end = TextMessageEndEvent(
+                message_id=message_id,
+            )
+        elif isinstance(part, ToolCallPart):  # pragma: no branch
+            message_id = stream_ctx.message_id or stream_ctx.new_message_id()
+            yield ToolCallStartEvent(
+                tool_call_id=part.tool_call_id,
+                tool_call_name=part.tool_name,
+                parent_message_id=message_id,
+            )
+            if part.args:
+                yield ToolCallArgsEvent(
                     tool_call_id=part.tool_call_id,
+                    delta=part.args if isinstance(part.args, str) else json.dumps(part.args),
                 )
+            stream_ctx.part_end = ToolCallEndEvent(
+                tool_call_id=part.tool_call_id,
+            )
 
-            elif isinstance(part, ThinkingPart):  # pragma: no branch
-                yield ThinkingTextMessageStartEvent(
-                    type=EventType.THINKING_TEXT_MESSAGE_START,
-                )
-                # Always send the content even if it's empty, as it may be
-                # used to indicate the start of thinking.
+        elif isinstance(part, ThinkingPart):  # pragma: no branch
+            yield ThinkingTextMessageStartEvent(
+                type=EventType.THINKING_TEXT_MESSAGE_START,
+            )
+            # Always send the content even if it's empty, as it may be
+            # used to indicate the start of thinking.
+            yield ThinkingTextMessageContentEvent(
+                type=EventType.THINKING_TEXT_MESSAGE_CONTENT,
+                delta=part.content,
+            )
+            stream_ctx.part_end = ThinkingTextMessageEndEvent(
+                type=EventType.THINKING_TEXT_MESSAGE_END,
+            )
+
+    elif isinstance(agent_event, PartDeltaEvent):
+        delta = agent_event.delta
+        if isinstance(delta, TextPartDelta):
+            yield TextMessageContentEvent(
+                message_id=stream_ctx.message_id,
+                delta=delta.content_delta,
+            )
+        elif isinstance(delta, ToolCallPartDelta):  # pragma: no branch
+            assert delta.tool_call_id, '`ToolCallPartDelta.tool_call_id` must be set'
+            yield ToolCallArgsEvent(
+                tool_call_id=delta.tool_call_id,
+                delta=delta.args_delta if isinstance(delta.args_delta, str) else json.dumps(delta.args_delta),
+            )
+        elif isinstance(delta, ThinkingPartDelta):  # pragma: no branch
+            if delta.content_delta:  # pragma: no branch
                 yield ThinkingTextMessageContentEvent(
                     type=EventType.THINKING_TEXT_MESSAGE_CONTENT,
-                    delta=part.content,
-                )
-                stream_ctx.part_end = ThinkingTextMessageEndEvent(
-                    type=EventType.THINKING_TEXT_MESSAGE_END,
-                )
-
-        elif isinstance(agent_event, PartDeltaEvent):
-            delta = agent_event.delta
-            if isinstance(delta, TextPartDelta):
-                yield TextMessageContentEvent(
-                    message_id=stream_ctx.message_id,
                     delta=delta.content_delta,
                 )
-            elif isinstance(delta, ToolCallPartDelta):  # pragma: no branch
-                assert delta.tool_call_id, '`ToolCallPartDelta.tool_call_id` must be set'
-                yield ToolCallArgsEvent(
-                    tool_call_id=delta.tool_call_id,
-                    delta=delta.args_delta if isinstance(delta.args_delta, str) else json.dumps(delta.args_delta),
-                )
-            elif isinstance(delta, ThinkingPartDelta):  # pragma: no branch
-                if delta.content_delta:  # pragma: no branch
-                    yield ThinkingTextMessageContentEvent(
-                        type=EventType.THINKING_TEXT_MESSAGE_CONTENT,
-                        delta=delta.content_delta,
-                    )
 
-    async def _handle_tool_result_event(
-        self,
-        stream_ctx: _RequestStreamContext,
-        event: FunctionToolResultEvent,
-    ) -> AsyncGenerator[BaseEvent, None]:
-        """Convert a tool call result to AG-UI events.
 
-        Args:
-            stream_ctx: The request stream context to manage state.
-            event: The tool call result event to process.
+async def _handle_tool_result_event(
+    stream_ctx: _RequestStreamContext,
+    event: FunctionToolResultEvent,
+) -> AsyncIterator[BaseEvent]:
+    """Convert a tool call result to AG-UI events.
 
-        Yields:
-            AG-UI Server-Sent Events (SSE).
-        """
-        result = event.result
-        if not isinstance(result, ToolReturnPart):
-            return
-
-        message_id = stream_ctx.new_message_id()
-        yield ToolCallResultEvent(
-            message_id=message_id,
-            type=EventType.TOOL_CALL_RESULT,
-            role='tool',
-            tool_call_id=result.tool_call_id,
-            content=result.model_response_str(),
-        )
+    Args:
+        stream_ctx: The request stream context to manage state.
+        event: The tool call result event to process.
 
-        # Now check for  AG-UI events returned by the tool calls.
-        content = result.content
-        if isinstance(content, BaseEvent):
-            yield content
-        elif isinstance(content, (str, bytes)):  # pragma: no branch
-            # Avoid iterable check for strings and bytes.
-            pass
-        elif isinstance(content, Iterable):  # pragma: no branch
-            for item in content:  # type: ignore[reportUnknownMemberType]
-                if isinstance(item, BaseEvent):  # pragma: no branch
-                    yield item
+    Yields:
+        AG-UI Server-Sent Events (SSE).
+    """
+    result = event.result
+    if not isinstance(result, ToolReturnPart):
+        return
+
+    message_id = stream_ctx.new_message_id()
+    yield ToolCallResultEvent(
+        message_id=message_id,
+        type=EventType.TOOL_CALL_RESULT,
+        role='tool',
+        tool_call_id=result.tool_call_id,
+        content=result.model_response_str(),
+    )
+
+    # Now check for  AG-UI events returned by the tool calls.
+    content = result.content
+    if isinstance(content, BaseEvent):
+        yield content
+    elif isinstance(content, (str, bytes)):  # pragma: no branch
+        # Avoid iterable check for strings and bytes.
+        pass
+    elif isinstance(content, Iterable):  # pragma: no branch
+        for item in content:  # type: ignore[reportUnknownMemberType]
+            if isinstance(item, BaseEvent):  # pragma: no branch
+                yield item
 
 
 def _messages_from_ag_ui(messages: list[Message]) -> list[ModelMessage]:

pydantic_ai/agent.py

@@ -1870,9 +1870,13 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
         on_shutdown: Sequence[Callable[[], Any]] | None = None,
         lifespan: Lifespan[AGUIApp[AgentDepsT, OutputDataT]] | None = None,
     ) -> AGUIApp[AgentDepsT, OutputDataT]:
-        """Convert the agent to an AG-UI application.
+        """Returns an ASGI application that handles every AG-UI request by running the agent.
 
-        This allows you to use the agent with a compatible AG-UI frontend.
+        Note that the `deps` will be the same for each request, with the exception of the AG-UI state that's
+        injected into the `state` field of a `deps` object that implements the [`StateHandler`][pydantic_ai.ag_ui.StateHandler] protocol.
+        To provide different `deps` for each request (e.g. based on the authenticated user),
+        use [`pydantic_ai.ag_ui.run_ag_ui`][pydantic_ai.ag_ui.run_ag_ui] or
+        [`pydantic_ai.ag_ui.handle_ag_ui_request`][pydantic_ai.ag_ui.handle_ag_ui_request] instead.
 
         Example:
         ```python
@@ -1882,8 +1886,6 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
         app = agent.to_ag_ui()
         ```
 
-        The `app` is an ASGI application that can be used with any ASGI server.
-
         To run the application, you can use the following command:
 
         ```bash
@@ -1902,7 +1904,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
             usage_limits: Optional limits on model request count or token usage.
             usage: Optional usage to start with, useful for resuming a conversation or agents used in tools.
             infer_name: Whether to try to infer the agent name from the call frame if it's not set.
-            toolsets: Optional list of toolsets to use for this agent, defaults to the agent's toolset.
+            toolsets: Optional additional toolsets for this run.
 
             debug: Boolean indicating if debug tracebacks should be returned on errors.
             routes: A list of routes to serve incoming HTTP and WebSocket requests.

pydantic_ai/models/__init__.py

@@ -137,12 +137,12 @@ KnownModelName = TypeAliasType(
         'google-gla:gemini-2.0-flash',
         'google-gla:gemini-2.0-flash-lite',
         'google-gla:gemini-2.5-flash',
-        'google-gla:gemini-2.5-flash-lite-preview-06-17',
+        'google-gla:gemini-2.5-flash-lite',
         'google-gla:gemini-2.5-pro',
         'google-vertex:gemini-2.0-flash',
         'google-vertex:gemini-2.0-flash-lite',
         'google-vertex:gemini-2.5-flash',
-        'google-vertex:gemini-2.5-flash-lite-preview-06-17',
+        'google-vertex:gemini-2.5-flash-lite',
         'google-vertex:gemini-2.5-pro',
         'gpt-3.5-turbo',
         'gpt-3.5-turbo-0125',

pydantic_ai/models/cohere.py

@@ -192,7 +192,7 @@ class CohereModel(Model):
             # While Cohere's API returns a list, it only does that for future proofing
             # and currently only one item is being returned.
             choice = response.message.content[0]
-            parts.extend(split_content_into_text_and_thinking(choice.text))
+            parts.extend(split_content_into_text_and_thinking(choice.text, self.profile.thinking_tags))
         for c in response.message.tool_calls or []:
             if c.function and c.function.name and c.function.arguments:  # pragma: no branch
                 parts.append(

pydantic_ai/models/gemini.py

@@ -51,7 +51,7 @@ LatestGeminiModelNames = Literal[
     'gemini-2.0-flash',
     'gemini-2.0-flash-lite',
     'gemini-2.5-flash',
-    'gemini-2.5-flash-lite-preview-06-17',
+    'gemini-2.5-flash-lite',
     'gemini-2.5-pro',
 ]
 """Latest Gemini models."""

pydantic_ai/models/google.py

@@ -76,7 +76,7 @@ LatestGoogleModelNames = Literal[
     'gemini-2.0-flash',
     'gemini-2.0-flash-lite',
     'gemini-2.5-flash',
-    'gemini-2.5-flash-lite-preview-06-17',
+    'gemini-2.5-flash-lite',
     'gemini-2.5-pro',
 ]
 """Latest Gemini models."""

pydantic_ai/models/groq.py

@@ -30,7 +30,7 @@ from ..messages import (
     ToolReturnPart,
     UserPromptPart,
 )
-from ..profiles import ModelProfileSpec
+from ..profiles import ModelProfile, ModelProfileSpec
 from ..providers import Provider, infer_provider
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
@@ -261,7 +261,7 @@ class GroqModel(Model):
             items.append(ThinkingPart(content=choice.message.reasoning))
         if choice.message.content is not None:
             # NOTE: The `<think>` tag is only present if `groq_reasoning_format` is set to `raw`.
-            items.extend(split_content_into_text_and_thinking(choice.message.content))
+            items.extend(split_content_into_text_and_thinking(choice.message.content, self.profile.thinking_tags))
         if choice.message.tool_calls is not None:
             for c in choice.message.tool_calls:
                 items.append(ToolCallPart(tool_name=c.function.name, args=c.function.arguments, tool_call_id=c.id))
@@ -281,6 +281,7 @@ class GroqModel(Model):
         return GroqStreamedResponse(
             _response=peekable_response,
             _model_name=self._model_name,
+            _model_profile=self.profile,
             _timestamp=number_to_datetime(first_chunk.created),
         )
 
@@ -400,6 +401,7 @@ class GroqStreamedResponse(StreamedResponse):
     """Implementation of `StreamedResponse` for Groq models."""
 
     _model_name: GroqModelName
+    _model_profile: ModelProfile
     _response: AsyncIterable[chat.ChatCompletionChunk]
     _timestamp: datetime
 
@@ -416,7 +418,9 @@ class GroqStreamedResponse(StreamedResponse):
             content = choice.delta.content
             if content is not None:
                 maybe_event = self._parts_manager.handle_text_delta(
-                    vendor_part_id='content', content=content, extract_think_tags=True
+                    vendor_part_id='content',
+                    content=content,
+                    thinking_tags=self._model_profile.thinking_tags,
                 )
                 if maybe_event is not None:  # pragma: no branch
                     yield maybe_event

pydantic_ai/models/huggingface.py

@@ -33,6 +33,7 @@ from ..messages import (
     UserPromptPart,
     VideoUrl,
 )
+from ..profiles import ModelProfile
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
 from . import Model, ModelRequestParameters, StreamedResponse, check_allow_model_requests
@@ -244,7 +245,7 @@ class HuggingFaceModel(Model):
         items: list[ModelResponsePart] = []
 
         if content is not None:
-            items.extend(split_content_into_text_and_thinking(content))
+            items.extend(split_content_into_text_and_thinking(content, self.profile.thinking_tags))
         if tool_calls is not None:
             for c in tool_calls:
                 items.append(ToolCallPart(c.function.name, c.function.arguments, tool_call_id=c.id))
@@ -267,6 +268,7 @@ class HuggingFaceModel(Model):
 
         return HuggingFaceStreamedResponse(
             _model_name=self._model_name,
+            _model_profile=self.profile,
             _response=peekable_response,
             _timestamp=datetime.fromtimestamp(first_chunk.created, tz=timezone.utc),
         )
@@ -412,6 +414,7 @@ class HuggingFaceStreamedResponse(StreamedResponse):
     """Implementation of `StreamedResponse` for Hugging Face models."""
 
     _model_name: str
+    _model_profile: ModelProfile
     _response: AsyncIterable[ChatCompletionStreamOutput]
     _timestamp: datetime
 
@@ -428,7 +431,9 @@ class HuggingFaceStreamedResponse(StreamedResponse):
             content = choice.delta.content
             if content:
                 maybe_event = self._parts_manager.handle_text_delta(
-                    vendor_part_id='content', content=content, extract_think_tags=True
+                    vendor_part_id='content',
+                    content=content,
+                    thinking_tags=self._model_profile.thinking_tags,
                 )
                 if maybe_event is not None:  # pragma: no branch
                     yield maybe_event

pydantic_ai/models/mistral.py

@@ -333,7 +333,7 @@ class MistralModel(Model):
 
         parts: list[ModelResponsePart] = []
         if text := _map_content(content):
-            parts.extend(split_content_into_text_and_thinking(text))
+            parts.extend(split_content_into_text_and_thinking(text, self.profile.thinking_tags))
 
         if isinstance(tool_calls, list):
             for tool_call in tool_calls:

pydantic_ai/models/openai.py

@@ -37,7 +37,7 @@ from ..messages import (
     UserPromptPart,
     VideoUrl,
 )
-from ..profiles import ModelProfileSpec
+from ..profiles import ModelProfile, ModelProfileSpec
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
 from . import (
@@ -407,7 +407,7 @@ class OpenAIModel(Model):
             }
 
         if choice.message.content is not None:
-            items.extend(split_content_into_text_and_thinking(choice.message.content))
+            items.extend(split_content_into_text_and_thinking(choice.message.content, self.profile.thinking_tags))
         if choice.message.tool_calls is not None:
             for c in choice.message.tool_calls:
                 part = ToolCallPart(c.function.name, c.function.arguments, tool_call_id=c.id)
@@ -433,6 +433,7 @@ class OpenAIModel(Model):
 
         return OpenAIStreamedResponse(
             _model_name=self._model_name,
+            _model_profile=self.profile,
             _response=peekable_response,
             _timestamp=number_to_datetime(first_chunk.created),
         )
@@ -1009,6 +1010,7 @@ class OpenAIStreamedResponse(StreamedResponse):
     """Implementation of `StreamedResponse` for OpenAI models."""
 
     _model_name: OpenAIModelName
+    _model_profile: ModelProfile
     _response: AsyncIterable[ChatCompletionChunk]
     _timestamp: datetime
 
@@ -1025,7 +1027,9 @@ class OpenAIStreamedResponse(StreamedResponse):
             content = choice.delta.content
             if content:
                 maybe_event = self._parts_manager.handle_text_delta(
-                    vendor_part_id='content', content=content, extract_think_tags=True
+                    vendor_part_id='content',
+                    content=content,
+                    thinking_tags=self._model_profile.thinking_tags,
                 )
                 if maybe_event is not None:  # pragma: no branch
                     yield maybe_event

pydantic_ai/models/test.py

@@ -123,7 +123,9 @@ class TestModel(Model):
 
         model_response = self._request(messages, model_settings, model_request_parameters)
         yield TestStreamedResponse(
-            _model_name=self._model_name, _structured_response=model_response, _messages=messages
+            _model_name=self._model_name,
+            _structured_response=model_response,
+            _messages=messages,
         )
 
     @property

pydantic_ai/profiles/__init__.py

@@ -35,6 +35,9 @@ class ModelProfile:
     json_schema_transformer: type[JsonSchemaTransformer] | None = None
     """The transformer to use to make JSON schemas for tools and structured output compatible with the model."""
 
+    thinking_tags: tuple[str, str] = ('<think>', '</think>')
+    """The tags used to indicate thinking parts in the model's output. Defaults to ('<think>', '</think>')."""
+
     @classmethod
     def from_profile(cls, profile: ModelProfile | None) -> Self:
         """Build a ModelProfile subclass instance from a ModelProfile instance."""

pydantic_ai/profiles/anthropic.py

@@ -5,4 +5,4 @@ from . import ModelProfile
 
 def anthropic_model_profile(model_name: str) -> ModelProfile | None:
     """Get the model profile for an Anthropic model."""
-    return None
+    return ModelProfile(thinking_tags=('<thinking>', '</thinking>'))

{pydantic_ai_slim-0.4.10.dist-info → pydantic_ai_slim-0.4.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.4.10
+Version: 0.4.11
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>, Marcelo Trylesinski <marcelotryle@gmail.com>, David Montague <david@pydantic.dev>, Alex Hall <alex@pydantic.dev>, Douwe Maan <douwe@pydantic.dev>
 License-Expression: MIT
@@ -30,7 +30,7 @@ Requires-Dist: exceptiongroup; python_version < '3.11'
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==0.4.10
+Requires-Dist: pydantic-graph==0.4.11
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
@@ -51,7 +51,7 @@ Requires-Dist: cohere>=5.16.0; (platform_system != 'Emscripten') and extra == 'c
 Provides-Extra: duckduckgo
 Requires-Dist: ddgs>=9.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==0.4.10; extra == 'evals'
+Requires-Dist: pydantic-evals==0.4.11; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.24.0; extra == 'google'
 Provides-Extra: groq

{pydantic_ai_slim-0.4.10.dist-info → pydantic_ai_slim-0.4.11.dist-info}/RECORD

@@ -7,14 +7,14 @@ pydantic_ai/_function_schema.py,sha256=6Xuash0DVpfPF0rWQce0bhtgti8YRyk3B1-OK_n6d
 pydantic_ai/_griffe.py,sha256=Ugft16ZHw9CN_6-lW0Svn6jESK9zHXO_x4utkGBkbBI,5253
 pydantic_ai/_mcp.py,sha256=PuvwnlLjv7YYOa9AZJCrklevBug99zGMhwJCBGG7BHQ,5626
 pydantic_ai/_output.py,sha256=2k-nxfPNLJEb-wjnPhQo63lh-yQH1XsIhNG1hjsrim0,37462
-pydantic_ai/_parts_manager.py,sha256=T4nlxaS697KeikJoqc1I9kRoIN5-_t5TEv-ovpMlzZg,17856
+pydantic_ai/_parts_manager.py,sha256=lWXN75zLy_MSDz4Wib65lqIPHk1SY8KDU8_OYaxG3yw,17788
 pydantic_ai/_run_context.py,sha256=pqb_HPXytE1Z9zZRRuBboRYes_tVTC75WGTpZgnb2Ko,1691
 pydantic_ai/_system_prompt.py,sha256=lUSq-gDZjlYTGtd6BUm54yEvTIvgdwBmJ8mLsNZZtYU,1142
-pydantic_ai/_thinking_part.py,sha256=mzx2RZSfiQxAKpljEflrcXRXmFKxtp6bKVyorY3UYZk,1554
+pydantic_ai/_thinking_part.py,sha256=x80-Vkon16GOyq3W6f2qzafTVPC5dCgF7QD3k8ZMmYU,1304
 pydantic_ai/_tool_manager.py,sha256=BdjPntbSshNvYVpYZUNxb-yib5n4GPqcDinbNpzhBVo,8960
 pydantic_ai/_utils.py,sha256=0Pte4mjir4YFZJTa6i-H6Cra9NbVwSKjOKegArzUggk,16283
-pydantic_ai/ag_ui.py,sha256=T7plrZ-pRDptL3r9kNlB2Vit2mVWMCZ1nhxG0ZTfH5M,25562
-pydantic_ai/agent.py,sha256=cN2QbfdPKIj60YfxShfyAe_k4YombGHAG1TYa3uQzOk,106873
+pydantic_ai/ag_ui.py,sha256=snIBVMcUUm3WWZ5P5orikyAzvM-7vGunNMgIudhvK-A,26156
+pydantic_ai/agent.py,sha256=VJOvadfilVm60BxWqxtXrzmNTnN8tuhapvFk2r13RO4,107234
 pydantic_ai/direct.py,sha256=WRfgke3zm-eeR39LTuh9XI2TrdHXAqO81eDvFwih4Ko,14803
 pydantic_ai/exceptions.py,sha256=o0l6fBrWI5UhosICVZ2yaT-JEJF05eqBlKlQCW8i9UM,3462
 pydantic_ai/format_as_xml.py,sha256=IINfh1evWDphGahqHNLBArB5dQ4NIqS3S-kru35ztGg,372
@@ -34,26 +34,26 @@ pydantic_ai/common_tools/tavily.py,sha256=Q1xxSF5HtXAaZ10Pp-OaDOHXwJf2mco9wScGEQ
 pydantic_ai/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/ext/aci.py,sha256=vUaNIj6pRM52x6RkPW_DohSYxJPm75pPUfOMw2i5Xx0,2515
 pydantic_ai/ext/langchain.py,sha256=GemxfhpyG1JPxj69PbRiSJANnY8Q5s4hSB7wqt-uTbo,2266
-pydantic_ai/models/__init__.py,sha256=GZ2YE5qcqI8tNpovlO0_6Ryx92bo8sQTsLmRKiYnSU4,30912
+pydantic_ai/models/__init__.py,sha256=UDi-zXjRt_Zb8kaN5OKMxGXnJtDkROpfa66tSz_wNdI,30884
 pydantic_ai/models/anthropic.py,sha256=dMPFqIeYCIhoeU_4uk9PmZYQWL1NbkSVmVrBKXplTiI,24167
 pydantic_ai/models/bedrock.py,sha256=O6wKZDu4L18L1L2Nsa-XMW4ch073FjcLKRA5t_NXcHU,29511
-pydantic_ai/models/cohere.py,sha256=lKUXEPqTMqxIJfouDj-Fr1bnfkrPu-JK3Xth7CL03kU,12800
+pydantic_ai/models/cohere.py,sha256=GYhQ6jkCYDHf3ca1835aig9o59XTvsyw4ISAVThYejA,12828
 pydantic_ai/models/fallback.py,sha256=URaV-dTQWkg99xrlkmknue5lXZWDcEt7cJ1Vsky4oB4,5130
 pydantic_ai/models/function.py,sha256=iHhG6GYN14XDo3_qbdliv_umY10B7-k11aoDoVF4xP8,13563
-pydantic_ai/models/gemini.py,sha256=BMFEiDJXbB0DPj5DKK4kCwXuQHifT2WU-WuthJOqPsI,38138
-pydantic_ai/models/google.py,sha256=NNcr2jJlK3eFlSRyaTgDPuSjG2GxOOj0vYDrAfD6rbo,24394
-pydantic_ai/models/groq.py,sha256=8-sh8h2sJNZE6TiNUoiTKjmWghtCncxa3BX_xN979XQ,18854
-pydantic_ai/models/huggingface.py,sha256=06Rh0Q-p_2LPuny5RIooMx-NWD1rbbhLWP2wL4E6aq0,19019
+pydantic_ai/models/gemini.py,sha256=J-05fngctXSqk3NzLaemt0h6r3S6jmr9ArvlWQE5Q0A,38124
+pydantic_ai/models/google.py,sha256=PNN5Z5VYPioT0-FzS4PoZ33es26AfUqwMBLfHhrElnw,24380
+pydantic_ai/models/groq.py,sha256=JX3Hi8tUJTsTj2A6CGoDhpW4IwNUxgOk0Ta58OCEL_A,19035
+pydantic_ai/models/huggingface.py,sha256=g4Z2C_e_OddYyGKLSOtP4nCL-AbWxmOdkW4zFcFtLq0,19222
 pydantic_ai/models/instrumented.py,sha256=aqvzspcGexn1Molbu6Mn4EEPRBSoQCCCS_yknJvJJ-8,16205
 pydantic_ai/models/mcp_sampling.py,sha256=q9nnjNEAAbhrfRc_Qw5z9TtCHMG_SwlCWW9FvKWjh8k,3395
-pydantic_ai/models/mistral.py,sha256=u3LcPVqvdI2WHckffbj7zRT5oQn9yYdTRbtEN20Gqpw,31427
-pydantic_ai/models/openai.py,sha256=PnbsqSrOUrj3et_2Og7BUMNQF7nOlMdOOWOlWzJH_L0,55941
-pydantic_ai/models/test.py,sha256=tkm6K0-G5Mc_iSqVzVIpU9VLil9dfkE1-5az8GGWwTI,18457
+pydantic_ai/models/mistral.py,sha256=bj56Meckuji8r4vowiFJMDSli-HZktocqSqtbzgpXa0,31455
+pydantic_ai/models/openai.py,sha256=Soqb7kZpQLBS6En7hVlhzBMlS07rjISJ9IlH96bBBBU,56122
+pydantic_ai/models/test.py,sha256=lGMblastixKF_f5MhP3TcvLWx7jj94H4ohmL7DMpdGo,18482
 pydantic_ai/models/wrapper.py,sha256=A5-ncYhPF8c9S_czGoXkd55s2KOQb65p3jbVpwZiFPA,2043
-pydantic_ai/profiles/__init__.py,sha256=BXMqUpgRfosmYgcxjKAI9ESCj47JTSa30DhKXEgVLzM,2419
+pydantic_ai/profiles/__init__.py,sha256=uC1_64Pb0O1IMt_SwzvU3W7a2_T3pvdoSDcm8_WI7hw,2592
 pydantic_ai/profiles/_json_schema.py,sha256=sTNHkaK0kbwmbldZp9JRGQNax0f5Qvwy0HkWuu_nGxU,7179
 pydantic_ai/profiles/amazon.py,sha256=O4ijm1Lpz01vaSiHrkSeGQhbCKV5lyQVtHYqh0pCW_k,339
-pydantic_ai/profiles/anthropic.py,sha256=DtTGh85tbkTrrrn2OrJ4FJKXWUIxUH_1Vw6y5fyMRyM,222
+pydantic_ai/profiles/anthropic.py,sha256=J9N46G8eOjHdQ5CwZSLiwGdPb0eeIMdsMjwosDpvNhI,275
 pydantic_ai/profiles/cohere.py,sha256=lcL34Ht1jZopwuqoU6OV9l8vN4zwF-jiPjlsEABbSRo,215
 pydantic_ai/profiles/deepseek.py,sha256=DS_idprnXpMliKziKF0k1neLDJOwUvpatZ3YLaiYnCM,219
 pydantic_ai/profiles/google.py,sha256=cd5zwtx0MU1Xwm8c-oqi2_OJ2-PMJ8Vy23mxvSJF7ik,4856
@@ -94,8 +94,8 @@ pydantic_ai/toolsets/prefixed.py,sha256=MIStkzUdiU0rk2Y6P19IrTBxspH5pTstGxsqCBt-
 pydantic_ai/toolsets/prepared.py,sha256=Zjfz6S8In6PBVxoKFN9sKPN984zO6t0awB7Lnq5KODw,1431
 pydantic_ai/toolsets/renamed.py,sha256=JuLHpi-hYPiSPlaTpN8WiXLiGsywYK0axi2lW2Qs75k,1637
 pydantic_ai/toolsets/wrapper.py,sha256=WjLoiM1WDuffSJ4mDS6pZrEZGHgZ421fjrqFcB66W94,1205
-pydantic_ai_slim-0.4.10.dist-info/METADATA,sha256=k2Hx78rIovi1HJ0FiRIAMd6EXoroqmOSe68hb4-VASg,4176
-pydantic_ai_slim-0.4.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-0.4.10.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
-pydantic_ai_slim-0.4.10.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
-pydantic_ai_slim-0.4.10.dist-info/RECORD,,
+pydantic_ai_slim-0.4.11.dist-info/METADATA,sha256=csPdqlBPAN-VkDDT1zV3WRxgwQLM_6saa0dNDI9Iyqs,4176
+pydantic_ai_slim-0.4.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-0.4.11.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
+pydantic_ai_slim-0.4.11.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
+pydantic_ai_slim-0.4.11.dist-info/RECORD,,