pydantic-ai-slim 0.7.1__py3-none-any.whl → 0.7.2__py3-none-any.whl

pydantic_ai/_agent_graph.py

@@ -23,7 +23,7 @@ from pydantic_graph.nodes import End, NodeRunEndT
 from . import _output, _system_prompt, exceptions, messages as _messages, models, result, usage as _usage
 from .exceptions import ToolRetryError
 from .output import OutputDataT, OutputSpec
-from .settings import ModelSettings, merge_model_settings
+from .settings import ModelSettings
 from .tools import RunContext, ToolDefinition, ToolKind
 
 if TYPE_CHECKING:
@@ -158,28 +158,7 @@ class UserPromptNode(AgentNode[DepsT, NodeRunEndT]):
 
     async def run(
         self, ctx: GraphRunContext[GraphAgentState, GraphAgentDeps[DepsT, NodeRunEndT]]
-    ) -> ModelRequestNode[DepsT, NodeRunEndT]:
-        return ModelRequestNode[DepsT, NodeRunEndT](request=await self._get_first_message(ctx))
-
-    async def _get_first_message(
-        self, ctx: GraphRunContext[GraphAgentState, GraphAgentDeps[DepsT, NodeRunEndT]]
-    ) -> _messages.ModelRequest:
-        run_context = build_run_context(ctx)
-        history, next_message = await self._prepare_messages(
-            self.user_prompt, ctx.state.message_history, ctx.deps.get_instructions, run_context
-        )
-        ctx.state.message_history = history
-        run_context.messages = history
-
-        return next_message
-
-    async def _prepare_messages(
-        self,
-        user_prompt: str | Sequence[_messages.UserContent] | None,
-        message_history: list[_messages.ModelMessage] | None,
-        get_instructions: Callable[[RunContext[DepsT]], Awaitable[str | None]],
-        run_context: RunContext[DepsT],
-    ) -> tuple[list[_messages.ModelMessage], _messages.ModelRequest]:
+    ) -> Union[ModelRequestNode[DepsT, NodeRunEndT], CallToolsNode[DepsT, NodeRunEndT]]:  # noqa UP007
         try:
             ctx_messages = get_captured_run_messages()
         except LookupError:
@@ -191,29 +170,48 @@ class UserPromptNode(AgentNode[DepsT, NodeRunEndT]):
                 messages = ctx_messages.messages
                 ctx_messages.used = True
 
+        # Add message history to the `capture_run_messages` list, which will be empty at this point
+        messages.extend(ctx.state.message_history)
+        # Use the `capture_run_messages` list as the message history so that new messages are added to it
+        ctx.state.message_history = messages
+
+        run_context = build_run_context(ctx)
+
         parts: list[_messages.ModelRequestPart] = []
-        instructions = await get_instructions(run_context)
-        if message_history:
-            # Shallow copy messages
-            messages.extend(message_history)
+        if messages:
             # Reevaluate any dynamic system prompt parts
             await self._reevaluate_dynamic_prompts(messages, run_context)
         else:
             parts.extend(await self._sys_parts(run_context))
 
-        if user_prompt is not None:
-            parts.append(_messages.UserPromptPart(user_prompt))
-        elif (
-            len(parts) == 0
-            and message_history
-            and (last_message := message_history[-1])
-            and isinstance(last_message, _messages.ModelRequest)
-        ):
-            # Drop last message that came from history and reuse its parts
-            messages.pop()
-            parts.extend(last_message.parts)
+        if messages and (last_message := messages[-1]):
+            if isinstance(last_message, _messages.ModelRequest) and self.user_prompt is None:
+                # Drop last message from history and reuse its parts
+                messages.pop()
+                parts.extend(last_message.parts)
+            elif isinstance(last_message, _messages.ModelResponse):
+                if self.user_prompt is None:
+                    # `CallToolsNode` requires the tool manager to be prepared for the run step
+                    # This will raise errors for any tool name conflicts
+                    ctx.deps.tool_manager = await ctx.deps.tool_manager.for_run_step(run_context)
+
+                    # Skip ModelRequestNode and go directly to CallToolsNode
+                    return CallToolsNode[DepsT, NodeRunEndT](model_response=last_message)
+                elif any(isinstance(part, _messages.ToolCallPart) for part in last_message.parts):
+                    raise exceptions.UserError(
+                        'Cannot provide a new user prompt when the message history ends with '
+                        'a model response containing unprocessed tool calls. Either process the '
+                        'tool calls first (by calling `iter` with `user_prompt=None`) or append a '
+                        '`ModelRequest` with `ToolResultPart`s.'
+                    )
+
+        if self.user_prompt is not None:
+            parts.append(_messages.UserPromptPart(self.user_prompt))
+
+        instructions = await ctx.deps.get_instructions(run_context)
+        next_message = _messages.ModelRequest(parts, instructions=instructions)
 
