pydantic-ai-slim 0.3.7__py3-none-any.whl → 0.4.1__py3-none-any.whl

pydantic_ai/_a2a.py

@@ -1,11 +1,13 @@
 from __future__ import annotations, annotations as _annotations
 
+import uuid
 from collections.abc import AsyncIterator, Sequence
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from functools import partial
-from typing import Any, Generic
+from typing import Any, Generic, TypeVar
 
+from pydantic import TypeAdapter
 from typing_extensions import assert_never
 
 from pydantic_ai.messages import (
@@ -19,12 +21,17 @@ from pydantic_ai.messages import (
     ModelResponse,
     ModelResponsePart,
     TextPart,
+    ThinkingPart,
+    ToolCallPart,
     UserPromptPart,
     VideoUrl,
 )
 
 from .agent import Agent, AgentDepsT, OutputDataT
 
+# AgentWorker output type needs to be invariant for use in both parameter and return positions
+WorkerOutputT = TypeVar('WorkerOutputT')
+
 try:
     from starlette.middleware import Middleware
     from starlette.routing import Route
@@ -33,10 +40,11 @@ try:
     from fasta2a.applications import FastA2A
     from fasta2a.broker import Broker, InMemoryBroker
     from fasta2a.schema import (
+        AgentProvider,
         Artifact,
+        DataPart,
         Message,
         Part,
-        Provider,
         Skill,
         TaskIdParams,
         TaskSendParams,
@@ -72,7 +80,7 @@ def agent_to_a2a(
     url: str = 'http://localhost:8000',
     version: str = '1.0.0',
     description: str | None = None,
-    provider: Provider | None = None,
+    provider: AgentProvider | None = None,
     skills: list[Skill] | None = None,
     # Starlette
     debug: bool = False,
@@ -106,59 +114,121 @@ def agent_to_a2a(
 
 
 @dataclass
-class AgentWorker(Worker, Generic[AgentDepsT, OutputDataT]):
+class AgentWorker(Worker[list[ModelMessage]], Generic[WorkerOutputT, AgentDepsT]):
     """A worker that uses an agent to execute tasks."""
 
-    agent: Agent[AgentDepsT, OutputDataT]
+    agent: Agent[AgentDepsT, WorkerOutputT]
 
     async def run_task(self, params: TaskSendParams) -> None:
-        task = await self.storage.load_task(params['id'], history_length=params.get('history_length'))
-        assert task is not None, f'Task {params["id"]} not found'
-        assert 'session_id' in task, 'Task must have a session_id'
+        task = await self.storage.load_task(params['id'])
+        if task is None:
+            raise ValueError(f'Task {params["id"]} not found')  # pragma: no cover
+
+        # TODO(Marcelo): Should we lock `run_task` on the `context_id`?
+        # Ensure this task hasn't been run before
+        if task['status']['state'] != 'submitted':
+            raise ValueError(  # pragma: no cover
+                f'Task {params["id"]} has already been processed (state: {task["status"]["state"]})'
+            )
 
         await self.storage.update_task(task['id'], state='working')
 
-        # TODO(Marcelo): We need to have a way to communicate when the task is set to `input-required`. Maybe
-        # a custom `output_type` with a `more_info_required` field, or something like that.
+        # Load context - contains pydantic-ai message history from previous tasks in this conversation
+        message_history = await self.storage.load_context(task['context_id']) or []
+        message_history.extend(self.build_message_history(task.get('history', [])))
+
+        try:
+            result = await self.agent.run(message_history=message_history)  # type: ignore
 
-        task_history = task.get('history', [])
-        message_history = self.build_message_history(task_history=task_history)
+            await self.storage.update_context(task['context_id'], result.all_messages())
 
-        # TODO(Marcelo): We need to make this more customizable e.g. pass deps.
-        result = await self.agent.run(message_history=message_history)  # type: ignore
+            # Convert new messages to A2A format for task history
+            a2a_messages: list[Message] = []
+
+            for message in result.new_messages():
+                if isinstance(message, ModelRequest):
+                    # Skip user prompts - they're already in task history
+                    continue
+                else:
+                    # Convert response parts to A2A format
+                    a2a_parts = self._response_parts_to_a2a(message.parts)
+                    if a2a_parts:  # Add if there are visible parts (text/thinking)
+                        a2a_messages.append(
+                            Message(role='agent', parts=a2a_parts, kind='message', message_id=str(uuid.uuid4()))
+                        )
 
-        artifacts = self.build_artifacts(result.output)
-        await self.storage.update_task(task['id'], state='completed', artifacts=artifacts)
+            artifacts = self.build_artifacts(result.output)
+        except Exception:
+            await self.storage.update_task(task['id'], state='failed')
+            raise
+        else:
+            await self.storage.update_task(
+                task['id'], state='completed', new_artifacts=artifacts, new_messages=a2a_messages
+            )
 
     async def cancel_task(self, params: TaskIdParams) -> None:
         pass
 
-    def build_artifacts(self, result: Any) -> list[Artifact]:
-        # TODO(Marcelo): We need to send the json schema of the result on the metadata of the message.
-        return [Artifact(name='result', index=0, parts=[A2ATextPart(type='text', text=str(result))])]
+    def build_artifacts(self, result: WorkerOutputT) -> list[Artifact]:
+        """Build artifacts from agent result.
 
-    def build_message_history(self, task_history: list[Message]) -> list[ModelMessage]:
+        All agent outputs become artifacts to mark them as durable task outputs.
+        For string results, we use TextPart. For structured data, we use DataPart.
+        Metadata is included to preserve type information.
+        """
+        artifact_id = str(uuid.uuid4())
+        part = self._convert_result_to_part(result)
+        return [Artifact(artifact_id=artifact_id, name='result', parts=[part])]
+
+    def _convert_result_to_part(self, result: WorkerOutputT) -> Part:
+        """Convert agent result to a Part (TextPart or DataPart).
+
+        For string results, returns a TextPart.
+        For structured data, returns a DataPart with properly serialized data.
+        """
+        if isinstance(result, str):
+            return A2ATextPart(kind='text', text=result)
+        else:
+            output_type = type(result)
+            type_adapter = TypeAdapter(output_type)
+            data = type_adapter.dump_python(result, mode='json')
+            json_schema = type_adapter.json_schema(mode='serialization')
+            return DataPart(kind='data', data={'result': data}, metadata={'json_schema': json_schema})
+
+    def build_message_history(self, history: list[Message]) -> list[ModelMessage]:
         model_messages: list[ModelMessage] = []
-        for message in task_history:
+        for message in history:
             if message['role'] == 'user':
-                model_messages.append(ModelRequest(parts=self._map_request_parts(message['parts'])))
+                model_messages.append(ModelRequest(parts=self._request_parts_from_a2a(message['parts'])))
             else:
-                model_messages.append(ModelResponse(parts=self._map_response_parts(message['parts'])))
+                model_messages.append(ModelResponse(parts=self._response_parts_from_a2a(message['parts'])))
         return model_messages
 
-    def _map_request_parts(self, parts: list[Part]) -> list[ModelRequestPart]:
+    def _request_parts_from_a2a(self, parts: list[Part]) -> list[ModelRequestPart]:
+        """Convert A2A Part objects to pydantic-ai ModelRequestPart objects.
+
+        This handles the conversion from A2A protocol parts (text, file, data) to
+        pydantic-ai's internal request parts (UserPromptPart with various content types).
+
+        Args:
+            parts: List of A2A Part objects from incoming messages
+
+        Returns:
+            List of ModelRequestPart objects for the pydantic-ai agent
+        """
         model_parts: list[ModelRequestPart] = []
         for part in parts:
-            if part['type'] == 'text':
+            if part['kind'] == 'text':
                 model_parts.append(UserPromptPart(content=part['text']))
-            elif part['type'] == 'file':
-                file = part['file']
-                if 'data' in file:
-                    data = file['data'].encode('utf-8')
-                    content = BinaryContent(data=data, media_type=file['mime_type'])
+            elif part['kind'] == 'file':
+                file_content = part['file']
+                if 'bytes' in file_content:
+                    data = file_content['bytes'].encode('utf-8')
+                    mime_type = file_content.get('mime_type', 'application/octet-stream')
+                    content = BinaryContent(data=data, media_type=mime_type)
                     model_parts.append(UserPromptPart(content=[content]))
                 else:
-                    url = file['url']
+                    url = file_content['uri']
                     for url_cls in (DocumentUrl, AudioUrl, ImageUrl, VideoUrl):
                         content = url_cls(url=url)
                         try:
@@ -168,24 +238,68 @@ class AgentWorker(Worker, Generic[AgentDepsT, OutputDataT]):
                         else:
                             break
                     else:
-                        raise ValueError(f'Unknown file type: {file["mime_type"]}')  # pragma: no cover
+                        raise ValueError(f'Unsupported file type: {url}')  # pragma: no cover
                     model_parts.append(UserPromptPart(content=[content]))
-            elif part['type'] == 'data':
-                # TODO(Marcelo): Maybe we should use this for `ToolReturnPart`, and `RetryPromptPart`.
+            elif part['kind'] == 'data':
                 raise NotImplementedError('Data parts are not supported yet.')
             else:
                 assert_never(part)
         return model_parts
 
-    def _map_response_parts(self, parts: list[Part]) -> list[ModelResponsePart]:
+    def _response_parts_from_a2a(self, parts: list[Part]) -> list[ModelResponsePart]:
+        """Convert A2A Part objects to pydantic-ai ModelResponsePart objects.
+
+        This handles the conversion from A2A protocol parts (text, file, data) to
+        pydantic-ai's internal response parts. Currently only supports text parts
+        as agent responses in A2A are expected to be text-based.
+
+        Args:
+            parts: List of A2A Part objects from stored agent messages
+
+        Returns:
+            List of ModelResponsePart objects for message history
+        """
         model_parts: list[ModelResponsePart] = []
         for part in parts:
-            if part['type'] == 'text':
+            if part['kind'] == 'text':
                 model_parts.append(TextPart(content=part['text']))
-            elif part['type'] == 'file':  # pragma: no cover
+            elif part['kind'] == 'file':  # pragma: no cover
                 raise NotImplementedError('File parts are not supported yet.')
-            elif part['type'] == 'data':  # pragma: no cover
+            elif part['kind'] == 'data':  # pragma: no cover
                 raise NotImplementedError('Data parts are not supported yet.')
             else:  # pragma: no cover
                 assert_never(part)
         return model_parts
+
+    def _response_parts_to_a2a(self, parts: list[ModelResponsePart]) -> list[Part]:
+        """Convert pydantic-ai ModelResponsePart objects to A2A Part objects.
+
+        This handles the conversion from pydantic-ai's internal response parts to
+        A2A protocol parts. Different part types are handled as follows:
+        - TextPart: Converted directly to A2A TextPart
+        - ThinkingPart: Converted to TextPart with metadata indicating it's thinking
+        - ToolCallPart: Skipped (internal to agent execution)
+
+        Args:
+            parts: List of ModelResponsePart objects from agent response
+
+        Returns:
+            List of A2A Part objects suitable for sending via A2A protocol
+        """
+        a2a_parts: list[Part] = []
+        for part in parts:
+            if isinstance(part, TextPart):
+                a2a_parts.append(A2ATextPart(kind='text', text=part.content))
+            elif isinstance(part, ThinkingPart):
+                # Convert thinking to text with metadata
+                a2a_parts.append(
+                    A2ATextPart(
+                        kind='text',
+                        text=part.content,
+                        metadata={'type': 'thinking', 'thinking_id': part.id, 'signature': part.signature},
+                    )
+                )
+            elif isinstance(part, ToolCallPart):
+                # Skip tool calls - they're internal to agent execution
+                pass
+        return a2a_parts

pydantic_ai/_function_schema.py

@@ -35,7 +35,7 @@ class FunctionSchema:
     """Internal information about a function schema."""
 
     function: Callable[..., Any]
-    description: str
+    description: str | None
     validator: SchemaValidator
     json_schema: ObjectJsonSchema
     # if not None, the function takes a single by that name (besides potentially `info`)

pydantic_ai/_griffe.py

@@ -19,7 +19,7 @@ def doc_descriptions(
     sig: Signature,
     *,
     docstring_format: DocstringFormat,
-) -> tuple[str, dict[str, str]]:
+) -> tuple[str | None, dict[str, str]]:
     """Extract the function description and parameter descriptions from a function's docstring.
 
     The function parses the docstring using the specified format (or infers it if 'auto')
@@ -35,7 +35,7 @@ def doc_descriptions(
     """
     doc = func.__doc__
     if doc is None:
-        return '', {}
+        return None, {}
 
     # see https://github.com/mkdocstrings/griffe/issues/293
     parent = cast(GriffeObject, sig)

pydantic_ai/_utils.py

@@ -315,8 +315,11 @@ def dataclasses_no_defaults_repr(self: Any) -> str:
     return f'{self.__class__.__qualname__}({", ".join(kv_pairs)})'
 
 
+_datetime_ta = TypeAdapter(datetime)
+
+
 def number_to_datetime(x: int | float) -> datetime:
-    return TypeAdapter(datetime).validate_python(x)
+    return _datetime_ta.validate_python(x)
 
 
 AwaitableCallable = Callable[..., Awaitable[T]]

pydantic_ai/agent.py

@@ -63,7 +63,7 @@ if TYPE_CHECKING:
 
     from fasta2a.applications import FastA2A
     from fasta2a.broker import Broker
-    from fasta2a.schema import Provider, Skill
+    from fasta2a.schema import AgentProvider, Skill
     from fasta2a.storage import Storage
     from pydantic_ai.mcp import MCPServer
 
@@ -1764,7 +1764,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
         url: str = 'http://localhost:8000',
         version: str = '1.0.0',
         description: str | None = None,
-        provider: Provider | None = None,
+        provider: AgentProvider | None = None,
         skills: list[Skill] | None = None,
         # Starlette
         debug: bool = False,

pydantic_ai/mcp.py

@@ -98,7 +98,7 @@ class MCPServer(ABC):
         return [
             tools.ToolDefinition(
                 name=self.get_prefixed_tool_name(tool.name),
-                description=tool.description or '',
+                description=tool.description,
                 parameters_json_schema=tool.inputSchema,
             )
             for tool in mcp_tools.tools

pydantic_ai/messages.py

@@ -25,7 +25,7 @@ if TYPE_CHECKING:
     from .models.instrumented import InstrumentationSettings
 
 
-AudioMediaType: TypeAlias = Literal['audio/wav', 'audio/mpeg']
+AudioMediaType: TypeAlias = Literal['audio/wav', 'audio/mpeg', 'audio/ogg', 'audio/flac', 'audio/aiff', 'audio/aac']
 ImageMediaType: TypeAlias = Literal['image/jpeg', 'image/png', 'image/gif', 'image/webp']
 DocumentMediaType: TypeAlias = Literal[
     'application/pdf',
@@ -48,7 +48,7 @@ VideoMediaType: TypeAlias = Literal[
     'video/3gpp',
 ]
 
-AudioFormat: TypeAlias = Literal['wav', 'mp3']
+AudioFormat: TypeAlias = Literal['wav', 'mp3', 'oga', 'flac', 'aiff', 'aac']
 ImageFormat: TypeAlias = Literal['jpeg', 'png', 'gif', 'webp']
 DocumentFormat: TypeAlias = Literal['csv', 'doc', 'docx', 'html', 'md', 'pdf', 'txt', 'xls', 'xlsx']
 VideoFormat: TypeAlias = Literal['mkv', 'mov', 'mp4', 'webm', 'flv', 'mpeg', 'mpg', 'wmv', 'three_gp']
@@ -182,13 +182,25 @@ class AudioUrl(FileUrl):
 
     @property
     def media_type(self) -> AudioMediaType:
-        """Return the media type of the audio file, based on the url."""
+        """Return the media type of the audio file, based on the url.
+
+        References:
+        - Gemini: https://ai.google.dev/gemini-api/docs/audio#supported-formats
+        """
         if self.url.endswith('.mp3'):
             return 'audio/mpeg'
-        elif self.url.endswith('.wav'):
+        if self.url.endswith('.wav'):
             return 'audio/wav'
-        else:
-            raise ValueError(f'Unknown audio file extension: {self.url}')
+        if self.url.endswith('.flac'):
+            return 'audio/flac'
+        if self.url.endswith('.oga'):
+            return 'audio/ogg'
+        if self.url.endswith('.aiff'):
+            return 'audio/aiff'
+        if self.url.endswith('.aac'):
+            return 'audio/aac'
+
+        raise ValueError(f'Unknown audio file extension: {self.url}')
 
     @property
     def format(self) -> AudioFormat:
@@ -358,6 +370,10 @@ _document_format_lookup: dict[str, DocumentFormat] = {
 _audio_format_lookup: dict[str, AudioFormat] = {
     'audio/mpeg': 'mp3',
     'audio/wav': 'wav',
+    'audio/flac': 'flac',
+    'audio/ogg': 'oga',
+    'audio/aiff': 'aiff',
+    'audio/aac': 'aac',
 }
 _image_format_lookup: dict[str, ImageFormat] = {
     'image/jpeg': 'jpeg',

pydantic_ai/models/anthropic.py

@@ -416,7 +416,7 @@ class AnthropicModel(Model):
     def _map_tool_definition(f: ToolDefinition) -> BetaToolParam:
         return {
             'name': f.name,
-            'description': f.description,
+            'description': f.description or '',
             'input_schema': f.parameters_json_schema,
         }
 

pydantic_ai/models/bedrock.py

@@ -62,6 +62,7 @@ if TYPE_CHECKING:
         SystemContentBlockTypeDef,
         ToolChoiceTypeDef,
         ToolConfigurationTypeDef,
+        ToolSpecificationTypeDef,
         ToolTypeDef,
         VideoBlockTypeDef,
     )
@@ -228,14 +229,16 @@ class BedrockConverseModel(Model):
 
     @staticmethod
     def _map_tool_definition(f: ToolDefinition) -> ToolTypeDef:
-        return {
-            'toolSpec': {
-                'name': f.name,
-                'description': f.description,
-                'inputSchema': {'json': f.parameters_json_schema},
-            }
+        tool_spec: ToolSpecificationTypeDef = {
+            'name': f.name,
+            'inputSchema': {'json': f.parameters_json_schema},
         }
 
+        if f.description:  # pragma: no branch
+            tool_spec['description'] = f.description
+
+        return {'toolSpec': tool_spec}
+
     @property
     def base_url(self) -> str:
         return str(self.client.meta.endpoint_url)

pydantic_ai/models/gemini.py

@@ -773,7 +773,7 @@ class _GeminiFunction(TypedDict):
 
 def _function_from_abstract_tool(tool: ToolDefinition) -> _GeminiFunction:
     json_schema = tool.parameters_json_schema
-    f = _GeminiFunction(name=tool.name, description=tool.description, parameters=json_schema)
+    f = _GeminiFunction(name=tool.name, description=tool.description or '', parameters=json_schema)
     return f
 
 

pydantic_ai/models/google.py

@@ -534,7 +534,7 @@ def _function_declaration_from_tool(tool: ToolDefinition) -> FunctionDeclaration
     json_schema = tool.parameters_json_schema
     f = FunctionDeclarationDict(
         name=tool.name,
-        description=tool.description,
+        description=tool.description or '',
         parameters=json_schema,  # type: ignore
     )
     return f

pydantic_ai/models/groq.py

@@ -333,7 +333,7 @@ class GroqModel(Model):
             'type': 'function',
             'function': {
                 'name': f.name,
-                'description': f.description,
+                'description': f.description or '',
                 'parameters': f.parameters_json_schema,
             },
         }

pydantic_ai/models/mistral.py

@@ -306,7 +306,9 @@ class MistralModel(Model):
         )
         tools = [
             MistralTool(
-                function=MistralFunction(name=r.name, parameters=r.parameters_json_schema, description=r.description)
+                function=MistralFunction(
+                    name=r.name, parameters=r.parameters_json_schema, description=r.description or ''
+                )
             )
             for r in all_tools
         ]

pydantic_ai/models/openai.py

@@ -469,7 +469,7 @@ class OpenAIModel(Model):
             'type': 'function',
             'function': {
                 'name': f.name,
-                'description': f.description,
+                'description': f.description or '',
                 'parameters': f.parameters_json_schema,
             },
         }

pydantic_ai/profiles/openai.py

@@ -93,10 +93,18 @@ class OpenAIJsonSchemaTransformer(JsonSchemaTransformer):
     def transform(self, schema: JsonSchema) -> JsonSchema:  # noqa C901
         # Remove unnecessary keys
         schema.pop('title', None)
-        schema.pop('default', None)
         schema.pop('$schema', None)
         schema.pop('discriminator', None)
 
+        default = schema.get('default', _sentinel)
+        if default is not _sentinel:
+            # the "default" keyword is not allowed in strict mode, but including it makes some Ollama models behave
+            # better, so we keep it around when not strict
+            if self.strict is True:
+                schema.pop('default', None)
+            elif self.strict is None:  # pragma: no branch
+                self.is_strict_compatible = False
+
         if schema_ref := schema.get('$ref'):
             if schema_ref == self.root_ref:
                 schema['$ref'] = '#'

pydantic_ai/tools.py

@@ -161,7 +161,7 @@ class Tool(Generic[AgentDepsT]):
     takes_ctx: bool
     max_retries: int | None
     name: str
-    description: str
+    description: str | None
     prepare: ToolPrepareFunc[AgentDepsT] | None
     docstring_format: DocstringFormat
     require_parameter_descriptions: bool
@@ -269,7 +269,7 @@ class Tool(Generic[AgentDepsT]):
         cls,
         function: Callable[..., Any],
         name: str,
-        description: str,
+        description: str | None,
         json_schema: JsonSchemaValue,
     ) -> Self:
         """Creates a Pydantic tool from a function and a JSON schema.
@@ -440,12 +440,12 @@ class ToolDefinition:
     name: str
     """The name of the tool."""
 
-    description: str
-    """The description of the tool."""
-
     parameters_json_schema: ObjectJsonSchema
     """The JSON schema for the tool's parameters."""
 
+    description: str | None = None
+    """The description of the tool."""
+
     outer_typed_dict_key: str | None = None
     """The key in the outer [TypedDict] that wraps an output tool.
 

{pydantic_ai_slim-0.3.7.dist-info → pydantic_ai_slim-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.3.7
+Version: 0.4.1
 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>
 License-Expression: MIT
@@ -30,11 +30,11 @@ 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.3.7
+Requires-Dist: pydantic-graph==0.4.1
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
-Requires-Dist: fasta2a==0.3.7; extra == 'a2a'
+Requires-Dist: fasta2a==0.4.1; extra == 'a2a'
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.52.0; extra == 'anthropic'
 Provides-Extra: bedrock
@@ -48,7 +48,7 @@ Requires-Dist: cohere>=5.13.11; (platform_system != 'Emscripten') and extra == '
 Provides-Extra: duckduckgo
 Requires-Dist: duckduckgo-search>=7.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==0.3.7; extra == 'evals'
+Requires-Dist: pydantic-evals==0.4.1; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.24.0; extra == 'google'
 Provides-Extra: groq

{pydantic_ai_slim-0.3.7.dist-info → pydantic_ai_slim-0.4.1.dist-info}/RECORD

@@ -1,29 +1,29 @@
 pydantic_ai/__init__.py,sha256=Ns04g4Efqkzwccs8w2nGphfWbptMlIJYG8vIJbGGyG0,1262
 pydantic_ai/__main__.py,sha256=Q_zJU15DUA01YtlJ2mnaLCoId2YmgmreVEERGuQT-Y0,132
-pydantic_ai/_a2a.py,sha256=8nNtx6GENDt2Ej3f1ui9L-FuNQBYVELpJFfwz-y7fUw,7234
+pydantic_ai/_a2a.py,sha256=G6W8zLRE5FNug19GieVkYuGPw5CA44YeZnS7GTN7M30,12068
 pydantic_ai/_agent_graph.py,sha256=rtzyBXN4bzEDBeRkRwF031ORktSMbuGz9toZmSqUxNI,42153
 pydantic_ai/_cli.py,sha256=R-sE-9gYqPxV5-5utso4g-bzAKMiTCdo33XOVqE0ZEg,13206
-pydantic_ai/_function_schema.py,sha256=TP9Y1wlN7tRHTDhkJ1IopJHPWpSbxJCxS3zxCb0dpK4,10806
-pydantic_ai/_griffe.py,sha256=Sf_DisE9k2TA0VFeVIK2nf1oOct5MygW86PBCACJkFA,5244
+pydantic_ai/_function_schema.py,sha256=BZus5y51eqiGQKxQIcCiDoSPml3AtAb12-st_aujU2k,10813
+pydantic_ai/_griffe.py,sha256=Ugft16ZHw9CN_6-lW0Svn6jESK9zHXO_x4utkGBkbBI,5253
 pydantic_ai/_mcp.py,sha256=PuvwnlLjv7YYOa9AZJCrklevBug99zGMhwJCBGG7BHQ,5626
 pydantic_ai/_output.py,sha256=8qOx2hEwxpcoS5P8OLqOAWj94KfODDVqrPHnEIhI-90,33164
 pydantic_ai/_parts_manager.py,sha256=Lioi8b7Nfyax09yQu8jTkMzxd26dYDrdAqhYvjRSKqQ,16182
 pydantic_ai/_run_context.py,sha256=zNkSyiQSH-YweO39ii3iB2taouUOodo3sTjz2Lrj4Pc,1792
 pydantic_ai/_system_prompt.py,sha256=lUSq-gDZjlYTGtd6BUm54yEvTIvgdwBmJ8mLsNZZtYU,1142
 pydantic_ai/_thinking_part.py,sha256=mzx2RZSfiQxAKpljEflrcXRXmFKxtp6bKVyorY3UYZk,1554
-pydantic_ai/_utils.py,sha256=hKejTwg5rAd6ElFFSE50xbs3VO4O_3tRfZ8Dy6V2DsY,15515
-pydantic_ai/agent.py,sha256=Fs-bm9eeCvanwiKiD-IS_XLcMmgNWucJylXgrIDH6WM,96186
+pydantic_ai/_utils.py,sha256=SGXEiGCnMae1Iz_eZKUs6ni_tGMPkDaJ4W3W3YMoP5w,15545
+pydantic_ai/agent.py,sha256=zvQgEG9eFG7entCTum3QSApHbNU8RvAE_ydscPaMAC4,96196
 pydantic_ai/direct.py,sha256=WRfgke3zm-eeR39LTuh9XI2TrdHXAqO81eDvFwih4Ko,14803
 pydantic_ai/exceptions.py,sha256=IdFw594Ou7Vn4YFa7xdZ040_j_6nmyA3MPANbC7sys4,3175
 pydantic_ai/format_as_xml.py,sha256=IINfh1evWDphGahqHNLBArB5dQ4NIqS3S-kru35ztGg,372
 pydantic_ai/format_prompt.py,sha256=qdKep95Sjlr7u1-qag4JwPbjoURbG0GbeU_l5ODTNw4,4466
-pydantic_ai/mcp.py,sha256=MSLNFiC38A1e5W7K8gQdnh0_DNLqD_AdzW064U83FJ8,21836
-pydantic_ai/messages.py,sha256=DGD9_Ct-xfcprN-yYpy_fqO5wqffuwesH7mNx4_BfD4,38701
+pydantic_ai/mcp.py,sha256=6RvxXIn6bUlL2XWpX69i8G3atU-HLLZBgKc93dYqeVo,21830
+pydantic_ai/messages.py,sha256=ykB4jzDwPGFkgQSJagOdurBv5-DTtCaY-y9671FYz7E,39256
 pydantic_ai/output.py,sha256=gq-8H2YKgbKSTxp_HUMym57ZUkwupHyS4sCOzedlXTI,9315
 pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/result.py,sha256=GVzXf7yjR2lKBDw9k-8PlhJgCpE3dVHiyLL0dFPvs7I,25603
 pydantic_ai/settings.py,sha256=yuUZ7-GkdPB-Gbx71kSdh8dSr6gwM9gEwk84qNxPO_I,3552
-pydantic_ai/tools.py,sha256=SQyLA5X3ILhjUW7kUTZefiUCNwhQhEETxkSC2JH4kCI,17746
+pydantic_ai/tools.py,sha256=ZZ5DZMzSLMZkM9y_G3fx5YnVTki6daPYgRkfuNXAQ-M,17774
 pydantic_ai/usage.py,sha256=35YPmItlzfNOwP35Rhh0qBUOlg5On5rUE7xqHQWrpaU,5596
 pydantic_ai/common_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/common_tools/duckduckgo.py,sha256=Ty9tu1rCwMfGKgz1JAaC2q_4esmL6QvpkHQUN8F0Ecc,2152
@@ -32,18 +32,18 @@ pydantic_ai/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/ext/aci.py,sha256=eiuWamUh90kexWyuGw_Fw2kM-EAA6Pv-IfNhf5hQ8fs,2123
 pydantic_ai/ext/langchain.py,sha256=iSyACZiJDDvxr0BKYl9dLxe4BPezCBHxgz_2Vk3W-Ak,1973
 pydantic_ai/models/__init__.py,sha256=B8vG0crUDCO3Bvd8fVeMNPzZH2Un61rEJFxSaumoUl4,29101
-pydantic_ai/models/anthropic.py,sha256=4kWGrKvyv32VmpyHXzqrGyLDUxIiNj15HSW_wJ3mEoU,23673
-pydantic_ai/models/bedrock.py,sha256=41rHdPpa7OfVXVaglyNeu54bptQxbVOWcuTpTWJd78A,29122
+pydantic_ai/models/anthropic.py,sha256=ooRh6Yh0jLj78IKjgaYTN0UbB2Ku8ZhuEBi8v8kymoE,23679
+pydantic_ai/models/bedrock.py,sha256=i8BNOFEYGiRYA4ZEFwqHzJHf3EP54akVzZHdEUJohiw,29234
 pydantic_ai/models/cohere.py,sha256=qgYegjfOsqXbRcjXCbg0jaexbuxh1SrS9_mZdzzJVbM,12623
 pydantic_ai/models/fallback.py,sha256=sTYw8wW8iGgFIPG2Oynsucb9orG6wbV_h-9k5vKil4I,5103
 pydantic_ai/models/function.py,sha256=nfCjRmbcF7sdK_nsak1fvzz9Xkptx5WhsxvWdB02zec,12113
-pydantic_ai/models/gemini.py,sha256=IB1GUtdlYX6GePXRWZYGY8ickhB5aNSGnjOcwgNqs7Q,38482
-pydantic_ai/models/google.py,sha256=F9m6uH3lxApzcevE61Vq0Pb2T4gmQNHb6Y5Yy-ZQvTc,24066
-pydantic_ai/models/groq.py,sha256=NHHOR4rfia3GmiA2qGnSCrXQaIPpPM3G0D2-XIzj43Q,18494
+pydantic_ai/models/gemini.py,sha256=22qucwayi8x20yvZY6qeHH4WRyEObfIkrCQ5cluejdQ,38488
+pydantic_ai/models/google.py,sha256=PFioCPeuf5_f80s9NiRSxFZawvfYbUUhpaW7mUg8frg,24072
+pydantic_ai/models/groq.py,sha256=tmYTPKsMMhtIms_9muPKYQvGZ98b_kax7t8H1YE1vPU,18500
 pydantic_ai/models/instrumented.py,sha256=olTa7Fl2BwHLvTLT6sSrS2HOS7UyWg182Xujx8hutBw,15947
 pydantic_ai/models/mcp_sampling.py,sha256=q9nnjNEAAbhrfRc_Qw5z9TtCHMG_SwlCWW9FvKWjh8k,3395
-pydantic_ai/models/mistral.py,sha256=reE_x3r6q8qMP05qwCUeSkzBxuRvv29v2rSIHFyXML4,30511
-pydantic_ai/models/openai.py,sha256=f0BwWnZ951Sa39bZ0-YKvDbgXwhc_UIre4BztzsXBB8,53640
+pydantic_ai/models/mistral.py,sha256=d_TQjSQukSztNt6JpFQCqugYTxXQ97GaQBc3zUxOSSA,30555
+pydantic_ai/models/openai.py,sha256=ReqpM4gdM0TPSwUCGu2L8VoBFsxy2Y-8PRFhI6d5KcI,53646
 pydantic_ai/models/test.py,sha256=STNd79ZoCyyphm0eFRNDoTpvkOzhw1qFw1zgv44kqsg,17441
 pydantic_ai/models/wrapper.py,sha256=2g06TxE5kFqfaJCwsDJHp7Rltoj0XXH0OzdpRDOcqNo,1861
 pydantic_ai/profiles/__init__.py,sha256=BXMqUpgRfosmYgcxjKAI9ESCj47JTSa30DhKXEgVLzM,2419
@@ -56,7 +56,7 @@ pydantic_ai/profiles/google.py,sha256=DJ0otpkCgVIrjwV2lzAUAejw8ivwZT9pNAY_sGRcrV
 pydantic_ai/profiles/grok.py,sha256=nBOxOCYCK9aiLmz2Q-esqYhotNbbBC1boAoOYIk1tVw,211
 pydantic_ai/profiles/meta.py,sha256=IAGPoUrLWd-g9ajAgpWp9fIeOrP-7dBlZ2HEFjIhUbY,334
 pydantic_ai/profiles/mistral.py,sha256=ll01PmcK3szwlTfbaJLQmfd0TADN8lqjov9HpPJzCMQ,217
-pydantic_ai/profiles/openai.py,sha256=DzrKYvegfCerqavHU3jHzrNQCm0IllWoIqS7_DiQB9M,6281
+pydantic_ai/profiles/openai.py,sha256=wFFtzbM22HbxxRNDXYEs6tr6_RSbv8xN_xBPz6RsP9s,6698
 pydantic_ai/profiles/qwen.py,sha256=u7pL8uomoQTVl45g5wDrHx0P_oFDLaN6ALswuwmkWc0,334
 pydantic_ai/providers/__init__.py,sha256=JNsVZ1PBx_9hUJZbnoRIDJCkWbrJbk69w-SFqjoG-6c,3654
 pydantic_ai/providers/anthropic.py,sha256=D35UXxCPXv8yIbD0fj9Zg2FvNyoMoJMeDUtVM8Sn78I,3046
@@ -76,8 +76,8 @@ pydantic_ai/providers/mistral.py,sha256=EIUSENjFuGzBhvbdrarUTM4VPkesIMnZrzfnEKHO
 pydantic_ai/providers/openai.py,sha256=7iGij0EaFylab7dTZAZDgXr78tr-HsZrn9EI9AkWBNQ,3091
 pydantic_ai/providers/openrouter.py,sha256=NXjNdnlXIBrBMMqbzcWQnowXOuZh4NHikXenBn5h3mc,4061
 pydantic_ai/providers/together.py,sha256=zFVSMSm5jXbpkNouvBOTjWrPmlPpCp6sQS5LMSyVjrQ,3482
-pydantic_ai_slim-0.3.7.dist-info/METADATA,sha256=ourVNvtmorrRHZGFYk8kNLDBZr6mKDSHtL9f_NRITAc,3846
-pydantic_ai_slim-0.3.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-0.3.7.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
-pydantic_ai_slim-0.3.7.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
-pydantic_ai_slim-0.3.7.dist-info/RECORD,,
+pydantic_ai_slim-0.4.1.dist-info/METADATA,sha256=PqGrAd6qbv0rxMgiCa6N1Lo1mBvMb3XUC_FGaxuzeAY,3846
+pydantic_ai_slim-0.4.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-0.4.1.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
+pydantic_ai_slim-0.4.1.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
+pydantic_ai_slim-0.4.1.dist-info/RECORD,,