pydantic-ai-slim 0.0.35__py3-none-any.whl → 0.0.37__py3-none-any.whl

pydantic_ai/_pydantic.py

@@ -6,7 +6,7 @@ This module has to use numerous internal Pydantic APIs and is therefore brittle
 from __future__ import annotations as _annotations
 
 from inspect import Parameter, signature
-from typing import TYPE_CHECKING, Any, Callable, TypedDict, cast
+from typing import TYPE_CHECKING, Any, Callable, cast
 
 from pydantic import ConfigDict
 from pydantic._internal import _decorators, _generate_schema, _typing_extra
@@ -15,7 +15,7 @@ from pydantic.fields import FieldInfo
 from pydantic.json_schema import GenerateJsonSchema
 from pydantic.plugin._schema_validator import create_schema_validator
 from pydantic_core import SchemaValidator, core_schema
-from typing_extensions import get_origin
+from typing_extensions import TypedDict, get_origin
 
 from ._griffe import doc_descriptions
 from ._utils import check_object_json_schema, is_model_like

pydantic_ai/agent.py

@@ -922,6 +922,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         self,
         /,
         *,
+        name: str | None = None,
         retries: int | None = None,
         prepare: ToolPrepareFunc[AgentDepsT] | None = None,
         docstring_format: DocstringFormat = 'auto',
@@ -933,6 +934,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         func: ToolFuncContext[AgentDepsT, ToolParams] | None = None,
         /,
         *,
+        name: str | None = None,
         retries: int | None = None,
         prepare: ToolPrepareFunc[AgentDepsT] | None = None,
         docstring_format: DocstringFormat = 'auto',
@@ -969,6 +971,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
 
         Args:
             func: The tool function to register.
+            name: The name of the tool, defaults to the function name.
             retries: The number of retries to allow for this tool, defaults to the agent's default retries,
                 which defaults to 1.
             prepare: custom method to prepare the tool definition for each step, return `None` to omit this
@@ -984,13 +987,17 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
                 func_: ToolFuncContext[AgentDepsT, ToolParams],
             ) -> ToolFuncContext[AgentDepsT, ToolParams]:
                 # noinspection PyTypeChecker
-                self._register_function(func_, True, retries, prepare, docstring_format, require_parameter_descriptions)
+                self._register_function(
+                    func_, True, name, retries, prepare, docstring_format, require_parameter_descriptions
+                )
                 return func_
 
             return tool_decorator
         else:
             # noinspection PyTypeChecker
-            self._register_function(func, True, retries, prepare, docstring_format, require_parameter_descriptions)
+            self._register_function(
+                func, True, name, retries, prepare, docstring_format, require_parameter_descriptions
+            )
             return func
 
     @overload
@@ -1001,6 +1008,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         self,
         /,
         *,
+        name: str | None = None,
         retries: int | None = None,
         prepare: ToolPrepareFunc[AgentDepsT] | None = None,
         docstring_format: DocstringFormat = 'auto',
@@ -1012,6 +1020,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         func: ToolFuncPlain[ToolParams] | None = None,
         /,
         *,
+        name: str | None = None,
         retries: int | None = None,
         prepare: ToolPrepareFunc[AgentDepsT] | None = None,
         docstring_format: DocstringFormat = 'auto',
@@ -1048,6 +1057,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
 
         Args:
             func: The tool function to register.
+            name: The name of the tool, defaults to the function name.
             retries: The number of retries to allow for this tool, defaults to the agent's default retries,
                 which defaults to 1.
             prepare: custom method to prepare the tool definition for each step, return `None` to omit this
@@ -1062,19 +1072,22 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
             def tool_decorator(func_: ToolFuncPlain[ToolParams]) -> ToolFuncPlain[ToolParams]:
                 # noinspection PyTypeChecker
                 self._register_function(
-                    func_, False, retries, prepare, docstring_format, require_parameter_descriptions
+                    func_, False, name, retries, prepare, docstring_format, require_parameter_descriptions
                 )
                 return func_
 
             return tool_decorator
         else:
-            self._register_function(func, False, retries, prepare, docstring_format, require_parameter_descriptions)
+            self._register_function(
+                func, False, name, retries, prepare, docstring_format, require_parameter_descriptions
+            )
             return func
 
     def _register_function(
         self,
         func: ToolFuncEither[AgentDepsT, ToolParams],
         takes_ctx: bool,
+        name: str | None,
         retries: int | None,
         prepare: ToolPrepareFunc[AgentDepsT] | None,
         docstring_format: DocstringFormat,
@@ -1085,6 +1098,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         tool = Tool[AgentDepsT](
             func,
             takes_ctx=takes_ctx,
+            name=name,
             max_retries=retries_,
             prepare=prepare,
             docstring_format=docstring_format,

pydantic_ai/common_tools/duckduckgo.py

@@ -1,10 +1,10 @@
 import functools
 from dataclasses import dataclass
-from typing import TypedDict
 
 import anyio
 import anyio.to_thread
 from pydantic import TypeAdapter
+from typing_extensions import TypedDict
 
 from pydantic_ai.tools import Tool
 

pydantic_ai/common_tools/tavily.py

@@ -1,7 +1,8 @@
 from dataclasses import dataclass
-from typing import Literal, TypedDict
+from typing import Literal
 
 from pydantic import TypeAdapter
+from typing_extensions import TypedDict
 
 from pydantic_ai.tools import Tool
 

pydantic_ai/messages.py

@@ -395,7 +395,9 @@ class ModelResponse:
 ModelMessage = Annotated[Union[ModelRequest, ModelResponse], pydantic.Discriminator('kind')]
 """Any message sent to or returned by a model."""
 
-ModelMessagesTypeAdapter = pydantic.TypeAdapter(list[ModelMessage], config=pydantic.ConfigDict(defer_build=True))
+ModelMessagesTypeAdapter = pydantic.TypeAdapter(
+    list[ModelMessage], config=pydantic.ConfigDict(defer_build=True, ser_json_bytes='base64')
+)
 """Pydantic [`TypeAdapter`][pydantic.type_adapter.TypeAdapter] for (de)serializing messages."""
 
 

pydantic_ai/models/__init__.py

@@ -34,6 +34,49 @@ KnownModelName = Literal[
     'anthropic:claude-3-opus-latest',
     'claude-3-7-sonnet-latest',
     'claude-3-5-haiku-latest',
+    'bedrock:amazon.titan-tg1-large',
+    'bedrock:amazon.titan-text-lite-v1',
+    'bedrock:amazon.titan-text-express-v1',
+    'bedrock:us.amazon.nova-pro-v1:0',
+    'bedrock:us.amazon.nova-lite-v1:0',
+    'bedrock:us.amazon.nova-micro-v1:0',
+    'bedrock:anthropic.claude-3-5-sonnet-20241022-v2:0',
+    'bedrock:us.anthropic.claude-3-5-sonnet-20241022-v2:0',
+    'bedrock:anthropic.claude-3-5-haiku-20241022-v1:0',
+    'bedrock:us.anthropic.claude-3-5-haiku-20241022-v1:0',
+    'bedrock:anthropic.claude-instant-v1',
+    'bedrock:anthropic.claude-v2:1',
+    'bedrock:anthropic.claude-v2',
+    'bedrock:anthropic.claude-3-sonnet-20240229-v1:0',
+    'bedrock:us.anthropic.claude-3-sonnet-20240229-v1:0',
+    'bedrock:anthropic.claude-3-haiku-20240307-v1:0',
+    'bedrock:us.anthropic.claude-3-haiku-20240307-v1:0',
+    'bedrock:anthropic.claude-3-opus-20240229-v1:0',
+    'bedrock:us.anthropic.claude-3-opus-20240229-v1:0',
+    'bedrock:anthropic.claude-3-5-sonnet-20240620-v1:0',
+    'bedrock:us.anthropic.claude-3-5-sonnet-20240620-v1:0',
+    'bedrock:anthropic.claude-3-7-sonnet-20250219-v1:0',
+    'bedrock:us.anthropic.claude-3-7-sonnet-20250219-v1:0',
+    'bedrock:cohere.command-text-v14',
+    'bedrock:cohere.command-r-v1:0',
+    'bedrock:cohere.command-r-plus-v1:0',
+    'bedrock:cohere.command-light-text-v14',
+    'bedrock:meta.llama3-8b-instruct-v1:0',
+    'bedrock:meta.llama3-70b-instruct-v1:0',
+    'bedrock:meta.llama3-1-8b-instruct-v1:0',
+    'bedrock:us.meta.llama3-1-8b-instruct-v1:0',
+    'bedrock:meta.llama3-1-70b-instruct-v1:0',
+    'bedrock:us.meta.llama3-1-70b-instruct-v1:0',
+    'bedrock:meta.llama3-1-405b-instruct-v1:0',
+    'bedrock:us.meta.llama3-2-11b-instruct-v1:0',
+    'bedrock:us.meta.llama3-2-90b-instruct-v1:0',
+    'bedrock:us.meta.llama3-2-1b-instruct-v1:0',
+    'bedrock:us.meta.llama3-2-3b-instruct-v1:0',
+    'bedrock:us.meta.llama3-3-70b-instruct-v1:0',
+    'bedrock:mistral.mistral-7b-instruct-v0:2',
+    'bedrock:mistral.mixtral-8x7b-instruct-v0:1',
+    'bedrock:mistral.mistral-large-2402-v1:0',
+    'bedrock:mistral.mistral-large-2407-v1:0',
     'claude-3-5-sonnet-latest',
     'claude-3-opus-latest',
     'cohere:c4ai-aya-expanse-32b',
@@ -223,6 +266,11 @@ class Model(ABC):
         """The system / model provider, ex: openai."""
         raise NotImplementedError()
 
+    @property
+    def base_url(self) -> str | None:
+        """The base URL for the provider API, if available."""
+        return None
+
 
 @dataclass
 class StreamedResponse(ABC):
@@ -324,7 +372,7 @@ def infer_model(model: Model | KnownModelName) -> Model:
         return TestModel()
 
     try:
-        provider, model_name = model.split(':')
+        provider, model_name = model.split(':', maxsplit=1)
     except ValueError:
         model_name = model
         # TODO(Marcelo): We should deprecate this way.
@@ -368,6 +416,10 @@ def infer_model(model: Model | KnownModelName) -> Model:
 
         # TODO(Marcelo): Missing provider API.
         return AnthropicModel(model_name)
+    elif provider == 'bedrock':
+        from .bedrock import BedrockConverseModel
+
+        return BedrockConverseModel(model_name)
     else:
         raise UserError(f'Unknown model: {model}')
 

pydantic_ai/models/anthropic.py

@@ -143,6 +143,10 @@ class AnthropicModel(Model):
         else:
             self.client = AsyncAnthropic(api_key=api_key, http_client=cached_async_http_client())
 
+    @property
+    def base_url(self) -> str:
+        return str(self.client.base_url)
+
     async def request(
         self,
         messages: list[ModelMessage],

pydantic_ai/models/bedrock.py

@@ -0,0 +1,455 @@
+from __future__ import annotations
+
+import functools
+import typing
+from collections.abc import AsyncIterator, Iterable
+from contextlib import asynccontextmanager
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import TYPE_CHECKING, Generic, Literal, Union, cast, overload
+
+import anyio
+import anyio.to_thread
+from typing_extensions import ParamSpec, assert_never
+
+from pydantic_ai import _utils, result
+from pydantic_ai.messages import (
+    ModelMessage,
+    ModelRequest,
+    ModelResponse,
+    ModelResponsePart,
+    ModelResponseStreamEvent,
+    RetryPromptPart,
+    SystemPromptPart,
+    TextPart,
+    ToolCallPart,
+    ToolReturnPart,
+    UserPromptPart,
+)
+from pydantic_ai.models import Model, ModelRequestParameters, StreamedResponse
+from pydantic_ai.providers import Provider, infer_provider
+from pydantic_ai.settings import ModelSettings
+from pydantic_ai.tools import ToolDefinition
+
+if TYPE_CHECKING:
+    from botocore.client import BaseClient
+    from botocore.eventstream import EventStream
+    from mypy_boto3_bedrock_runtime import BedrockRuntimeClient
+    from mypy_boto3_bedrock_runtime.type_defs import (
+        ContentBlockOutputTypeDef,
+        ConverseResponseTypeDef,
+        ConverseStreamMetadataEventTypeDef,
+        ConverseStreamOutputTypeDef,
+        InferenceConfigurationTypeDef,
+        MessageUnionTypeDef,
+        ToolChoiceTypeDef,
+        ToolTypeDef,
+    )
+
+
+LatestBedrockModelNames = Literal[
+    'amazon.titan-tg1-large',
+    'amazon.titan-text-lite-v1',
+    'amazon.titan-text-express-v1',
+    'us.amazon.nova-pro-v1:0',
+    'us.amazon.nova-lite-v1:0',
+    'us.amazon.nova-micro-v1:0',
+    'anthropic.claude-3-5-sonnet-20241022-v2:0',
+    'us.anthropic.claude-3-5-sonnet-20241022-v2:0',
+    'anthropic.claude-3-5-haiku-20241022-v1:0',
+    'us.anthropic.claude-3-5-haiku-20241022-v1:0',
+    'anthropic.claude-instant-v1',
+    'anthropic.claude-v2:1',
+    'anthropic.claude-v2',
+    'anthropic.claude-3-sonnet-20240229-v1:0',
+    'us.anthropic.claude-3-sonnet-20240229-v1:0',
+    'anthropic.claude-3-haiku-20240307-v1:0',
+    'us.anthropic.claude-3-haiku-20240307-v1:0',
+    'anthropic.claude-3-opus-20240229-v1:0',
+    'us.anthropic.claude-3-opus-20240229-v1:0',
+    'anthropic.claude-3-5-sonnet-20240620-v1:0',
+    'us.anthropic.claude-3-5-sonnet-20240620-v1:0',
+    'anthropic.claude-3-7-sonnet-20250219-v1:0',
+    'us.anthropic.claude-3-7-sonnet-20250219-v1:0',
+    'cohere.command-text-v14',
+    'cohere.command-r-v1:0',
+    'cohere.command-r-plus-v1:0',
+    'cohere.command-light-text-v14',
+    'meta.llama3-8b-instruct-v1:0',
+    'meta.llama3-70b-instruct-v1:0',
+    'meta.llama3-1-8b-instruct-v1:0',
+    'us.meta.llama3-1-8b-instruct-v1:0',
+    'meta.llama3-1-70b-instruct-v1:0',
+    'us.meta.llama3-1-70b-instruct-v1:0',
+    'meta.llama3-1-405b-instruct-v1:0',
+    'us.meta.llama3-2-11b-instruct-v1:0',
+    'us.meta.llama3-2-90b-instruct-v1:0',
+    'us.meta.llama3-2-1b-instruct-v1:0',
+    'us.meta.llama3-2-3b-instruct-v1:0',
+    'us.meta.llama3-3-70b-instruct-v1:0',
+    'mistral.mistral-7b-instruct-v0:2',
+    'mistral.mixtral-8x7b-instruct-v0:1',
+    'mistral.mistral-large-2402-v1:0',
+    'mistral.mistral-large-2407-v1:0',
+]
+"""Latest Bedrock models."""
+
+BedrockModelName = Union[str, LatestBedrockModelNames]
+"""Possible Bedrock model names.
+
+Since Bedrock supports a variety of date-stamped models, we explicitly list the latest models but allow any name in the type hints.
+See [the Bedrock docs](https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html) for a full list.
+"""
+
+
+P = ParamSpec('P')
+T = typing.TypeVar('T')
+
+
+@dataclass(init=False)
+class BedrockConverseModel(Model):
+    """A model that uses the Bedrock Converse API."""
+
+    client: BedrockRuntimeClient
+
+    _model_name: BedrockModelName = field(repr=False)
+    _system: str | None = field(default='bedrock', repr=False)
+
+    @property
+    def model_name(self) -> str:
+        """The model name."""
+        return self._model_name
+
+    @property
+    def system(self) -> str | None:
+        """The system / model provider, ex: openai."""
+        return self._system
+
+    def __init__(
+        self,
+        model_name: BedrockModelName,
+        *,
+        provider: Literal['bedrock'] | Provider[BaseClient] = 'bedrock',
+    ):
+        """Initialize a Bedrock model.
+
+        Args:
+            model_name: The name of the model to use.
+            model_name: The name of the Bedrock model to use. List of model names available
+                [here](https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html).
+            provider: The provider to use. Defaults to `'bedrock'`.
+        """
+        self._model_name = model_name
+
+        if isinstance(provider, str):
+            self.client = infer_provider(provider).client
+        else:
+            self.client = cast('BedrockRuntimeClient', provider.client)
+
+    def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[ToolTypeDef]:
+        tools = [self._map_tool_definition(r) for r in model_request_parameters.function_tools]
+        if model_request_parameters.result_tools:
+            tools += [self._map_tool_definition(r) for r in model_request_parameters.result_tools]
+        return tools
+
+    @staticmethod
+    def _map_tool_definition(f: ToolDefinition) -> ToolTypeDef:
+        return {
+            'toolSpec': {
+                'name': f.name,
+                'description': f.description,
+                'inputSchema': {'json': f.parameters_json_schema},
+            }
+        }
+
+    @property
+    def base_url(self) -> str:
+        return str(self.client.meta.endpoint_url)
+
+    async def request(
+        self,
+        messages: list[ModelMessage],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+    ) -> tuple[ModelResponse, result.Usage]:
+        response = await self._messages_create(messages, False, model_settings, model_request_parameters)
+        return await self._process_response(response)
+
+    @asynccontextmanager
+    async def request_stream(
+        self,
+        messages: list[ModelMessage],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+    ) -> AsyncIterator[StreamedResponse]:
+        response = await self._messages_create(messages, True, model_settings, model_request_parameters)
+        yield BedrockStreamedResponse(_model_name=self.model_name, _event_stream=response)
+
+    async def _process_response(self, response: ConverseResponseTypeDef) -> tuple[ModelResponse, result.Usage]:
+        items: list[ModelResponsePart] = []
+        if message := response['output'].get('message'):
+            for item in message['content']:
+                if text := item.get('text'):
+                    items.append(TextPart(content=text))
+                else:
+                    tool_use = item.get('toolUse')
+                    assert tool_use is not None, f'Found a content that is not a text or tool use: {item}'
+                    items.append(
+                        ToolCallPart(
+                            tool_name=tool_use['name'],
+                            args=tool_use['input'],
+                            tool_call_id=tool_use['toolUseId'],
+                        ),
+                    )
+        usage = result.Usage(
+            request_tokens=response['usage']['inputTokens'],
+            response_tokens=response['usage']['outputTokens'],
+            total_tokens=response['usage']['totalTokens'],
+        )
+        return ModelResponse(items, model_name=self.model_name), usage
+
+    @overload
+    async def _messages_create(
+        self,
+        messages: list[ModelMessage],
+        stream: Literal[True],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+    ) -> EventStream[ConverseStreamOutputTypeDef]:
+        pass
+
+    @overload
+    async def _messages_create(
+        self,
+        messages: list[ModelMessage],
+        stream: Literal[False],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+    ) -> ConverseResponseTypeDef:
+        pass
+
+    async def _messages_create(
+        self,
+        messages: list[ModelMessage],
+        stream: bool,
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+    ) -> ConverseResponseTypeDef | EventStream[ConverseStreamOutputTypeDef]:
+        tools = self._get_tools(model_request_parameters)
+        support_tools_choice = self.model_name.startswith(('anthropic', 'us.anthropic'))
+        if not tools or not support_tools_choice:
+            tool_choice: ToolChoiceTypeDef = {}
+        elif not model_request_parameters.allow_text_result:
+            tool_choice = {'any': {}}
+        else:
+            tool_choice = {'auto': {}}
+
+        system_prompt, bedrock_messages = self._map_message(messages)
+        inference_config = self._map_inference_config(model_settings)
+
+        params = {
+            'modelId': self.model_name,
+            'messages': bedrock_messages,
+            'system': [{'text': system_prompt}],
+            'inferenceConfig': inference_config,
+            **(
+                {'toolConfig': {'tools': tools, **({'toolChoice': tool_choice} if tool_choice else {})}}
+                if tools
+                else {}
+            ),
+        }
+
+        if stream:
+            model_response = await anyio.to_thread.run_sync(functools.partial(self.client.converse_stream, **params))
+            model_response = model_response['stream']
+        else:
+            model_response = await anyio.to_thread.run_sync(functools.partial(self.client.converse, **params))
+        return model_response
+
+    @staticmethod
+    def _map_inference_config(
+        model_settings: ModelSettings | None,
+    ) -> InferenceConfigurationTypeDef:
+        model_settings = model_settings or {}
+        inference_config: InferenceConfigurationTypeDef = {}
+
+        if max_tokens := model_settings.get('max_tokens'):
+            inference_config['maxTokens'] = max_tokens
+        if temperature := model_settings.get('temperature'):
+            inference_config['temperature'] = temperature
+        if top_p := model_settings.get('top_p'):
+            inference_config['topP'] = top_p
+        # TODO(Marcelo): This is not included in model_settings yet.
+        # if stop_sequences := model_settings.get('stop_sequences'):
+        #     inference_config['stopSequences'] = stop_sequences
+
+        return inference_config
+
+    def _map_message(self, messages: list[ModelMessage]) -> tuple[str, list[MessageUnionTypeDef]]:
+        """Just maps a `pydantic_ai.Message` to the Bedrock `MessageUnionTypeDef`."""
+        system_prompt: str = ''
+        bedrock_messages: list[MessageUnionTypeDef] = []
+        for m in messages:
+            if isinstance(m, ModelRequest):
+                for part in m.parts:
+                    if isinstance(part, SystemPromptPart):
+                        system_prompt += part.content
+                    elif isinstance(part, UserPromptPart):
+                        if isinstance(part.content, str):
+                            bedrock_messages.append({'role': 'user', 'content': [{'text': part.content}]})
+                        else:
+                            raise NotImplementedError('User prompt can only be a string for now.')
+                    elif isinstance(part, ToolReturnPart):
+                        assert part.tool_call_id is not None
+                        bedrock_messages.append(
+                            {
+                                'role': 'user',
+                                'content': [
+                                    {
+                                        'toolResult': {
+                                            'toolUseId': part.tool_call_id,
+                                            'content': [{'text': part.model_response_str()}],
+                                            'status': 'success',
+                                        }
+                                    }
+                                ],
+                            }
+                        )
+                    elif isinstance(part, RetryPromptPart):
+                        # TODO(Marcelo): We need to add a test here.
+                        if part.tool_name is None:  # pragma: no cover
+                            bedrock_messages.append({'role': 'user', 'content': [{'text': part.model_response()}]})
+                        else:
+                            assert part.tool_call_id is not None
+                            bedrock_messages.append(
+                                {
+                                    'role': 'user',
+                                    'content': [
+                                        {
+                                            'toolResult': {
+                                                'toolUseId': part.tool_call_id,
+                                                'content': [{'text': part.model_response()}],
+                                                'status': 'error',
+                                            }
+                                        }
+                                    ],
+                                }
+                            )
+            elif isinstance(m, ModelResponse):
+                content: list[ContentBlockOutputTypeDef] = []
+                for item in m.parts:
+                    if isinstance(item, TextPart):
+                        content.append({'text': item.content})
+                    else:
+                        assert isinstance(item, ToolCallPart)
+                        content.append(self._map_tool_call(item))  # FIXME: MISSING key
+                bedrock_messages.append({'role': 'assistant', 'content': content})
+            else:
+                assert_never(m)
+        return system_prompt, bedrock_messages
+
+    @staticmethod
+    def _map_tool_call(t: ToolCallPart) -> ContentBlockOutputTypeDef:
+        assert t.tool_call_id is not None
+        return {
+            'toolUse': {
+                'toolUseId': t.tool_call_id,
+                'name': t.tool_name,
+                'input': t.args_as_dict(),
+            }
+        }
+
+
+@dataclass
+class BedrockStreamedResponse(StreamedResponse):
+    """Implementation of `StreamedResponse` for Bedrock models."""
+
+    _model_name: BedrockModelName
+    _event_stream: EventStream[ConverseStreamOutputTypeDef]
+    _timestamp: datetime = field(default_factory=_utils.now_utc)
+
+    async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
+        """Return an async iterator of [`ModelResponseStreamEvent`][pydantic_ai.messages.ModelResponseStreamEvent]s.
+
+        This method should be implemented by subclasses to translate the vendor-specific stream of events into
+        pydantic_ai-format events.
+        """
+        chunk: ConverseStreamOutputTypeDef
+        tool_id: str | None = None
+        async for chunk in _AsyncIteratorWrapper(self._event_stream):
+            # TODO(Marcelo): Switch this to `match` when we drop Python 3.9 support.
+            if 'messageStart' in chunk:
+                continue
+            if 'messageStop' in chunk:
+                continue
+            if 'metadata' in chunk:
+                if 'usage' in chunk['metadata']:
+                    self._usage += self._map_usage(chunk['metadata'])
+                continue
+            if 'contentBlockStart' in chunk:
+                index = chunk['contentBlockStart']['contentBlockIndex']
+                start = chunk['contentBlockStart']['start']
+                if 'toolUse' in start:
+                    tool_use_start = start['toolUse']
+                    tool_id = tool_use_start['toolUseId']
+                    tool_name = tool_use_start['name']
+                    maybe_event = self._parts_manager.handle_tool_call_delta(
+                        vendor_part_id=index,
+                        tool_name=tool_name,
+                        args=None,
+                        tool_call_id=tool_id,
+                    )
+                    if maybe_event:
+                        yield maybe_event
+            if 'contentBlockDelta' in chunk:
+                index = chunk['contentBlockDelta']['contentBlockIndex']
+                delta = chunk['contentBlockDelta']['delta']
+                if 'text' in delta:
+                    yield self._parts_manager.handle_text_delta(vendor_part_id=index, content=delta['text'])
+                if 'toolUse' in delta:
+                    tool_use = delta['toolUse']
+                    maybe_event = self._parts_manager.handle_tool_call_delta(
+                        vendor_part_id=index,
+                        tool_name=tool_use.get('name'),
+                        args=tool_use.get('input'),
+                        tool_call_id=tool_id,
+                    )
+                    if maybe_event:
+                        yield maybe_event
+
+    @property
+    def timestamp(self) -> datetime:
+        return self._timestamp
+
+    @property
+    def model_name(self) -> str:
+        """Get the model name of the response."""
+        return self._model_name
+
+    def _map_usage(self, metadata: ConverseStreamMetadataEventTypeDef) -> result.Usage:
+        return result.Usage(
+            request_tokens=metadata['usage']['inputTokens'],
+            response_tokens=metadata['usage']['outputTokens'],
+            total_tokens=metadata['usage']['totalTokens'],
+        )
+
+
+class _AsyncIteratorWrapper(Generic[T]):
+    """Wrap a synchronous iterator in an async iterator."""
+
+    def __init__(self, sync_iterator: Iterable[T]):
+        self.sync_iterator = iter(sync_iterator)
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self) -> T:
+        try:
+            # Run the synchronous next() call in a thread pool
+            item = await anyio.to_thread.run_sync(next, self.sync_iterator)
+            return item
+        except RuntimeError as e:
+            if type(e.__cause__) is StopIteration:
+                raise StopAsyncIteration
+            else:
+                raise e

pydantic_ai/models/cohere.py

@@ -127,6 +127,11 @@ class CohereModel(Model):
         else:
             self.client = AsyncClientV2(api_key=api_key, httpx_client=http_client)
 
+    @property
+    def base_url(self) -> str:
+        client_wrapper = self.client._client_wrapper  # type: ignore
+        return str(client_wrapper.get_base_url())
+
     async def request(
         self,
         messages: list[ModelMessage],

pydantic_ai/models/fallback.py

@@ -106,6 +106,10 @@ class FallbackModel(Model):
         """The system / model provider, n/a for fallback models."""
         return None
 
+    @property
+    def base_url(self) -> str | None:
+        return self.models[0].base_url
+
 
 def _default_fallback_condition_factory(exceptions: tuple[type[Exception], ...]) -> Callable[[Exception], bool]:
     """Create a default fallback condition for the given exceptions."""

pydantic_ai/models/gemini.py

@@ -143,6 +143,7 @@ class GeminiModel(Model):
             else:
                 self._system = provider.name
                 self.client = provider.client
+            self._url = str(self.client.base_url)
         else:
             if api_key is None:
                 if env_api_key := os.getenv('GEMINI_API_KEY'):
@@ -159,7 +160,7 @@ class GeminiModel(Model):
         return self._auth
 
     @property
-    def url(self) -> str:
+    def base_url(self) -> str:
         assert self._url is not None, 'URL not initialized'
         return self._url
 
@@ -257,7 +258,7 @@ class GeminiModel(Model):
             'User-Agent': get_user_agent(),
         }
         if self._provider is None:  # pragma: no cover
-            url = self.url + ('streamGenerateContent' if streamed else 'generateContent')
+            url = self.base_url + ('streamGenerateContent' if streamed else 'generateContent')
             headers.update(await self.auth.headers())
         else:
             url = f'/{self._model_name}:{"streamGenerateContent" if streamed else "generateContent"}'

pydantic_ai/models/groq.py

@@ -123,6 +123,10 @@ class GroqModel(Model):
         else:
             self.client = AsyncGroq(api_key=api_key, http_client=cached_async_http_client())
 
+    @property
+    def base_url(self) -> str:
+        return str(self.client.base_url)
+
     async def request(
         self,
         messages: list[ModelMessage],

pydantic_ai/models/instrumented.py

@@ -5,6 +5,7 @@ from collections.abc import AsyncIterator, Iterator, Mapping
 from contextlib import asynccontextmanager, contextmanager
 from dataclasses import dataclass, field
 from typing import Any, Callable, Literal
+from urllib.parse import urlparse
 
 from opentelemetry._events import Event, EventLogger, EventLoggerProvider, get_event_logger_provider
 from opentelemetry.trace import Span, Tracer, TracerProvider, get_tracer_provider
@@ -142,8 +143,6 @@ class InstrumentedModel(WrapperModel):
         system = getattr(self.wrapped, 'system', '') or self.wrapped.__class__.__name__.removesuffix('Model').lower()
         system = {'google-gla': 'gemini', 'google-vertex': 'vertex_ai', 'mistral': 'mistral_ai'}.get(system, system)
         # TODO Missing attributes:
-        #  - server.address: requires a Model.base_url abstract method or similar
-        #  - server.port: to parse from the base_url
         #  - error.type: unclear if we should do something here or just always rely on span exceptions
         #  - gen_ai.request.stop_sequences/top_k: model_settings doesn't include these
         attributes: dict[str, AttributeValue] = {
@@ -151,6 +150,15 @@ class InstrumentedModel(WrapperModel):
             'gen_ai.system': system,
             'gen_ai.request.model': model_name,
         }
+        if base_url := self.wrapped.base_url:
+            try:
+                parsed = urlparse(base_url)
+                if parsed.hostname:
+                    attributes['server.address'] = parsed.hostname
+                if parsed.port:
+                    attributes['server.port'] = parsed.port
+            except Exception:  # pragma: no cover
+                pass
 
         if model_settings:
             for key in MODEL_SETTING_ATTRIBUTES:

pydantic_ai/models/mistral.py

@@ -140,6 +140,10 @@ class MistralModel(Model):
             api_key = os.getenv('MISTRAL_API_KEY') if api_key is None else api_key
             self.client = Mistral(api_key=api_key, async_client=http_client or cached_async_http_client())
 
+    @property
+    def base_url(self) -> str:
+        return str(self.client.sdk_configuration.get_server_details()[0])
+
     async def request(
         self,
         messages: list[ModelMessage],

pydantic_ai/models/openai.py

@@ -187,6 +187,10 @@ class OpenAIModel(Model):
         self.system_prompt_role = system_prompt_role
         self._system = system
 
+    @property
+    def base_url(self) -> str:
+        return str(self.client.base_url)
+
     async def request(
         self,
         messages: list[ModelMessage],

pydantic_ai/models/vertexai.py

@@ -224,15 +224,13 @@ class BearerTokenAuth:
 
 
 VertexAiRegion = Literal[
-    'us-central1',
-    'us-east1',
-    'us-east4',
-    'us-south1',
-    'us-west1',
-    'us-west2',
-    'us-west3',
-    'us-west4',
-    'us-east5',
+    'asia-east1',
+    'asia-east2',
+    'asia-northeast1',
+    'asia-northeast3',
+    'asia-south1',
+    'asia-southeast1',
+    'australia-southeast1',
     'europe-central2',
     'europe-north1',
     'europe-southwest1',
@@ -243,27 +241,20 @@ VertexAiRegion = Literal[
     'europe-west6',
     'europe-west8',
     'europe-west9',
-    'europe-west12',
-    'africa-south1',
-    'asia-east1',
-    'asia-east2',
-    'asia-northeast1',
-    'asia-northeast2',
-    'asia-northeast3',
-    'asia-south1',
-    'asia-southeast1',
-    'asia-southeast2',
-    'australia-southeast1',
-    'australia-southeast2',
     'me-central1',
     'me-central2',
     'me-west1',
     'northamerica-northeast1',
-    'northamerica-northeast2',
     'southamerica-east1',
-    'southamerica-west1',
+    'us-central1',
+    'us-east1',
+    'us-east4',
+    'us-east5',
+    'us-south1',
+    'us-west1',
+    'us-west4',
 ]
 """Regions available for Vertex AI.
 
-More details [here](https://cloud.google.com/vertex-ai/docs/reference/rest#rest_endpoints).
+More details [here](https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations#genai-locations).
 """

pydantic_ai/providers/__init__.py

@@ -60,5 +60,10 @@ def infer_provider(provider: str) -> Provider[Any]:
         from .google_gla import GoogleGLAProvider
 
         return GoogleGLAProvider()
+    # NOTE: We don't test because there are many ways the `boto3.client` can retrieve the credentials.
+    elif provider == 'bedrock':  # pragma: no cover
+        from .bedrock import BedrockProvider
+
+        return BedrockProvider()
     else:  # pragma: no cover
         raise ValueError(f'Unknown provider: {provider}')

pydantic_ai/providers/bedrock.py

@@ -0,0 +1,76 @@
+from __future__ import annotations as _annotations
+
+from typing import overload
+
+from pydantic_ai.providers import Provider
+
+try:
+    import boto3
+    from botocore.client import BaseClient
+    from botocore.exceptions import NoRegionError
+except ImportError as _import_error:
+    raise ImportError(
+        'Please install `boto3` to use the Bedrock provider, '
+        "you can use the `bedrock` optional group — `pip install 'pydantic-ai-slim[bedrock]'`"
+    ) from _import_error
+
+
+class BedrockProvider(Provider[BaseClient]):
+    """Provider for AWS Bedrock."""
+
+    @property
+    def name(self) -> str:
+        return 'bedrock'
+
+    @property
+    def base_url(self) -> str:
+        return self._client.meta.endpoint_url
+
+    @property
+    def client(self) -> BaseClient:
+        return self._client
+
+    @overload
+    def __init__(self, *, bedrock_client: BaseClient) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        region_name: str | None = None,
+        aws_access_key_id: str | None = None,
+        aws_secret_access_key: str | None = None,
+        aws_session_token: str | None = None,
+    ) -> None: ...
+
+    def __init__(
+        self,
+        *,
+        bedrock_client: BaseClient | None = None,
+        region_name: str | None = None,
+        aws_access_key_id: str | None = None,
+        aws_secret_access_key: str | None = None,
+        aws_session_token: str | None = None,
+    ) -> None:
+        """Initialize the Bedrock provider.
+
+        Args:
+            bedrock_client: A boto3 client for Bedrock Runtime. If provided, other arguments are ignored.
+            region_name: The AWS region name.
+            aws_access_key_id: The AWS access key ID.
+            aws_secret_access_key: The AWS secret access key.
+            aws_session_token: The AWS session token.
+        """
+        if bedrock_client is not None:
+            self._client = bedrock_client
+        else:
+            try:
+                self._client = boto3.client(  # type: ignore[reportUnknownMemberType]
+                    'bedrock-runtime',
+                    aws_access_key_id=aws_access_key_id,
+                    aws_secret_access_key=aws_secret_access_key,
+                    aws_session_token=aws_session_token,
+                    region_name=region_name,
+                )
+            except NoRegionError as exc:  # pragma: no cover
+                raise ValueError('You must provide a `region_name` or a boto3 client for Bedrock Runtime.') from exc

pydantic_ai/providers/google_vertex.py

@@ -1,10 +1,10 @@
 from __future__ import annotations as _annotations
 
 import functools
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Mapping
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import Literal
+from typing import Literal, overload
 
 import anyio.to_thread
 import httpx
@@ -52,19 +52,45 @@ class GoogleVertexProvider(Provider[httpx.AsyncClient]):
     def client(self) -> httpx.AsyncClient:
         return self._client
 
+    @overload
     def __init__(
         self,
+        *,
         service_account_file: Path | str | None = None,
         project_id: str | None = None,
         region: VertexAiRegion = 'us-central1',
         model_publisher: str = 'google',
         http_client: httpx.AsyncClient | None = None,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        service_account_info: Mapping[str, str] | None = None,
+        project_id: str | None = None,
+        region: VertexAiRegion = 'us-central1',
+        model_publisher: str = 'google',
+        http_client: httpx.AsyncClient | None = None,
+    ) -> None: ...
+
+    def __init__(
+        self,
+        *,
+        service_account_file: Path | str | None = None,
+        service_account_info: Mapping[str, str] | None = None,
+        project_id: str | None = None,
+        region: VertexAiRegion = 'us-central1',
+        model_publisher: str = 'google',
+        http_client: httpx.AsyncClient | None = None,
     ) -> None:
         """Create a new Vertex AI provider.
 
         Args:
             service_account_file: Path to a service account file.
-                If not provided, the default environment credentials will be used.
+                If not provided, the service_account_info or default environment credentials will be used.
+            service_account_info: The loaded service_account_file contents.
+                If not provided, the service_account_file or default environment credentials will be used.
             project_id: The project ID to use, if not provided it will be taken from the credentials.
             region: The region to make requests to.
             model_publisher: The model publisher to use, I couldn't find a good list of available publishers,
@@ -73,13 +99,17 @@ class GoogleVertexProvider(Provider[httpx.AsyncClient]):
                 Please create an issue or PR if you know how to use other publishers.
             http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
         """
+        if service_account_file and service_account_info:
+            raise ValueError('Only one of `service_account_file` or `service_account_info` can be provided.')
+
         self._client = http_client or cached_async_http_client()
         self.service_account_file = service_account_file
+        self.service_account_info = service_account_info
         self.project_id = project_id
         self.region = region
         self.model_publisher = model_publisher
 
-        self._client.auth = _VertexAIAuth(service_account_file, project_id, region)
+        self._client.auth = _VertexAIAuth(service_account_file, service_account_info, project_id, region)
         self._client.base_url = self.base_url
 
 
@@ -91,10 +121,12 @@ class _VertexAIAuth(httpx.Auth):
     def __init__(
         self,
         service_account_file: Path | str | None = None,
+        service_account_info: Mapping[str, str] | None = None,
         project_id: str | None = None,
         region: VertexAiRegion = 'us-central1',
     ) -> None:
         self.service_account_file = service_account_file
+        self.service_account_info = service_account_info
         self.project_id = project_id
         self.region = region
 
@@ -119,6 +151,11 @@ class _VertexAIAuth(httpx.Auth):
             assert creds.project_id is None or isinstance(creds.project_id, str)  # type: ignore[reportUnknownMemberType]
             creds_project_id: str | None = creds.project_id
             creds_source = 'service account file'
+        elif self.service_account_info is not None:
+            creds = await _creds_from_info(self.service_account_info)
+            assert creds.project_id is None or isinstance(creds.project_id, str)  # type: ignore[reportUnknownMemberType]
+            creds_project_id: str | None = creds.project_id
+            creds_source = 'service account info'
         else:
             creds, creds_project_id = await _async_google_auth()
             creds_source = '`google.auth.default()`'
@@ -154,16 +191,22 @@ async def _creds_from_file(service_account_file: str | Path) -> ServiceAccountCr
     return await anyio.to_thread.run_sync(service_account_credentials_from_file, str(service_account_file))
 
 
+async def _creds_from_info(service_account_info: Mapping[str, str]) -> ServiceAccountCredentials:
+    service_account_credentials_from_string = functools.partial(
+        ServiceAccountCredentials.from_service_account_info,  # type: ignore[reportUnknownMemberType]
+        scopes=['https://www.googleapis.com/auth/cloud-platform'],
+    )
+    return await anyio.to_thread.run_sync(service_account_credentials_from_string, service_account_info)
+
+
 VertexAiRegion = Literal[
-    'us-central1',
-    'us-east1',
-    'us-east4',
-    'us-south1',
-    'us-west1',
-    'us-west2',
-    'us-west3',
-    'us-west4',
-    'us-east5',
+    'asia-east1',
+    'asia-east2',
+    'asia-northeast1',
+    'asia-northeast3',
+    'asia-south1',
+    'asia-southeast1',
+    'australia-southeast1',
     'europe-central2',
     'europe-north1',
     'europe-southwest1',
@@ -174,27 +217,20 @@ VertexAiRegion = Literal[
     'europe-west6',
     'europe-west8',
     'europe-west9',
-    'europe-west12',
-    'africa-south1',
-    'asia-east1',
-    'asia-east2',
-    'asia-northeast1',
-    'asia-northeast2',
-    'asia-northeast3',
-    'asia-south1',
-    'asia-southeast1',
-    'asia-southeast2',
-    'australia-southeast1',
-    'australia-southeast2',
     'me-central1',
     'me-central2',
     'me-west1',
     'northamerica-northeast1',
-    'northamerica-northeast2',
     'southamerica-east1',
-    'southamerica-west1',
+    'us-central1',
+    'us-east1',
+    'us-east4',
+    'us-east5',
+    'us-south1',
+    'us-west1',
+    'us-west4',
 ]
 """Regions available for Vertex AI.
 
-More details [here](https://cloud.google.com/vertex-ai/docs/reference/rest#rest_endpoints).
+More details [here](https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations#genai-locations).
 """

pydantic_ai/settings.py

@@ -27,6 +27,7 @@ class ModelSettings(TypedDict, total=False):
     * Groq
     * Cohere
     * Mistral
+    * Bedrock
     """
 
     temperature: float
@@ -45,6 +46,7 @@ class ModelSettings(TypedDict, total=False):
     * Groq
     * Cohere
     * Mistral
+    * Bedrock
     """
 
     top_p: float
@@ -62,6 +64,7 @@ class ModelSettings(TypedDict, total=False):
     * Groq
     * Cohere
     * Mistral
+    * Bedrock
     """
 
     timeout: float | Timeout

{pydantic_ai_slim-0.0.35.dist-info → pydantic_ai_slim-0.0.37.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.35
+Version: 0.0.37
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -29,11 +29,13 @@ 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.0.35
+Requires-Dist: pydantic-graph==0.0.37
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.49.0; extra == 'anthropic'
+Provides-Extra: bedrock
+Requires-Dist: boto3>=1.34.116; extra == 'bedrock'
 Provides-Extra: cli
 Requires-Dist: argcomplete>=3.5.0; extra == 'cli'
 Requires-Dist: prompt-toolkit>=3; extra == 'cli'

pydantic_ai_slim-0.0.37.dist-info/RECORD

@@ -0,0 +1,45 @@
+pydantic_ai/__init__.py,sha256=xrSDxkBwpUVInbPtTVhReEecStk-mWZMttAPUAQR0Ic,927
+pydantic_ai/_agent_graph.py,sha256=wbhm3_5VNpx_Oy1_sQ_6b2hkaFjd9vd1v9g3Rw_8sJY,30127
+pydantic_ai/_cli.py,sha256=vvbRmOO1lj8AgEjJi0-I-05ofKFsj87fibW2EZLt1hU,8605
+pydantic_ai/_griffe.py,sha256=RYRKiLbgG97QxnazbAwlnc74XxevGHLQet-FGfq9qls,3960
+pydantic_ai/_parts_manager.py,sha256=ARfDQY1_5AIY5rNl_M2fAYHEFCe03ZxdhgjHf9qeIKw,11872
+pydantic_ai/_pydantic.py,sha256=v8bqZvfpALiGzjAwhsAz4Pzyqxjr4N1296dsqjDoPGg,8808
+pydantic_ai/_result.py,sha256=SlxqR-AKWzDoc7cRRN2jmIZ7pCv3DKzaP-dnZW-e7us,10117
+pydantic_ai/_system_prompt.py,sha256=602c2jyle2R_SesOrITBDETZqsLk4BZ8Cbo8yEhmx04,1120
+pydantic_ai/_utils.py,sha256=nx4Suswk2qjLvzphx8uQntKzFi-IzvhX_H1L7t_kJlQ,9579
+pydantic_ai/agent.py,sha256=dy8oTMEjc_2EUu8v3dUvhNb5GgbnlQYVm4XK2DKbTZc,67318
+pydantic_ai/exceptions.py,sha256=1ujJeB3jDDQ-pH5ydBYrgStvR35-GlEW0bYGTGEr4ME,3127
+pydantic_ai/format_as_xml.py,sha256=QE7eMlg5-YUMw1_2kcI3h0uKYPZZyGkgXFDtfZTMeeI,4480
+pydantic_ai/messages.py,sha256=oXFWWPllACi6C4K2wMHkHnCP7DVLMWfGkL48SD40oWI,23981
+pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_ai/result.py,sha256=LXKxRzy_rGMkdZ8xJ7yknPP3wGZtGNeZl-gh5opXbaQ,22542
+pydantic_ai/settings.py,sha256=q__Hordc4dypesNxpy_cBT5rFdSiEY-rQt9G6zfyFaM,3101
+pydantic_ai/tools.py,sha256=IPZuZJCSQUppz1uyLVwpfFLGoMirB8YtKWXIDQGR444,13414
+pydantic_ai/usage.py,sha256=VmpU_o_RjFI65J81G1wfCwDIAYBclMjeWfLtslntFOw,5406
+pydantic_ai/common_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_ai/common_tools/duckduckgo.py,sha256=02Ud34xJBwZV0xqYHfPJL7PUfN3odfm9N00j-9p2t0Q,2241
+pydantic_ai/common_tools/tavily.py,sha256=rz3nMIK1aD1kAFP1ZhFSYr4Uy0_uMDJY-JgZxQ1MxsM,2589
+pydantic_ai/models/__init__.py,sha256=kMwX5bLTUXZuA6SUgs2uI7Xlxn3SfkziLq_hUy_8vwI,16262
+pydantic_ai/models/anthropic.py,sha256=4SsM3K4YLk8S4o846jC5_sPpAUNLLBPmojCkmV3m-Wo,20766
+pydantic_ai/models/bedrock.py,sha256=4M_LcIWT9t0p5IzKWG59HXH-8BOM4UigXvpr0tKyVek,18154
+pydantic_ai/models/cohere.py,sha256=re_4dIvAzEbXms1Omvz4SOiBqgXoNBxCfqaFWeHhMZ8,11679
+pydantic_ai/models/fallback.py,sha256=WC-6CFfn5WZY1bxdhkV5zZenW9VftEvBPtWQHyAYtjQ,4299
+pydantic_ai/models/function.py,sha256=THIwVJ8qI3efYLNlYXlYze_J8hc7MHB-NMb3kpknq0g,11373
+pydantic_ai/models/gemini.py,sha256=L6RwBGuVXr9RK6JITdxpe5P0xl58egfiRYW2d1yehFk,35864
+pydantic_ai/models/groq.py,sha256=vDY3fdrY-Uj0e8zQZmee2VGMr1qr1jKBgAupgSKNNLo,16493
+pydantic_ai/models/instrumented.py,sha256=sH5-RiXZ-lVhYgYXXH3F3ui42F4Tc55DP3AErypz32I,9839
+pydantic_ai/models/mistral.py,sha256=kWomL1iWlbH_-UKXCmPMMt7ZPqlZ91oi_8q9Noiwuzc,27568
+pydantic_ai/models/openai.py,sha256=eyg0GUd5pKlXuLHWdoBqvgTvH_oaXpn9ayfAPwz0Rz0,21682
+pydantic_ai/models/test.py,sha256=Ux20cmuJFkhvI9L1N7ItHNFcd-j284TBEsrM53eWRag,16873
+pydantic_ai/models/vertexai.py,sha256=fdzVj7dnrjF4emqtl7bxzdumhljlUN7ZEr-YL7p2A70,9680
+pydantic_ai/models/wrapper.py,sha256=Zr3fgiUBpt2N9gXds6iSwaMEtEsFKr9WwhpHjSoHa7o,1410
+pydantic_ai/providers/__init__.py,sha256=RN2Mm0y-4ZB2U-Aei3oAGh3uALVY4DGB1jYScGoeLDo,2053
+pydantic_ai/providers/bedrock.py,sha256=O2MCKM_zUg1umM633VM8iglraMo0P9tms0MdGqXCmtk,2488
+pydantic_ai/providers/deepseek.py,sha256=KDNvVXjB8cuRTw_xEM1JYLKig9V5YdvGFPm-dcf0kdc,2065
+pydantic_ai/providers/google_gla.py,sha256=sfJXkuGW17nI-P40glnO8DaL_mrpL4uafgoH8xPvcEY,1539
+pydantic_ai/providers/google_vertex.py,sha256=ClXkXg0vrRy1KttAPMmzLPayHTEYTDLKLIY-3DeXdzE,9244
+pydantic_ai/providers/openai.py,sha256=wa6_UXtpOCc_XWuyru3Bf1QH44JGXsM3sIOhUa5Y6qs,2893
+pydantic_ai_slim-0.0.37.dist-info/METADATA,sha256=Hp_5-Dn11hnKTjhXLQdvB9p7MUM7jK8iOf3RzrvwyYg,3343
+pydantic_ai_slim-0.0.37.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-0.0.37.dist-info/entry_points.txt,sha256=KxQSmlMS8GMTkwTsl4_q9a5nJvBjj3HWeXx688wLrKg,45
+pydantic_ai_slim-0.0.37.dist-info/RECORD,,

pydantic_ai_slim-0.0.35.dist-info/RECORD

@@ -1,43 +0,0 @@
-pydantic_ai/__init__.py,sha256=xrSDxkBwpUVInbPtTVhReEecStk-mWZMttAPUAQR0Ic,927
-pydantic_ai/_agent_graph.py,sha256=wbhm3_5VNpx_Oy1_sQ_6b2hkaFjd9vd1v9g3Rw_8sJY,30127
-pydantic_ai/_cli.py,sha256=vvbRmOO1lj8AgEjJi0-I-05ofKFsj87fibW2EZLt1hU,8605
-pydantic_ai/_griffe.py,sha256=RYRKiLbgG97QxnazbAwlnc74XxevGHLQet-FGfq9qls,3960
-pydantic_ai/_parts_manager.py,sha256=ARfDQY1_5AIY5rNl_M2fAYHEFCe03ZxdhgjHf9qeIKw,11872
-pydantic_ai/_pydantic.py,sha256=SxI7HBLzAATlO-_UP4eEuKItkxrkYYToBQMIDdLvwI4,8808
-pydantic_ai/_result.py,sha256=SlxqR-AKWzDoc7cRRN2jmIZ7pCv3DKzaP-dnZW-e7us,10117
-pydantic_ai/_system_prompt.py,sha256=602c2jyle2R_SesOrITBDETZqsLk4BZ8Cbo8yEhmx04,1120
-pydantic_ai/_utils.py,sha256=nx4Suswk2qjLvzphx8uQntKzFi-IzvhX_H1L7t_kJlQ,9579
-pydantic_ai/agent.py,sha256=IMngkZhSuX2X-4HrXWTIm14IZL2R6s73RflwsKkGfOQ,66873
-pydantic_ai/exceptions.py,sha256=1ujJeB3jDDQ-pH5ydBYrgStvR35-GlEW0bYGTGEr4ME,3127
-pydantic_ai/format_as_xml.py,sha256=QE7eMlg5-YUMw1_2kcI3h0uKYPZZyGkgXFDtfZTMeeI,4480
-pydantic_ai/messages.py,sha256=yEYLz27UaiQBgMfzBkHR1I2RtCk5ba9eulNRdUHQxrY,23950
-pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_ai/result.py,sha256=LXKxRzy_rGMkdZ8xJ7yknPP3wGZtGNeZl-gh5opXbaQ,22542
-pydantic_ai/settings.py,sha256=ntuWnke9UA18aByDxk9OIhN0tAgOaPdqCEkRf-wlp8Y,3059
-pydantic_ai/tools.py,sha256=IPZuZJCSQUppz1uyLVwpfFLGoMirB8YtKWXIDQGR444,13414
-pydantic_ai/usage.py,sha256=VmpU_o_RjFI65J81G1wfCwDIAYBclMjeWfLtslntFOw,5406
-pydantic_ai/common_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_ai/common_tools/duckduckgo.py,sha256=-kSa1gGn5-NIYvtxFWrFcX2XdmfEmGxI3_wAqrb6jLI,2230
-pydantic_ai/common_tools/tavily.py,sha256=Lz35037ggkdWKa_Stj0yXBkiN_hygDefEevoRDUclF0,2560
-pydantic_ai/models/__init__.py,sha256=m1TWcmpTKn7hKDqlBNaIt2shUlhFqrVxtFOluhlp0B0,13894
-pydantic_ai/models/anthropic.py,sha256=DxoaSSo-HZYJSqbOAR2p7gsW6kUXY-SV6aA1j-8gy6c,20679
-pydantic_ai/models/cohere.py,sha256=6F6eWPGVT7mpMXlRugbVbR-a8Q1zmb1SKS_fWOoBL80,11514
-pydantic_ai/models/fallback.py,sha256=smHwNIpxu19JsgYYjY0nmzl3yox7yQRJ0Ir08zdhnk0,4207
-pydantic_ai/models/function.py,sha256=THIwVJ8qI3efYLNlYXlYze_J8hc7MHB-NMb3kpknq0g,11373
-pydantic_ai/models/gemini.py,sha256=r7PG7dMruGNmqFRWVFYLmxhICw2oAYfdB9Q1qLoSf8U,35804
-pydantic_ai/models/groq.py,sha256=Z4sZJDu5Yxa2tZiAPp9EjSVMz4uwLhS3fW7kFSc09gI,16406
-pydantic_ai/models/instrumented.py,sha256=TFxY-JFpwH8hkr4pEC8InhI7VjdSTzUFGGi5vgh6Cuc,9567
-pydantic_ai/models/mistral.py,sha256=ZJ4xPcL9wJIQ5io34yP2fPyXy8GZrSvsW4itZiKPYFw,27448
-pydantic_ai/models/openai.py,sha256=NpRFXO-Wc0VVmTY9OHyfl8Qelc_ecxcmRIn6F00CH0Y,21595
-pydantic_ai/models/test.py,sha256=Ux20cmuJFkhvI9L1N7ItHNFcd-j284TBEsrM53eWRag,16873
-pydantic_ai/models/vertexai.py,sha256=KbbLC1wdMqlKTh4Ot07Q4ejy-nfl_ZFI8WAST5j1dBk,9869
-pydantic_ai/models/wrapper.py,sha256=Zr3fgiUBpt2N9gXds6iSwaMEtEsFKr9WwhpHjSoHa7o,1410
-pydantic_ai/providers/__init__.py,sha256=tiH0iwFUjOlYuFQqK2L1coAPgCRlFU_NuLlbJiy_kNg,1819
-pydantic_ai/providers/deepseek.py,sha256=KDNvVXjB8cuRTw_xEM1JYLKig9V5YdvGFPm-dcf0kdc,2065
-pydantic_ai/providers/google_gla.py,sha256=sfJXkuGW17nI-P40glnO8DaL_mrpL4uafgoH8xPvcEY,1539
-pydantic_ai/providers/google_vertex.py,sha256=F2vVukvXeeujgDnbCQnnDQg_3pDFHsyufTGzjJkYvus,7329
-pydantic_ai/providers/openai.py,sha256=wa6_UXtpOCc_XWuyru3Bf1QH44JGXsM3sIOhUa5Y6qs,2893
-pydantic_ai_slim-0.0.35.dist-info/METADATA,sha256=5NOAgrhn6OLK48ch_mJBcARvwEK67ApFm0agVE0DHso,3268
-pydantic_ai_slim-0.0.35.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-0.0.35.dist-info/entry_points.txt,sha256=KxQSmlMS8GMTkwTsl4_q9a5nJvBjj3HWeXx688wLrKg,45
-pydantic_ai_slim-0.0.35.dist-info/RECORD,,