-        return messages, _messages.ModelRequest(parts, instructions=instructions)
+        return ModelRequestNode[DepsT, NodeRunEndT](request=next_message)
 
     async def _reevaluate_dynamic_prompts(
         self, messages: list[_messages.ModelMessage], run_context: RunContext[DepsT]
@@ -250,9 +248,6 @@ async def _prepare_request_parameters(
     ctx: GraphRunContext[GraphAgentState, GraphAgentDeps[DepsT, NodeRunEndT]],
 ) -> models.ModelRequestParameters:
     """Build tools and create an agent model."""
-    run_context = build_run_context(ctx)
-    ctx.deps.tool_manager = await ctx.deps.tool_manager.for_run_step(run_context)
-
     output_schema = ctx.deps.output_schema
     output_object = None
     if isinstance(output_schema, _output.NativeOutputSchema):
@@ -355,21 +350,21 @@ class ModelRequestNode(AgentNode[DepsT, NodeRunEndT]):
 
         run_context = build_run_context(ctx)
 
-        model_settings = merge_model_settings(ctx.deps.model_settings, None)
+        # This will raise errors for any tool name conflicts
+        ctx.deps.tool_manager = await ctx.deps.tool_manager.for_run_step(run_context)
+
+        message_history = await _process_message_history(ctx.state, ctx.deps.history_processors, run_context)
 
         model_request_parameters = await _prepare_request_parameters(ctx)
         model_request_parameters = ctx.deps.model.customize_request_parameters(model_request_parameters)
 
-        message_history = await _process_message_history(ctx.state, ctx.deps.history_processors, run_context)
-
+        model_settings = ctx.deps.model_settings
         usage = ctx.state.usage
         if ctx.deps.usage_limits.count_tokens_before_request:
             # Copy to avoid modifying the original usage object with the counted usage
             usage = dataclasses.replace(usage)
 
-            counted_usage = await ctx.deps.model.count_tokens(
-                message_history, ctx.deps.model_settings, model_request_parameters
-            )
+            counted_usage = await ctx.deps.model.count_tokens(message_history, model_settings, model_request_parameters)
             usage.incr(counted_usage)
 
         ctx.deps.usage_limits.check_before_request(usage)
@@ -432,9 +427,11 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
         if self._events_iterator is None:
             # Ensure that the stream is only run once
 
-            async def _run_stream() -> AsyncIterator[_messages.HandleResponseEvent]:
+            async def _run_stream() -> AsyncIterator[_messages.HandleResponseEvent]:  # noqa: C901
                 texts: list[str] = []
                 tool_calls: list[_messages.ToolCallPart] = []
+                thinking_parts: list[_messages.ThinkingPart] = []
+
                 for part in self.model_response.parts:
                     if isinstance(part, _messages.TextPart):
                         # ignore empty content for text parts, see #437
@@ -447,11 +444,7 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
                     elif isinstance(part, _messages.BuiltinToolReturnPart):
                         yield _messages.BuiltinToolResultEvent(part)
                     elif isinstance(part, _messages.ThinkingPart):
-                        # We don't need to do anything with thinking parts in this tool-calling node.
-                        # We need to handle text parts in case there are no tool calls and/or the desired output comes
-                        # from the text, but thinking parts should not directly influence the execution of tools or
-                        # determination of the next node of graph execution here.
-                        pass
+                        thinking_parts.append(part)
                     else:
                         assert_never(part)
 
@@ -465,8 +458,18 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
                 elif texts:
                     # No events are emitted during the handling of text responses, so we don't need to yield anything
                     self._next_node = await self._handle_text_response(ctx, texts)
+                elif thinking_parts:
+                    # handle thinking-only responses (responses that contain only ThinkingPart instances)
+                    # this can happen with models that support thinking mode when they don't provide
+                    # actionable output alongside their thinking content.
+                    self._next_node = ModelRequestNode[DepsT, NodeRunEndT](
+                        _messages.ModelRequest(
+                            parts=[_messages.RetryPromptPart('Responses without text or tool calls are not permitted.')]
+                        )
+                    )
                 else:
-                    # we've got an empty response, this sometimes happens with anthropic (and perhaps other models)
+                    # we got an empty response with no tool calls, text, or thinking
+                    # this sometimes happens with anthropic (and perhaps other models)
                     # when the model has already returned text along side tool calls
                     # in this scenario, if text responses are allowed, we return text from the most recent model
                     # response, if any

pydantic_ai/_parts_manager.py

@@ -72,6 +72,7 @@ class ModelResponsePartsManager:
         vendor_part_id: VendorId | None,
         content: str,
         thinking_tags: tuple[str, str] | None = None,
+        ignore_leading_whitespace: bool = False,
     ) -> ModelResponseStreamEvent | None:
         """Handle incoming text content, creating or updating a TextPart in the manager as appropriate.
 
@@ -85,6 +86,7 @@ class ModelResponsePartsManager:
                 a TextPart.
             content: The text content to append to the appropriate TextPart.
             thinking_tags: If provided, will handle content between the thinking tags as thinking parts.
+            ignore_leading_whitespace: If True, will ignore leading whitespace in the content.
 
         Returns:
             - A `PartStartEvent` if a new part was created.
@@ -128,10 +130,9 @@ class ModelResponsePartsManager:
             return self.handle_thinking_delta(vendor_part_id=vendor_part_id, content='')
 
         if existing_text_part_and_index is None:
-            # If the first text delta is all whitespace, don't emit a new part yet.
-            # This is a workaround for models that emit `<think>\n</think>\n\n` ahead of tool calls (e.g. Ollama + Qwen3),
-            # which we don't want to end up treating as a final result.
-            if content.isspace():
+            # This is a workaround for models that emit `<think>\n</think>\n\n` or an empty text part ahead of tool calls (e.g. Ollama + Qwen3),
+            # which we don't want to end up treating as a final result when using `run_stream` with `str` a valid `output_type`.
+            if ignore_leading_whitespace and (len(content) == 0 or content.isspace()):
                 return None
 
             # There is no existing text part that should be updated, so create a new one

pydantic_ai/_tool_manager.py

@@ -5,6 +5,7 @@ from collections.abc import Iterable
 from dataclasses import dataclass, field, replace
 from typing import Any, Generic
 
+from opentelemetry.trace import Tracer
 from pydantic import ValidationError
 from typing_extensions import assert_never
 
@@ -21,41 +22,46 @@ from .toolsets.abstract import AbstractToolset, ToolsetTool
 class ToolManager(Generic[AgentDepsT]):
     """Manages tools for an agent run step. It caches the agent run's toolset's tool definitions and handles calling tools and retries."""
 
-    ctx: RunContext[AgentDepsT]
-    """The agent run context for a specific run step."""
     toolset: AbstractToolset[AgentDepsT]
     """The toolset that provides the tools for this run step."""
-    tools: dict[str, ToolsetTool[AgentDepsT]]
+    ctx: RunContext[AgentDepsT] | None = None
+    """The agent run context for a specific run step."""
+    tools: dict[str, ToolsetTool[AgentDepsT]] | None = None
     """The cached tools for this run step."""
     failed_tools: set[str] = field(default_factory=set)
     """Names of tools that failed in this run step."""
 
-    @classmethod
-    async def build(cls, toolset: AbstractToolset[AgentDepsT], ctx: RunContext[AgentDepsT]) -> ToolManager[AgentDepsT]:
-        """Build a new tool manager for a specific run step."""
-        return cls(
-            ctx=ctx,
-            toolset=toolset,
-            tools=await toolset.get_tools(ctx),
-        )
-
     async def for_run_step(self, ctx: RunContext[AgentDepsT]) -> ToolManager[AgentDepsT]:
         """Build a new tool manager for the next run step, carrying over the retries from the current run step."""
-        if ctx.run_step == self.ctx.run_step:
-            return self
-
-        retries = {
-            failed_tool_name: self.ctx.retries.get(failed_tool_name, 0) + 1 for failed_tool_name in self.failed_tools
-        }
-        return await self.__class__.build(self.toolset, replace(ctx, retries=retries))
+        if self.ctx is not None:
+            if ctx.run_step == self.ctx.run_step:
+                return self
+
+            retries = {
+                failed_tool_name: self.ctx.retries.get(failed_tool_name, 0) + 1
+                for failed_tool_name in self.failed_tools
+            }
+            ctx = replace(ctx, retries=retries)
+
+        return self.__class__(
+            toolset=self.toolset,
+            ctx=ctx,
+            tools=await self.toolset.get_tools(ctx),
+        )
 
     @property
     def tool_defs(self) -> list[ToolDefinition]:
         """The tool definitions for the tools in this tool manager."""
+        if self.tools is None:
+            raise ValueError('ToolManager has not been prepared for a run step yet')  # pragma: no cover
+
         return [tool.tool_def for tool in self.tools.values()]
 
     def get_tool_def(self, name: str) -> ToolDefinition | None:
         """Get the tool definition for a given tool name, or `None` if the tool is unknown."""
+        if self.tools is None:
+            raise ValueError('ToolManager has not been prepared for a run step yet')  # pragma: no cover
+
         try:
             return self.tools[name].tool_def
         except KeyError:
@@ -71,15 +77,25 @@ class ToolManager(Generic[AgentDepsT]):
             allow_partial: Whether to allow partial validation of the tool arguments.
             wrap_validation_errors: Whether to wrap validation errors in a retry prompt part.
         """
+        if self.tools is None or self.ctx is None:
+            raise ValueError('ToolManager has not been prepared for a run step yet')  # pragma: no cover
+
         if (tool := self.tools.get(call.tool_name)) and tool.tool_def.kind == 'output':
             # Output tool calls are not traced
             return await self._call_tool(call, allow_partial, wrap_validation_errors)
         else:
-            return await self._call_tool_traced(call, allow_partial, wrap_validation_errors)
+            return await self._call_tool_traced(
+                call,
+                allow_partial,
+                wrap_validation_errors,
+                self.ctx.tracer,
+                self.ctx.trace_include_content,
+            )
+
+    async def _call_tool(self, call: ToolCallPart, allow_partial: bool, wrap_validation_errors: bool) -> Any:
+        if self.tools is None or self.ctx is None:
+            raise ValueError('ToolManager has not been prepared for a run step yet')  # pragma: no cover
 
-    async def _call_tool(
-        self, call: ToolCallPart, allow_partial: bool = False, wrap_validation_errors: bool = True
-    ) -> Any:
         name = call.tool_name
         tool = self.tools.get(name)
         try:
@@ -137,14 +153,19 @@ class ToolManager(Generic[AgentDepsT]):
                 raise e
 
     async def _call_tool_traced(
-        self, call: ToolCallPart, allow_partial: bool = False, wrap_validation_errors: bool = True
+        self,
+        call: ToolCallPart,
+        allow_partial: bool,
+        wrap_validation_errors: bool,
+        tracer: Tracer,
+        include_content: bool = False,
     ) -> Any:
         """See <https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-spans/#execute-tool-span>."""
         span_attributes = {
             'gen_ai.tool.name': call.tool_name,
             # NOTE: this means `gen_ai.tool.call.id` will be included even if it was generated by pydantic-ai
             'gen_ai.tool.call.id': call.tool_call_id,
-            **({'tool_arguments': call.args_as_json_str()} if self.ctx.trace_include_content else {}),
+            **({'tool_arguments': call.args_as_json_str()} if include_content else {}),
             'logfire.msg': f'running tool: {call.tool_name}',
             # add the JSON schema so these attributes are formatted nicely in Logfire
             'logfire.json_schema': json.dumps(
@@ -156,7 +177,7 @@ class ToolManager(Generic[AgentDepsT]):
                                 'tool_arguments': {'type': 'object'},
                                 'tool_response': {'type': 'object'},
                             }
-                            if self.ctx.trace_include_content
+                            if include_content
                             else {}
                         ),
                         'gen_ai.tool.name': {},
@@ -165,16 +186,16 @@ class ToolManager(Generic[AgentDepsT]):
                 }
             ),
         }
-        with self.ctx.tracer.start_as_current_span('running tool', attributes=span_attributes) as span:
+        with tracer.start_as_current_span('running tool', attributes=span_attributes) as span:
             try:
                 tool_result = await self._call_tool(call, allow_partial, wrap_validation_errors)
             except ToolRetryError as e:
                 part = e.tool_retry
-                if self.ctx.trace_include_content and span.is_recording():
+                if include_content and span.is_recording():
                     span.set_attribute('tool_response', part.model_response())
                 raise e
 
-            if self.ctx.trace_include_content and span.is_recording():
+            if include_content and span.is_recording():
                 span.set_attribute(
                     'tool_response',
                     tool_result

pydantic_ai/agent/__init__.py

@@ -566,6 +566,8 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
             if output_toolset:
                 output_toolset.max_retries = self._max_result_retries
                 output_toolset.output_validators = output_validators
+        toolset = self._get_toolset(output_toolset=output_toolset, additional_toolsets=toolsets)
+        tool_manager = ToolManager[AgentDepsT](toolset)
 
         # Build the graph
         graph: Graph[_agent_graph.GraphAgentState, _agent_graph.GraphAgentDeps[AgentDepsT, Any], FinalResult[Any]] = (
@@ -581,6 +583,27 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
             run_step=0,
         )
 
+        # Merge model settings in order of precedence: run > agent > model
+        merged_settings = merge_model_settings(model_used.settings, self.model_settings)
+        model_settings = merge_model_settings(merged_settings, model_settings)
+        usage_limits = usage_limits or _usage.UsageLimits()
+
+        async def get_instructions(run_context: RunContext[AgentDepsT]) -> str | None:
+            parts = [
+                self._instructions,
+                *[await func.run(run_context) for func in self._instructions_functions],
+            ]
+
+            model_profile = model_used.profile
+            if isinstance(output_schema, _output.PromptedOutputSchema):
+                instructions = output_schema.instructions(model_profile.prompted_output_template)
+                parts.append(instructions)
+
+            parts = [p for p in parts if p]
+            if not parts:
+                return None
+            return '\n\n'.join(parts).strip()
+
         if isinstance(model_used, InstrumentedModel):
             instrumentation_settings = model_used.instrumentation_settings
             tracer = model_used.instrumentation_settings.tracer
@@ -588,81 +611,45 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
             instrumentation_settings = None
             tracer = NoOpTracer()
 
-        run_context = RunContext[AgentDepsT](
-            deps=deps,
-            model=model_used,
-            usage=usage,
+        graph_deps = _agent_graph.GraphAgentDeps[AgentDepsT, RunOutputDataT](
+            user_deps=deps,
             prompt=user_prompt,
-            messages=state.message_history,
+            new_message_index=new_message_index,
+            model=model_used,
+            model_settings=model_settings,
+            usage_limits=usage_limits,
+            max_result_retries=self._max_result_retries,
+            end_strategy=self.end_strategy,
+            output_schema=output_schema,
+            output_validators=output_validators,
+            history_processors=self.history_processors,
+            builtin_tools=list(self._builtin_tools),
+            tool_manager=tool_manager,
             tracer=tracer,
-            trace_include_content=instrumentation_settings is not None and instrumentation_settings.include_content,
-            run_step=state.run_step,
+            get_instructions=get_instructions,
+            instrumentation_settings=instrumentation_settings,
+        )
+        start_node = _agent_graph.UserPromptNode[AgentDepsT](
+            user_prompt=user_prompt,
+            instructions=self._instructions,
+            instructions_functions=self._instructions_functions,
+            system_prompts=self._system_prompts,
+            system_prompt_functions=self._system_prompt_functions,
+            system_prompt_dynamic_functions=self._system_prompt_dynamic_functions,
         )
 
-        toolset = self._get_toolset(output_toolset=output_toolset, additional_toolsets=toolsets)
-
-        async with toolset:
-            # This will raise errors for any name conflicts
-            tool_manager = await ToolManager[AgentDepsT].build(toolset, run_context)
-
-            # Merge model settings in order of precedence: run > agent > model
-            merged_settings = merge_model_settings(model_used.settings, self.model_settings)
-            model_settings = merge_model_settings(merged_settings, model_settings)
-            usage_limits = usage_limits or _usage.UsageLimits()
-            agent_name = self.name or 'agent'
-            run_span = tracer.start_span(
-                'agent run',
-                attributes={
-                    'model_name': model_used.model_name if model_used else 'no-model',
-                    'agent_name': agent_name,
-                    'logfire.msg': f'{agent_name} run',
-                },
-            )
-
-            async def get_instructions(run_context: RunContext[AgentDepsT]) -> str | None:
-                parts = [
-                    self._instructions,
-                    *[await func.run(run_context) for func in self._instructions_functions],
-                ]
-
-                model_profile = model_used.profile
-                if isinstance(output_schema, _output.PromptedOutputSchema):
-                    instructions = output_schema.instructions(model_profile.prompted_output_template)
-                    parts.append(instructions)
-
-                parts = [p for p in parts if p]
-                if not parts:
-                    return None
-                return '\n\n'.join(parts).strip()
-
-            graph_deps = _agent_graph.GraphAgentDeps[AgentDepsT, RunOutputDataT](
-                user_deps=deps,
-                prompt=user_prompt,
-                new_message_index=new_message_index,
-                model=model_used,
-                model_settings=model_settings,
-                usage_limits=usage_limits,
-                max_result_retries=self._max_result_retries,
-                end_strategy=self.end_strategy,
-                output_schema=output_schema,
-                output_validators=output_validators,
-                history_processors=self.history_processors,
-                builtin_tools=list(self._builtin_tools),
-                tool_manager=tool_manager,
-                tracer=tracer,
-                get_instructions=get_instructions,
-                instrumentation_settings=instrumentation_settings,
-            )
-            start_node = _agent_graph.UserPromptNode[AgentDepsT](
-                user_prompt=user_prompt,
-                instructions=self._instructions,
-                instructions_functions=self._instructions_functions,
-                system_prompts=self._system_prompts,
-                system_prompt_functions=self._system_prompt_functions,
-                system_prompt_dynamic_functions=self._system_prompt_dynamic_functions,
-            )
+        agent_name = self.name or 'agent'
+        run_span = tracer.start_span(
+            'agent run',
+            attributes={
+                'model_name': model_used.model_name if model_used else 'no-model',
+                'agent_name': agent_name,
+                'logfire.msg': f'{agent_name} run',
+            },
+        )
 
-            try:
+        try:
+            async with toolset:
                 async with graph.iter(
                     start_node,
                     state=state,
@@ -682,12 +669,12 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
                                     else json.dumps(InstrumentedModel.serialize_any(final_result.output))
                                 ),
                             )
+        finally:
+            try:
+                if instrumentation_settings and run_span.is_recording():
+                    run_span.set_attributes(self._run_span_end_attributes(state, usage, instrumentation_settings))
             finally:
-                try:
-                    if instrumentation_settings and run_span.is_recording():
-                        run_span.set_attributes(self._run_span_end_attributes(state, usage, instrumentation_settings))
-                finally:
-                    run_span.end()
+                run_span.end()
 
     def _run_span_end_attributes(
         self, state: _agent_graph.GraphAgentState, usage: _usage.Usage, settings: InstrumentationSettings

pydantic_ai/models/anthropic.py

@@ -8,14 +8,6 @@ from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from typing import Any, Literal, Union, cast, overload
 
-from anthropic.types.beta import (
-    BetaCitationsDelta,
-    BetaCodeExecutionToolResultBlock,
-    BetaCodeExecutionToolResultBlockParam,
-    BetaInputJSONDelta,
-    BetaServerToolUseBlockParam,
-    BetaWebSearchToolResultBlockParam,
-)
 from typing_extensions import assert_never
 
 from pydantic_ai.builtin_tools import CodeExecutionTool, WebSearchTool
@@ -47,24 +39,21 @@ from ..profiles import ModelProfileSpec
 from ..providers import Provider, infer_provider
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
-from . import (
-    Model,
-    ModelRequestParameters,
-    StreamedResponse,
-    check_allow_model_requests,
-    download_item,
-    get_user_agent,
-)
+from . import Model, ModelRequestParameters, StreamedResponse, check_allow_model_requests, download_item, get_user_agent
 
 try:
     from anthropic import NOT_GIVEN, APIStatusError, AsyncAnthropic, AsyncStream
     from anthropic.types.beta import (
         BetaBase64PDFBlockParam,
         BetaBase64PDFSourceParam,
+        BetaCitationsDelta,
         BetaCodeExecutionTool20250522Param,
+        BetaCodeExecutionToolResultBlock,
+        BetaCodeExecutionToolResultBlockParam,
         BetaContentBlock,
         BetaContentBlockParam,
         BetaImageBlockParam,
+        BetaInputJSONDelta,
         BetaMessage,
         BetaMessageParam,
         BetaMetadataParam,
@@ -78,6 +67,7 @@ try:
         BetaRawMessageStreamEvent,
         BetaRedactedThinkingBlock,
         BetaServerToolUseBlock,
+        BetaServerToolUseBlockParam,
         BetaSignatureDelta,
         BetaTextBlock,
         BetaTextBlockParam,
@@ -94,6 +84,7 @@ try:
         BetaToolUseBlockParam,
         BetaWebSearchTool20250305Param,
         BetaWebSearchToolResultBlock,
+        BetaWebSearchToolResultBlockParam,
     )
     from anthropic.types.beta.beta_web_search_tool_20250305_param import UserLocation
     from anthropic.types.model_param import ModelParam
@@ -246,7 +237,9 @@ class AnthropicModel(Model):
     ) -> BetaMessage | AsyncStream[BetaRawMessageStreamEvent]:
         # standalone function to make it easier to override
         tools = self._get_tools(model_request_parameters)
-        tools += self._get_builtin_tools(model_request_parameters)
+        builtin_tools, tool_headers = self._get_builtin_tools(model_request_parameters)
+        tools += builtin_tools
+
         tool_choice: BetaToolChoiceParam | None
 
         if not tools:
@@ -264,8 +257,10 @@ class AnthropicModel(Model):
 
         try:
             extra_headers = model_settings.get('extra_headers', {})
+            for k, v in tool_headers.items():
+                extra_headers.setdefault(k, v)
             extra_headers.setdefault('User-Agent', get_user_agent())
-            extra_headers.setdefault('anthropic-beta', 'code-execution-2025-05-22')
+
             return await self.client.beta.messages.create(
                 max_tokens=model_settings.get('max_tokens', 4096),
                 system=system_prompt or NOT_GIVEN,
@@ -352,8 +347,11 @@ class AnthropicModel(Model):
     def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[BetaToolParam]:
         return [self._map_tool_definition(r) for r in model_request_parameters.tool_defs.values()]
 
-    def _get_builtin_tools(self, model_request_parameters: ModelRequestParameters) -> list[BetaToolUnionParam]:
+    def _get_builtin_tools(
+        self, model_request_parameters: ModelRequestParameters
+    ) -> tuple[list[BetaToolUnionParam], dict[str, str]]:
         tools: list[BetaToolUnionParam] = []
+        extra_headers: dict[str, str] = {}
         for tool in model_request_parameters.builtin_tools:
             if isinstance(tool, WebSearchTool):
                 user_location = UserLocation(type='approximate', **tool.user_location) if tool.user_location else None
@@ -361,18 +359,20 @@ class AnthropicModel(Model):
                     BetaWebSearchTool20250305Param(
                         name='web_search',
                         type='web_search_20250305',
+                        max_uses=tool.max_uses,
                         allowed_domains=tool.allowed_domains,
                         blocked_domains=tool.blocked_domains,
                         user_location=user_location,
                     )
                 )
             elif isinstance(tool, CodeExecutionTool):  # pragma: no branch
+                extra_headers['anthropic-beta'] = 'code-execution-2025-05-22'
                 tools.append(BetaCodeExecutionTool20250522Param(name='code_execution', type='code_execution_20250522'))
             else:  # pragma: no cover
                 raise UserError(
                     f'`{tool.__class__.__name__}` is not supported by `AnthropicModel`. If it should be, please file an issue.'
                 )
-        return tools
+        return tools, extra_headers
 
     async def _map_message(self, messages: list[ModelMessage]) -> tuple[str, list[BetaMessageParam]]:  # noqa: C901
         """Just maps a `pydantic_ai.Message` to a `anthropic.types.MessageParam`."""

pydantic_ai/models/bedrock.py

@@ -648,7 +648,7 @@ class BedrockStreamedResponse(StreamedResponse):
                         )
                 if 'text' in delta:
                     maybe_event = self._parts_manager.handle_text_delta(vendor_part_id=index, content=delta['text'])
-                    if maybe_event is not None:
+                    if maybe_event is not None:  # pragma: no branch
                         yield maybe_event
                 if 'toolUse' in delta:
                     tool_use = delta['toolUse']

pydantic_ai/models/groq.py

@@ -457,6 +457,7 @@ class GroqStreamedResponse(StreamedResponse):
                     vendor_part_id='content',
                     content=content,
                     thinking_tags=self._model_profile.thinking_tags,
+                    ignore_leading_whitespace=self._model_profile.ignore_streamed_leading_whitespace,
                 )
                 if maybe_event is not None:  # pragma: no branch
                     yield maybe_event

pydantic_ai/models/huggingface.py

@@ -35,7 +35,7 @@ from ..messages import (
     UserPromptPart,
     VideoUrl,
 )
-from ..profiles import ModelProfile
+from ..profiles import ModelProfile, ModelProfileSpec
 from ..providers import Provider, infer_provider
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
@@ -121,6 +121,8 @@ class HuggingFaceModel(Model):
         model_name: str,
         *,
         provider: Literal['huggingface'] | Provider[AsyncInferenceClient] = 'huggingface',
+        profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ):
         """Initialize a Hugging Face model.
 
@@ -128,6 +130,8 @@ class HuggingFaceModel(Model):
             model_name: The name of the Model to use. You can browse available models [here](https://huggingface.co/models?pipeline_tag=text-generation&inference_provider=all&sort=trending).
             provider: The provider to use for Hugging Face Inference Providers. Can be either the string 'huggingface' or an
                 instance of `Provider[AsyncInferenceClient]`. If not provided, the other parameters will be used.
+            profile: The model profile to use. Defaults to a profile picked by the provider based on the model name.
+            settings: Model-specific settings that will be used as defaults for this model.
         """
         self._model_name = model_name
         self._provider = provider
@@ -135,6 +139,8 @@ class HuggingFaceModel(Model):
             provider = infer_provider(provider)
         self.client = provider.client
 
+        super().__init__(settings=settings, profile=profile or provider.model_profile)
+
     async def request(
         self,
         messages: list[ModelMessage],
@@ -444,11 +450,12 @@ class HuggingFaceStreamedResponse(StreamedResponse):
 
             # Handle the text part of the response
             content = choice.delta.content
-            if content:
+            if content is not None:
                 maybe_event = self._parts_manager.handle_text_delta(
                     vendor_part_id='content',
                     content=content,
                     thinking_tags=self._model_profile.thinking_tags,
+                    ignore_leading_whitespace=self._model_profile.ignore_streamed_leading_whitespace,
                 )
                 if maybe_event is not None:  # pragma: no branch
                     yield maybe_event

pydantic_ai/models/openai.py

@@ -217,6 +217,7 @@ class OpenAIModel(Model):
             'together',
             'heroku',
             'github',
+            'ollama',
         ]
         | Provider[AsyncOpenAI] = 'openai',
         profile: ModelProfileSpec | None = None,
@@ -1094,11 +1095,12 @@ class OpenAIStreamedResponse(StreamedResponse):
 
             # Handle the text part of the response
             content = choice.delta.content
-            if content:
+            if content is not None:
                 maybe_event = self._parts_manager.handle_text_delta(
                     vendor_part_id='content',
                     content=content,
                     thinking_tags=self._model_profile.thinking_tags,
+                    ignore_leading_whitespace=self._model_profile.ignore_streamed_leading_whitespace,
                 )
                 if maybe_event is not None:  # pragma: no branch
                     yield maybe_event

pydantic_ai/profiles/__init__.py

@@ -20,7 +20,7 @@ __all__ = [
 
 @dataclass
 class ModelProfile:
-    """Describes how requests to a specific model or family of models need to be constructed to get the best results, independent of the model and provider classes used."""
+    """Describes how requests to and responses from specific models or families of models need to be constructed and processed to get the best results, independent of the model and provider classes used."""
 
     supports_tools: bool = True
     """Whether the model supports tools."""
@@ -46,6 +46,15 @@ class ModelProfile:
     thinking_tags: tuple[str, str] = ('<think>', '</think>')
     """The tags used to indicate thinking parts in the model's output. Defaults to ('<think>', '</think>')."""
 
+    ignore_streamed_leading_whitespace: bool = False
+    """Whether to ignore leading whitespace when streaming a response.
+
+    This is a workaround for models that emit `<think>\n</think>\n\n` or an empty text part ahead of tool calls (e.g. Ollama + Qwen3),
+    which we don't want to end up treating as a final result when using `run_stream` with `str` a valid `output_type`.
+
+    This is currently only used by `OpenAIModel`, `HuggingFaceModel`, and `GroqModel`.
+    """
+
     @classmethod
     def from_profile(cls, profile: ModelProfile | None) -> Self:
         """Build a ModelProfile subclass instance from a ModelProfile instance."""

pydantic_ai/profiles/deepseek.py

@@ -5,4 +5,4 @@ from . import ModelProfile
 
 def deepseek_model_profile(model_name: str) -> ModelProfile | None:
     """Get the model profile for a DeepSeek model."""
-    return None
+    return ModelProfile(ignore_streamed_leading_whitespace='r1' in model_name)

pydantic_ai/profiles/moonshotai.py

@@ -5,4 +5,4 @@ from . import ModelProfile
 
 def moonshotai_model_profile(model_name: str) -> ModelProfile | None:
     """Get the model profile for a MoonshotAI model."""
-    return None
+    return ModelProfile(ignore_streamed_leading_whitespace=True)

pydantic_ai/profiles/qwen.py

@@ -5,4 +5,7 @@ from . import InlineDefsJsonSchemaTransformer, ModelProfile
 
 def qwen_model_profile(model_name: str) -> ModelProfile | None:
     """Get the model profile for a Qwen model."""
-    return ModelProfile(json_schema_transformer=InlineDefsJsonSchemaTransformer)
+    return ModelProfile(
+        json_schema_transformer=InlineDefsJsonSchemaTransformer,
+        ignore_streamed_leading_whitespace=True,
+    )

pydantic_ai/providers/__init__.py

@@ -123,6 +123,10 @@ def infer_provider_class(provider: str) -> type[Provider[Any]]:  # noqa: C901
         from .huggingface import HuggingFaceProvider
 
         return HuggingFaceProvider
+    elif provider == 'ollama':
+        from .ollama import OllamaProvider
+
+        return OllamaProvider
     elif provider == 'github':
         from .github import GitHubProvider
 

pydantic_ai/providers/huggingface.py

@@ -6,6 +6,13 @@ from typing import overload
 from httpx import AsyncClient
 
 from pydantic_ai.exceptions import UserError
+from pydantic_ai.profiles import ModelProfile
+from pydantic_ai.profiles.deepseek import deepseek_model_profile
+from pydantic_ai.profiles.google import google_model_profile
+from pydantic_ai.profiles.meta import meta_model_profile
+from pydantic_ai.profiles.mistral import mistral_model_profile
+from pydantic_ai.profiles.moonshotai import moonshotai_model_profile
+from pydantic_ai.profiles.qwen import qwen_model_profile
 
 try:
     from huggingface_hub import AsyncInferenceClient
@@ -33,6 +40,26 @@ class HuggingFaceProvider(Provider[AsyncInferenceClient]):
     def client(self) -> AsyncInferenceClient:
         return self._client
 
+    def model_profile(self, model_name: str) -> ModelProfile | None:
+        provider_to_profile = {
+            'deepseek-ai': deepseek_model_profile,
+            'google': google_model_profile,
+            'qwen': qwen_model_profile,
+            'meta-llama': meta_model_profile,
+            'mistralai': mistral_model_profile,
+            'moonshotai': moonshotai_model_profile,
+        }
+
+        if '/' not in model_name:
+            return None
+
+        model_name = model_name.lower()
+        provider, model_name = model_name.split('/', 1)
+        if provider in provider_to_profile:
+            return provider_to_profile[provider](model_name)
+
+        return None
+
     @overload
     def __init__(self, *, base_url: str, api_key: str | None = None) -> None: ...
     @overload

pydantic_ai/providers/ollama.py

@@ -0,0 +1,105 @@
+from __future__ import annotations as _annotations
+
+import os
+
+import httpx
+from openai import AsyncOpenAI
+
+from pydantic_ai.exceptions import UserError
+from pydantic_ai.models import cached_async_http_client
+from pydantic_ai.profiles import ModelProfile
+from pydantic_ai.profiles.cohere import cohere_model_profile
+from pydantic_ai.profiles.deepseek import deepseek_model_profile
+from pydantic_ai.profiles.google import google_model_profile
+from pydantic_ai.profiles.meta import meta_model_profile
+from pydantic_ai.profiles.mistral import mistral_model_profile
+from pydantic_ai.profiles.openai import OpenAIJsonSchemaTransformer, OpenAIModelProfile
+from pydantic_ai.profiles.qwen import qwen_model_profile
+from pydantic_ai.providers import Provider
+
+try:
+    from openai import AsyncOpenAI
+except ImportError as _import_error:  # pragma: no cover
+    raise ImportError(
+        'Please install the `openai` package to use the Ollama provider, '
+        'you can use the `openai` optional group — `pip install "pydantic-ai-slim[openai]"`'
+    ) from _import_error
+
+
+class OllamaProvider(Provider[AsyncOpenAI]):
+    """Provider for local or remote Ollama API."""
+
+    @property
+    def name(self) -> str:
+        return 'ollama'
+
+    @property
+    def base_url(self) -> str:
+        return str(self.client.base_url)
+
+    @property
+    def client(self) -> AsyncOpenAI:
+        return self._client
+
+    def model_profile(self, model_name: str) -> ModelProfile | None:
+        prefix_to_profile = {
+            'llama': meta_model_profile,
+            'gemma': google_model_profile,
+            'qwen': qwen_model_profile,
+            'qwq': qwen_model_profile,
+            'deepseek': deepseek_model_profile,
+            'mistral': mistral_model_profile,
+            'command': cohere_model_profile,
+        }
+
+        profile = None
+        for prefix, profile_func in prefix_to_profile.items():
+            model_name = model_name.lower()
+            if model_name.startswith(prefix):
+                profile = profile_func(model_name)
+
+        # As OllamaProvider is always used with OpenAIModel, which used to unconditionally use OpenAIJsonSchemaTransformer,
+        # we need to maintain that behavior unless json_schema_transformer is set explicitly
+        return OpenAIModelProfile(json_schema_transformer=OpenAIJsonSchemaTransformer).update(profile)
+
+    def __init__(
+        self,
+        base_url: str | None = None,
+        api_key: str | None = None,
+        openai_client: AsyncOpenAI | None = None,
+        http_client: httpx.AsyncClient | None = None,
+    ) -> None:
+        """Create a new Ollama provider.
+
+        Args:
+            base_url: The base url for the Ollama requests. If not provided, the `OLLAMA_BASE_URL` environment variable
+                will be used if available.
+            api_key: The API key to use for authentication, if not provided, the `OLLAMA_API_KEY` environment variable
+                will be used if available.
+            openai_client: An existing
+                [`AsyncOpenAI`](https://github.com/openai/openai-python?tab=readme-ov-file#async-usage)
+                client to use. If provided, `base_url`, `api_key`, and `http_client` must be `None`.
+            http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
+        """
+        if openai_client is not None:
+            assert base_url is None, 'Cannot provide both `openai_client` and `base_url`'
+            assert http_client is None, 'Cannot provide both `openai_client` and `http_client`'
+            assert api_key is None, 'Cannot provide both `openai_client` and `api_key`'
+            self._client = openai_client
+        else:
+            base_url = base_url or os.getenv('OLLAMA_BASE_URL')
+            if not base_url:
+                raise UserError(
+                    'Set the `OLLAMA_BASE_URL` environment variable or pass it via `OllamaProvider(base_url=...)`'
+                    'to use the Ollama provider.'
+                )
+
+            # This is a workaround for the OpenAI client requiring an API key, whilst locally served,
+            # openai compatible models do not always need an API key, but a placeholder (non-empty) key is required.
+            api_key = api_key or os.getenv('OLLAMA_API_KEY') or 'api-key-not-set'
+
+            if http_client is not None:
+                self._client = AsyncOpenAI(base_url=base_url, api_key=api_key, http_client=http_client)
+            else:
+                http_client = cached_async_http_client(provider='ollama')
+                self._client = AsyncOpenAI(base_url=base_url, api_key=api_key, http_client=http_client)

pydantic_ai/providers/openrouter.py

@@ -17,6 +17,7 @@ from pydantic_ai.profiles.google import google_model_profile
 from pydantic_ai.profiles.grok import grok_model_profile
 from pydantic_ai.profiles.meta import meta_model_profile
 from pydantic_ai.profiles.mistral import mistral_model_profile
+from pydantic_ai.profiles.moonshotai import moonshotai_model_profile
 from pydantic_ai.profiles.openai import OpenAIJsonSchemaTransformer, OpenAIModelProfile, openai_model_profile
 from pydantic_ai.profiles.qwen import qwen_model_profile
 from pydantic_ai.providers import Provider
@@ -57,6 +58,7 @@ class OpenRouterProvider(Provider[AsyncOpenAI]):
             'amazon': amazon_model_profile,
             'deepseek': deepseek_model_profile,
             'meta-llama': meta_model_profile,
+            'moonshotai': moonshotai_model_profile,
         }
 
         profile = None

pydantic_ai/result.py

@@ -196,7 +196,7 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
                     and isinstance(event.part, _messages.TextPart)
                     and event.part.content
                 ):
-                    yield event.part.content, event.index
+                    yield event.part.content, event.index  # pragma: no cover
                 elif (  # pragma: no branch
                     isinstance(event, _messages.PartDeltaEvent)
                     and isinstance(event.delta, _messages.TextPartDelta)

pydantic_ai/tools.py

@@ -31,7 +31,7 @@ __all__ = (
 ToolParams = ParamSpec('ToolParams', default=...)
 """Retrieval function param spec."""
 
-SystemPromptFunc = Union[
+SystemPromptFunc: TypeAlias = Union[
     Callable[[RunContext[AgentDepsT]], str],
     Callable[[RunContext[AgentDepsT]], Awaitable[str]],
     Callable[[], str],
@@ -42,17 +42,17 @@ SystemPromptFunc = Union[
 Usage `SystemPromptFunc[AgentDepsT]`.
 """
 
-ToolFuncContext = Callable[Concatenate[RunContext[AgentDepsT], ToolParams], Any]
+ToolFuncContext: TypeAlias = Callable[Concatenate[RunContext[AgentDepsT], ToolParams], Any]
 """A tool function that takes `RunContext` as the first argument.
 
 Usage `ToolContextFunc[AgentDepsT, ToolParams]`.
 """
-ToolFuncPlain = Callable[ToolParams, Any]
+ToolFuncPlain: TypeAlias = Callable[ToolParams, Any]
 """A tool function that does not take `RunContext` as the first argument.
 
 Usage `ToolPlainFunc[ToolParams]`.
 """
-ToolFuncEither = Union[ToolFuncContext[AgentDepsT, ToolParams], ToolFuncPlain[ToolParams]]
+ToolFuncEither: TypeAlias = Union[ToolFuncContext[AgentDepsT, ToolParams], ToolFuncPlain[ToolParams]]
 """Either kind of tool function.
 
 This is just a union of [`ToolFuncContext`][pydantic_ai.tools.ToolFuncContext] and
@@ -60,7 +60,7 @@ This is just a union of [`ToolFuncContext`][pydantic_ai.tools.ToolFuncContext] a
 
 Usage `ToolFuncEither[AgentDepsT, ToolParams]`.
 """
-ToolPrepareFunc: TypeAlias = 'Callable[[RunContext[AgentDepsT], ToolDefinition], Awaitable[ToolDefinition | None]]'
+ToolPrepareFunc: TypeAlias = Callable[[RunContext[AgentDepsT], 'ToolDefinition'], Awaitable['ToolDefinition | None']]
 """Definition of a function that can prepare a tool definition at call time.
 
 See [tool docs](../tools.md#tool-prepare) for more information.
@@ -88,9 +88,9 @@ hitchhiker = Tool(hitchhiker, prepare=only_if_42)
 Usage `ToolPrepareFunc[AgentDepsT]`.
 """
 
-ToolsPrepareFunc: TypeAlias = (
-    'Callable[[RunContext[AgentDepsT], list[ToolDefinition]], Awaitable[list[ToolDefinition] | None]]'
-)
+ToolsPrepareFunc: TypeAlias = Callable[
+    [RunContext[AgentDepsT], list['ToolDefinition']], Awaitable['list[ToolDefinition] | None']
+]
 """Definition of a function that can prepare the tool definition of all tools for each step.
 This is useful if you want to customize the definition of multiple tools or you want to register
 a subset of tools for a given step.
@@ -118,7 +118,7 @@ agent = Agent('openai:gpt-4o', prepare_tools=turn_on_strict_if_openai)
 Usage `ToolsPrepareFunc[AgentDepsT]`.
 """
 
-DocstringFormat = Literal['google', 'numpy', 'sphinx', 'auto']
+DocstringFormat: TypeAlias = Literal['google', 'numpy', 'sphinx', 'auto']
 """Supported docstring formats.
 
 * `'google'` — [Google-style](https://google.github.io/styleguide/pyguide.html#381-docstrings) docstrings.

{pydantic_ai_slim-0.7.1.dist-info → pydantic_ai_slim-0.7.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.7.1
+Version: 0.7.2
 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.7.1
+Requires-Dist: pydantic-graph==0.7.2
 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.7.1; extra == 'evals'
+Requires-Dist: pydantic-evals==0.7.2; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.28.0; extra == 'google'
 Provides-Extra: groq

{pydantic_ai_slim-0.7.1.dist-info → pydantic_ai_slim-0.7.2.dist-info}/RECORD

@@ -1,17 +1,17 @@
 pydantic_ai/__init__.py,sha256=Uy0J4BgX4CXsa0sUUb5K0FC4uUWGIwBici93QHLkNsk,1478
 pydantic_ai/__main__.py,sha256=Q_zJU15DUA01YtlJ2mnaLCoId2YmgmreVEERGuQT-Y0,132
 pydantic_ai/_a2a.py,sha256=wux52DmJQceLJwF71qxb0Uqupk3aS61m005-NmuWZIw,12164
-pydantic_ai/_agent_graph.py,sha256=CairpjIY302UegGzzA5C56kDqvXR6l2gcR6vSdai2JI,37714
+pydantic_ai/_agent_graph.py,sha256=QB6J-UI-gUUXPhk1ud39yCWw3U04Ea28HWfIN74iO6M,38488
 pydantic_ai/_cli.py,sha256=nr3hW7Y4vHzk7oXpfOCupwuJ6Z2SmZLz2dYS6ljCpuc,13281
 pydantic_ai/_function_schema.py,sha256=YFHxb6bKfhgeY6rNdbuYXgndGCDanveUx2258xkSNlQ,11233
 pydantic_ai/_griffe.py,sha256=Ugft16ZHw9CN_6-lW0Svn6jESK9zHXO_x4utkGBkbBI,5253
 pydantic_ai/_mcp.py,sha256=PuvwnlLjv7YYOa9AZJCrklevBug99zGMhwJCBGG7BHQ,5626
 pydantic_ai/_output.py,sha256=6Vxlw8F9nRWCkjy4qvFF8tmDi2xZn7Dq72T6s4C5kAM,37640
-pydantic_ai/_parts_manager.py,sha256=lWXN75zLy_MSDz4Wib65lqIPHk1SY8KDU8_OYaxG3yw,17788
+pydantic_ai/_parts_manager.py,sha256=zrra5yDpAX8cFB_eK0btAp9d6NAR979V1Rmepm83l1w,17980
 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=x80-Vkon16GOyq3W6f2qzafTVPC5dCgF7QD3k8ZMmYU,1304
-pydantic_ai/_tool_manager.py,sha256=0_4Ed8kUj_Z_AdTpyBdz5rdYbmlCxf1DUh2vrIk7rYE,9031
+pydantic_ai/_tool_manager.py,sha256=WPMXgHBzyn7UgRKIuqU-oV2GpsAOW0nF2RsxPCKOp7U,9655
 pydantic_ai/_utils.py,sha256=Ge9rtu8NJvsfSFjx1MduITPr0-9b_I0emDFSpwJbYes,16372
 pydantic_ai/ag_ui.py,sha256=2cKSSvl1j0pxVNCFQO82l7LVtkJMt0HUaEXGwy3y558,26463
 pydantic_ai/builtin_tools.py,sha256=mwIq-7m0ZSbCZp1zxswjRfQM648QE01IDfifvqDGxUQ,3023
@@ -22,13 +22,13 @@ pydantic_ai/mcp.py,sha256=n9_ECHmFE-eOZmb1bDh94oy81caefdtSGo1oH2KKWMo,31162
 pydantic_ai/messages.py,sha256=kLw3yBtUEoRQ43zZ43PpasgC6EeVbSQi4Fl0PB1tQwA,45700
 pydantic_ai/output.py,sha256=54Cwd1RruXlA5hucZ1h-SxFrzKHJuLvYvLtH9iyg2GI,11988
 pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_ai/result.py,sha256=PgsaEcIFt9rkWs3F3RW2jqI8Qhmf5gEtCHZ7jVr2d34,19765
+pydantic_ai/result.py,sha256=2Z5-wJXO5Iw_qHFoMcshTjiUHFdcT1aycNWt26kyLuY,19785
 pydantic_ai/retries.py,sha256=Xkj-gZAd3wc12CVsIErVYx2EIdIwD5yJOL4Ou6jDQ2s,10498
 pydantic_ai/run.py,sha256=VSZEadgzRc_tytnHt2Gemdv9z05e6aEJTNPQ7DmuUck,15130
 pydantic_ai/settings.py,sha256=yuUZ7-GkdPB-Gbx71kSdh8dSr6gwM9gEwk84qNxPO_I,3552
-pydantic_ai/tools.py,sha256=H7pCfLYvtQ9j2I5qQGF_UCzUpufO14vEgLowFE8msNA,14764
+pydantic_ai/tools.py,sha256=1_4kt4HGfpHH4XnYy0lQRzm5Io5SzOjk3AJxa-LJLmE,14821
 pydantic_ai/usage.py,sha256=UddLBMmytzKBmsLzyGHHbJAnr4VQkMA8-vSjCeifz3w,6801
-pydantic_ai/agent/__init__.py,sha256=GrQ_HqEo8Usw4QGzCOqD6zjn_htDs2zK53ocm1Fr4WM,60033
+pydantic_ai/agent/__init__.py,sha256=IB67d_jxZ3LpIdt5X7ng06CUV84dlzyBMse628PQttk,59319
 pydantic_ai/agent/abstract.py,sha256=m83vk00sV7q3MqIHucExkMsiEF52dANHptGl8TNEkbw,42035
 pydantic_ai/agent/wrapper.py,sha256=cVIpfPWF63oTD1jeWdFY-OS_ty2nwbeSwsI7upd30Kw,9155
 pydantic_ai/common_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -47,36 +47,36 @@ pydantic_ai/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/ext/aci.py,sha256=sUllKDNO-LOMurbFgxwRHuzNlBkSa3aVBqXfEm-A_vo,2545
 pydantic_ai/ext/langchain.py,sha256=iLVEZv1kcLkdIHo3us2yfdi0kVqyJ6qTaCt9BoLWm4k,2335
 pydantic_ai/models/__init__.py,sha256=PQcyiPaSj72mt9kjPgg69eboqHqRl0JlBHTS3eCO5uY,34611
-pydantic_ai/models/anthropic.py,sha256=th3jyYMcqa-I_hyOvtH5PKyOCX-IDnriaMT5VPKBVAo,29777
-pydantic_ai/models/bedrock.py,sha256=wlw-9zuRnvMW-T5Nt1_rBTLWrYBllhCbu1GzkaBWddk,30819
+pydantic_ai/models/anthropic.py,sha256=8wLXYWzGxD2tEf0V9cy0iApZStZHgup6TUlMjd8pQp4,30019
+pydantic_ai/models/bedrock.py,sha256=IzVpH0rpj63fWnQSwYf13sZ4VFAVn0wzSWW4HRgRaSw,30840
 pydantic_ai/models/cohere.py,sha256=ZbRvCPgPjDLItUj-r08VPmR8D8e6ARbUiRd8rsZ-1sY,13094
 pydantic_ai/models/fallback.py,sha256=8d5C2MDbVBQ1NFHIciaIAJd8-DGzpTbMzIPIR1Dj4Xc,5514
 pydantic_ai/models/function.py,sha256=CKSy_xA__n92BnOzfI9BXRsRVy3WjvuRyzibU26I8Js,14299
 pydantic_ai/models/gemini.py,sha256=SWeahyDS_8STbofWJoIDvayBIGv-d4CYUuIBERPZkpI,38676
 pydantic_ai/models/google.py,sha256=xiAbIT0WkfdwwvjGY5WzOgTpkpxXI7-A2cvnyxwmI8s,29636
-pydantic_ai/models/groq.py,sha256=xibIAuIpSbdlF5ONAKLpEcU3qYX3JfAJRBh2K7Fh_U4,20840
-pydantic_ai/models/huggingface.py,sha256=ONsqk_4YiojEpVzJvAjc5z92Bln71PKvk8eK53309bk,19731
+pydantic_ai/models/groq.py,sha256=iLgei6osGzLSrtxCPlDUR3Qz2sYa6qmeWJfJPrfc-c4,20942
+pydantic_ai/models/huggingface.py,sha256=CMGpAzzaJ-xtDlNAM0IAx97fUagyEO84MMAncBYnwa0,20256
 pydantic_ai/models/instrumented.py,sha256=vVHO2sHkZnH7kcFr2iozOOuacfwGQYORhSgUtvDYZEU,16315
 pydantic_ai/models/mcp_sampling.py,sha256=0pAMCTkzmhQuyhik8KG2ZUYGVh4tofjdZBf6WdR78ik,3490
 pydantic_ai/models/mistral.py,sha256=-nB6VoHvNveLZHRCmXQaX9EFUJlFHXXt7nRyFtI2SIE,32251
-pydantic_ai/models/openai.py,sha256=ys4opGwro9SX-JA2-Xul5hV_xydq5LusOR5Ck-D18Uo,61110
+pydantic_ai/models/openai.py,sha256=Ozry-an08lai0aI-PmTuOA2dwpMwnFs3VG9xgaEu7EU,61246
 pydantic_ai/models/test.py,sha256=XKfJOwjnaMAuGpQwMT-H99vIicFymdJDpAtr0PU0Zoo,19151
 pydantic_ai/models/wrapper.py,sha256=9MeHW7mXPsEK03IKL0rtjeX6QgXyZROOOzLh72GiX2k,2148
-pydantic_ai/profiles/__init__.py,sha256=Ggk_pbNnRcaGnDWEBppsH3sUk8ajckaaXKfJlkLQWVo,2775
+pydantic_ai/profiles/__init__.py,sha256=AdwFrK50_20qJBA_eMXXsV1vdGOvPxLVW82hMQvzXU0,3285
 pydantic_ai/profiles/_json_schema.py,sha256=CthOGmPSjgEZRRglfvg31zyQ9vjHDdacXoFpmba93dE,7206
 pydantic_ai/profiles/amazon.py,sha256=IPa2wydpcbFLLvhDK35-pwwoKo0Pg4vP84823fHx0zc,314
 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/deepseek.py,sha256=JDwfkr-0YovlB3jEKk7dNFvepxNf_YuLgLkGCtyXHSk,282
 pydantic_ai/profiles/google.py,sha256=cd5zwtx0MU1Xwm8c-oqi2_OJ2-PMJ8Vy23mxvSJF7ik,4856
 pydantic_ai/profiles/grok.py,sha256=nBOxOCYCK9aiLmz2Q-esqYhotNbbBC1boAoOYIk1tVw,211
 pydantic_ai/profiles/groq.py,sha256=5jLNnOuxq3HTrbY-cizJyGa1hIluW7sCPLmDP1C1unc,668
 pydantic_ai/profiles/meta.py,sha256=JdZcpdRWx8PY1pU9Z2i_TYtA0Cpbg23xyFrV7eXnooY,309
 pydantic_ai/profiles/mistral.py,sha256=ll01PmcK3szwlTfbaJLQmfd0TADN8lqjov9HpPJzCMQ,217
-pydantic_ai/profiles/moonshotai.py,sha256=LL5RacKHKn6rdvhoKjpGgZ8aVriv5NMeL6HCWEANAiU,223
+pydantic_ai/profiles/moonshotai.py,sha256=e1RJnbEvazE6aJAqfmYLYGNtwNwg52XQDRDkcLrv3fU,272
 pydantic_ai/profiles/openai.py,sha256=YIzZAeJWO8dhmeHcOQk-Kyh6DUd5b0I5EQSTcK0-qy4,7564
-pydantic_ai/profiles/qwen.py,sha256=zU19r2lVBxU0v0fXyA9G-VvG3XzBZMZJVxCpQutU9k0,309
-pydantic_ai/providers/__init__.py,sha256=yxPgiTJKFYZbDW18tmVM6mmD2Znol3WwniwnhtlN0Ak,4141
+pydantic_ai/profiles/qwen.py,sha256=K4_nJ_oN5NS_9W0Fl-dFgC4emVRTHPXFTtiJ_nycKHo,373
+pydantic_ai/providers/__init__.py,sha256=-jb9Vl4gE7z0katqwLPaKt5UileuPp0Brq0ZueBVJys,4246
 pydantic_ai/providers/anthropic.py,sha256=D35UXxCPXv8yIbD0fj9Zg2FvNyoMoJMeDUtVM8Sn78I,3046
 pydantic_ai/providers/azure.py,sha256=y77IHGiSQ9Ttx9f4SGMgdpin2Daq6eYyzUdM9ET22RQ,5819
 pydantic_ai/providers/bedrock.py,sha256=8jz77ySKv6CzCktN9YbZb1736gZM0d_btcKvXiZSSHI,5784
@@ -90,11 +90,12 @@ pydantic_ai/providers/google_vertex.py,sha256=9wJGctzQTEtmTTr3KCFAubDREMQJ4zOXt9
 pydantic_ai/providers/grok.py,sha256=dIkpxuuJlZ4pFtTSgeeJgiM_Z3mJU9qvk4f7jvSzi24,3141
 pydantic_ai/providers/groq.py,sha256=AeG5flZ_n4fRy8RWm0RGvDBEDrdaLfR8gMOTRHQB368,4059
 pydantic_ai/providers/heroku.py,sha256=NmDIkAdxtWsvCjlX-bKI5FgI4HW1zO9-e0mrNQNGMCk,2990
-pydantic_ai/providers/huggingface.py,sha256=LRmJcJpQRRYvam3IAPkYs2fMUJf70GgE3aDgQltGRCU,3821
+pydantic_ai/providers/huggingface.py,sha256=MLAv-Z99Kii5Faolq97_0Ir1LUKH9CwRmJFaI5RvwW4,4914
 pydantic_ai/providers/mistral.py,sha256=EIUSENjFuGzBhvbdrarUTM4VPkesIMnZrzfnEKHOsc4,3120
 pydantic_ai/providers/moonshotai.py,sha256=3BAE9eC9QaD3kblVwxtQWEln0-PhgK7bRvrYTCEYXbY,3471
+pydantic_ai/providers/ollama.py,sha256=GNrrjK02fRCv-3l09N2rl6tFTnGVbdDtfbu5j4Wggv8,4629
 pydantic_ai/providers/openai.py,sha256=7iGij0EaFylab7dTZAZDgXr78tr-HsZrn9EI9AkWBNQ,3091
-pydantic_ai/providers/openrouter.py,sha256=NXjNdnlXIBrBMMqbzcWQnowXOuZh4NHikXenBn5h3mc,4061
+pydantic_ai/providers/openrouter.py,sha256=rSJwc_efQlOaGSxN5hjuemg-8llVCEGf5uZaeFwoQm8,4182
 pydantic_ai/providers/together.py,sha256=zFVSMSm5jXbpkNouvBOTjWrPmlPpCp6sQS5LMSyVjrQ,3482
 pydantic_ai/providers/vercel.py,sha256=wFIfyfD2RCAVRWtveDDMjumOkP8v9AHy94KV1HXF180,4285
 pydantic_ai/toolsets/__init__.py,sha256=btvEfRHUzW8E6HiWP-AUKc0xBvIEigW6qWqVfnN11Ag,643
@@ -108,8 +109,8 @@ pydantic_ai/toolsets/prefixed.py,sha256=0KwcDkW8OM36ZUsOLVP5h-Nj2tPq78L3_E2c-1Fb
 pydantic_ai/toolsets/prepared.py,sha256=Zjfz6S8In6PBVxoKFN9sKPN984zO6t0awB7Lnq5KODw,1431
 pydantic_ai/toolsets/renamed.py,sha256=JuLHpi-hYPiSPlaTpN8WiXLiGsywYK0axi2lW2Qs75k,1637
 pydantic_ai/toolsets/wrapper.py,sha256=mMuMPdko9PJUdcsexlRXbwViSwKKJfv6JE58d8HK3ds,1646
-pydantic_ai_slim-0.7.1.dist-info/METADATA,sha256=DMu_iRcI1lhpIap8dm_3UX3vapXTkwtAauYAbDVxskk,4252
-pydantic_ai_slim-0.7.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-0.7.1.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
-pydantic_ai_slim-0.7.1.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
-pydantic_ai_slim-0.7.1.dist-info/RECORD,,
+pydantic_ai_slim-0.7.2.dist-info/METADATA,sha256=ibQxHaOvu0py9dGB6ALtmaIOpK23YHDxXINvJ92bjDE,4252
+pydantic_ai_slim-0.7.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-0.7.2.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
+pydantic_ai_slim-0.7.2.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
+pydantic_ai_slim-0.7.2.dist-info/RECORD,,