pydantic-ai-slim 0.4.1__tar.gz → 0.4.2__tar.gz

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.4.1
+Version: 0.4.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>
 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.4.1
+Requires-Dist: pydantic-graph==0.4.2
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
-Requires-Dist: fasta2a==0.4.1; 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.4.1; extra == 'evals'
+Requires-Dist: pydantic-evals==0.4.2; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.24.0; extra == 'google'
 Provides-Extra: groq

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/__init__.py

@@ -12,7 +12,7 @@ from .exceptions import (
 )
 from .format_prompt import format_as_xml
 from .messages import AudioUrl, BinaryContent, DocumentUrl, ImageUrl, VideoUrl
-from .output import NativeOutput, PromptedOutput, TextOutput, ToolOutput
+from .output import NativeOutput, PromptedOutput, StructuredDict, TextOutput, ToolOutput
 from .tools import RunContext, Tool
 
 __all__ = (
@@ -46,6 +46,7 @@ __all__ = (
     'NativeOutput',
     'PromptedOutput',
     'TextOutput',
+    'StructuredDict',
     # format_prompt
     'format_as_xml',
 )

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/_a2a.py

@@ -33,10 +33,6 @@ from .agent import Agent, AgentDepsT, OutputDataT
 WorkerOutputT = TypeVar('WorkerOutputT')
 
 try:
-    from starlette.middleware import Middleware
-    from starlette.routing import Route
-    from starlette.types import ExceptionHandler, Lifespan
-
     from fasta2a.applications import FastA2A
     from fasta2a.broker import Broker, InMemoryBroker
     from fasta2a.schema import (
@@ -52,6 +48,9 @@ try:
     )
     from fasta2a.storage import InMemoryStorage, Storage
     from fasta2a.worker import Worker
+    from starlette.middleware import Middleware
+    from starlette.routing import Route
+    from starlette.types import ExceptionHandler, Lifespan
 except ImportError as _import_error:
     raise ImportError(
         'Please install the `fasta2a` package to use `Agent.to_a2a()` method, '

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/_output.py

@@ -264,10 +264,16 @@ class OutputSchema(BaseOutputSchema[OutputDataT], ABC):
 
                 output = output.output
 
+            description = description or default_description
+            if strict is None:
+                strict = default_strict
+
+            processor = ObjectOutputProcessor(output=output, description=description, strict=strict)
+
             if name is None:
                 name = default_name
                 if multiple:
-                    name += f'_{output.__name__}'
+                    name += f'_{processor.object_def.name}'
 
             i = 1
             original_name = name
@@ -275,11 +281,6 @@ class OutputSchema(BaseOutputSchema[OutputDataT], ABC):
                 i += 1
                 name = f'{original_name}_{i}'
 
-            description = description or default_description
-            if strict is None:
-                strict = default_strict
-
-            processor = ObjectOutputProcessor(output=output, description=description, strict=strict)
             tools[name] = OutputTool(name=name, processor=processor, multiple=multiple)
 
         return tools
@@ -616,6 +617,9 @@ class ObjectOutputProcessor(BaseOutputProcessor[OutputDataT]):
                 # including `response_data_typed_dict` as a title here doesn't add anything and could confuse the LLM
                 json_schema.pop('title')
 
+        if name is None and (json_schema_title := json_schema.get('title', None)):
+            name = json_schema_title
+
         if json_schema_description := json_schema.pop('description', None):
             if description is None:
                 description = json_schema_description

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/_utils.py

@@ -60,7 +60,12 @@ def is_model_like(type_: Any) -> bool:
     return (
         isinstance(type_, type)
         and not isinstance(type_, GenericAlias)
-        and (issubclass(type_, BaseModel) or is_dataclass(type_) or is_typeddict(type_))  # pyright: ignore[reportUnknownArgumentType]
+        and (
+            issubclass(type_, BaseModel)
+            or is_dataclass(type_)  # pyright: ignore[reportUnknownArgumentType]
+            or is_typeddict(type_)  # pyright: ignore[reportUnknownArgumentType]
+            or getattr(type_, '__is_model_like__', False)  # pyright: ignore[reportUnknownArgumentType]
+        )
     )
 
 

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/agent.py

@@ -57,14 +57,14 @@ ModelRequestNode = _agent_graph.ModelRequestNode
 UserPromptNode = _agent_graph.UserPromptNode
 
 if TYPE_CHECKING:
-    from starlette.middleware import Middleware
-    from starlette.routing import Route
-    from starlette.types import ExceptionHandler, Lifespan
-
     from fasta2a.applications import FastA2A
     from fasta2a.broker import Broker
     from fasta2a.schema import AgentProvider, Skill
     from fasta2a.storage import Storage
+    from starlette.middleware import Middleware
+    from starlette.routing import Route
+    from starlette.types import ExceptionHandler, Lifespan
+
     from pydantic_ai.mcp import MCPServer
 
 
@@ -500,7 +500,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
     @overload
     def iter(
         self,
-        user_prompt: str | Sequence[_messages.UserContent] | None,
+        user_prompt: str | Sequence[_messages.UserContent] | None = None,
         *,
         output_type: None = None,
         message_history: list[_messages.ModelMessage] | None = None,
@@ -516,7 +516,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
     @overload
     def iter(
         self,
-        user_prompt: str | Sequence[_messages.UserContent] | None,
+        user_prompt: str | Sequence[_messages.UserContent] | None = None,
         *,
         output_type: OutputSpec[RunOutputDataT],
         message_history: list[_messages.ModelMessage] | None = None,
@@ -533,7 +533,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
     @deprecated('`result_type` is deprecated, use `output_type` instead.')
     def iter(
         self,
-        user_prompt: str | Sequence[_messages.UserContent] | None,
+        user_prompt: str | Sequence[_messages.UserContent] | None = None,
         *,
         result_type: type[RunOutputDataT],
         message_history: list[_messages.ModelMessage] | None = None,
@@ -674,12 +674,14 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
         # typecast reasonable, even though it is possible to violate it with otherwise-type-checked code.
         output_validators = cast(list[_output.OutputValidator[AgentDepsT, RunOutputDataT]], self._output_validators)
 
-        model_settings = merge_model_settings(self.model_settings, model_settings)
+        # 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()
 
         if isinstance(model_used, InstrumentedModel):
-            instrumentation_settings = model_used.settings
-            tracer = model_used.settings.tracer
+            instrumentation_settings = model_used.instrumentation_settings
+            tracer = model_used.instrumentation_settings.tracer
         else:
             instrumentation_settings = None
             tracer = NoOpTracer()

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/__init__.py

@@ -321,6 +321,27 @@ class Model(ABC):
     """Abstract class for a model."""
 
     _profile: ModelProfileSpec | None = None
+    _settings: ModelSettings | None = None
+
+    def __init__(
+        self,
+        *,
+        settings: ModelSettings | None = None,
+        profile: ModelProfileSpec | None = None,
+    ) -> None:
+        """Initialize the model with optional settings and profile.
+
+        Args:
+            settings: Model-specific settings that will be used as defaults for this model.
+            profile: The model profile to use.
+        """
+        self._settings = settings
+        self._profile = profile
+
+    @property
+    def settings(self) -> ModelSettings | None:
+        """Get the model settings."""
+        return self._settings
 
     @abstractmethod
     async def request(

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/anthropic.py

@@ -127,6 +127,7 @@ class AnthropicModel(Model):
         *,
         provider: Literal['anthropic'] | Provider[AsyncAnthropic] = 'anthropic',
         profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ):
         """Initialize an Anthropic model.
 
@@ -136,13 +137,15 @@ class AnthropicModel(Model):
             provider: The provider to use for the Anthropic API. Can be either the string 'anthropic' or an
                 instance of `Provider[AsyncAnthropic]`. 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: Default model settings for this model instance.
         """
         self._model_name = model_name
 
         if isinstance(provider, str):
             provider = infer_provider(provider)
         self.client = provider.client
-        self._profile = profile or provider.model_profile
+
+        super().__init__(settings=settings, profile=profile or provider.model_profile)
 
     @property
     def base_url(self) -> str:

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/bedrock.py

@@ -202,6 +202,7 @@ class BedrockConverseModel(Model):
         *,
         provider: Literal['bedrock'] | Provider[BaseClient] = 'bedrock',
         profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ):
         """Initialize a Bedrock model.
 
@@ -213,13 +214,15 @@ class BedrockConverseModel(Model):
                 'bedrock' or an instance of `Provider[BaseClient]`. If not provided, a new provider will be
                 created using the other parameters.
             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
 
         if isinstance(provider, str):
             provider = infer_provider(provider)
         self.client = cast('BedrockRuntimeClient', provider.client)
-        self._profile = profile or provider.model_profile
+
+        super().__init__(settings=settings, profile=profile or provider.model_profile)
 
     def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[ToolTypeDef]:
         tools = [self._map_tool_definition(r) for r in model_request_parameters.function_tools]

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/cohere.py

@@ -111,6 +111,7 @@ class CohereModel(Model):
         *,
         provider: Literal['cohere'] | Provider[AsyncClientV2] = 'cohere',
         profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ):
         """Initialize an Cohere model.
 
@@ -121,13 +122,15 @@ class CohereModel(Model):
                 'cohere' or an instance of `Provider[AsyncClientV2]`. If not provided, a new provider will be
                 created using the other parameters.
             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
 
         if isinstance(provider, str):
             provider = infer_provider(provider)
         self.client = provider.client
-        self._profile = profile or provider.model_profile
+
+        super().__init__(settings=settings, profile=profile or provider.model_profile)
 
     @property
     def base_url(self) -> str:

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/fallback.py

@@ -42,6 +42,7 @@ class FallbackModel(Model):
             fallback_models: The names or instances of the fallback models to use upon failure.
             fallback_on: A callable or tuple of exceptions that should trigger a fallback.
         """
+        super().__init__()
         self.models = [infer_model(default_model), *[infer_model(m) for m in fallback_models]]
 
         if isinstance(fallback_on, tuple):

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/function.py

@@ -52,7 +52,12 @@ class FunctionModel(Model):
 
     @overload
     def __init__(
-        self, function: FunctionDef, *, model_name: str | None = None, profile: ModelProfileSpec | None = None
+        self,
+        function: FunctionDef,
+        *,
+        model_name: str | None = None,
+        profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ) -> None: ...
 
     @overload
@@ -62,6 +67,7 @@ class FunctionModel(Model):
         stream_function: StreamFunctionDef,
         model_name: str | None = None,
         profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ) -> None: ...
 
     @overload
@@ -72,6 +78,7 @@ class FunctionModel(Model):
         stream_function: StreamFunctionDef,
         model_name: str | None = None,
         profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ) -> None: ...
 
     def __init__(
@@ -81,6 +88,7 @@ class FunctionModel(Model):
         stream_function: StreamFunctionDef | None = None,
         model_name: str | None = None,
         profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ):
         """Initialize a `FunctionModel`.
 
@@ -91,16 +99,19 @@ class FunctionModel(Model):
             stream_function: The function to call for streamed requests.
             model_name: The name of the model. If not provided, a name is generated from the function names.
             profile: The model profile to use.
+            settings: Model-specific settings that will be used as defaults for this model.
         """
         if function is None and stream_function is None:
             raise TypeError('Either `function` or `stream_function` must be provided')
+
         self.function = function
         self.stream_function = stream_function
 
         function_name = self.function.__name__ if self.function is not None else ''
         stream_function_name = self.stream_function.__name__ if self.stream_function is not None else ''
         self._model_name = model_name or f'function:{function_name}:{stream_function_name}'
-        self._profile = profile
+
+        super().__init__(settings=settings, profile=profile)
 
     async def request(
         self,

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/gemini.py

@@ -133,6 +133,7 @@ class GeminiModel(Model):
         *,
         provider: Literal['google-gla', 'google-vertex'] | Provider[httpx.AsyncClient] = 'google-gla',
         profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ):
         """Initialize a Gemini model.
 
@@ -142,6 +143,7 @@ class GeminiModel(Model):
                 'google-gla' or 'google-vertex' or an instance of `Provider[httpx.AsyncClient]`.
                 If not provided, a new provider will be created using the other parameters.
             profile: The model profile to use. Defaults to a profile picked by the provider based on the model name.
+            settings: Default model settings for this model instance.
         """
         self._model_name = model_name
         self._provider = provider
@@ -151,7 +153,8 @@ class GeminiModel(Model):
         self._system = provider.name
         self.client = provider.client
         self._url = str(self.client.base_url)
-        self._profile = profile or provider.model_profile
+
+        super().__init__(settings=settings, profile=profile or provider.model_profile)
 
     @property
     def base_url(self) -> str:
@@ -921,10 +924,10 @@ def _ensure_decodeable(content: bytearray) -> bytearray:
 
     This is a temporary workaround until https://github.com/pydantic/pydantic-core/issues/1633 is resolved
     """
-    while True:
-        try:
-            content.decode()
-        except UnicodeDecodeError:
-            content = content[:-1]  # this will definitely succeed before we run out of bytes
-        else:
-            return content
+    try:
+        content.decode()
+    except UnicodeDecodeError as e:
+        # e.start marks the start of the invalid decoded bytes, so cut up to before the first invalid byte
+        return content[: e.start]
+    else:
+        return content

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/google.py

@@ -151,6 +151,7 @@ class GoogleModel(Model):
         *,
         provider: Literal['google-gla', 'google-vertex'] | Provider[genai.Client] = 'google-gla',
         profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ):
         """Initialize a Gemini model.
 
@@ -160,6 +161,7 @@ class GoogleModel(Model):
                 'google-gla' or 'google-vertex' or an instance of `Provider[httpx.AsyncClient]`.
                 If not provided, a new provider will be created using the other parameters.
             profile: The model profile to use. Defaults to a profile picked by the provider based on the model name.
+            settings: The model settings to use. Defaults to None.
         """
         self._model_name = model_name
 
@@ -169,7 +171,8 @@ class GoogleModel(Model):
         self._provider = provider
         self._system = provider.name
         self.client = provider.client
-        self._profile = profile or provider.model_profile
+
+        super().__init__(settings=settings, profile=profile or provider.model_profile)
 
     @property
     def base_url(self) -> str:

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/groq.py

@@ -120,6 +120,7 @@ class GroqModel(Model):
         *,
         provider: Literal['groq'] | Provider[AsyncGroq] = 'groq',
         profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ):
         """Initialize a Groq model.
 
@@ -130,13 +131,15 @@ class GroqModel(Model):
                 'groq' or an instance of `Provider[AsyncGroq]`. If not provided, a new provider will be
                 created using the other parameters.
             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
 
         if isinstance(provider, str):
             provider = infer_provider(provider)
         self.client = provider.client
-        self._profile = profile or provider.model_profile
+
+        super().__init__(settings=settings, profile=profile or provider.model_profile)
 
     @property
     def base_url(self) -> str:

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/instrumented.py

@@ -182,15 +182,15 @@ GEN_AI_SYSTEM_ATTRIBUTE = 'gen_ai.system'
 GEN_AI_REQUEST_MODEL_ATTRIBUTE = 'gen_ai.request.model'
 
 
-@dataclass
+@dataclass(init=False)
 class InstrumentedModel(WrapperModel):
     """Model which wraps another model so that requests are instrumented with OpenTelemetry.
 
     See the [Debugging and Monitoring guide](https://ai.pydantic.dev/logfire/) for more info.
     """
 
-    settings: InstrumentationSettings
-    """Configuration for instrumenting requests."""
+    instrumentation_settings: InstrumentationSettings
+    """Instrumentation settings for this model."""
 
     def __init__(
         self,
@@ -198,7 +198,7 @@ class InstrumentedModel(WrapperModel):
         options: InstrumentationSettings | None = None,
     ) -> None:
         super().__init__(wrapped)
-        self.settings = options or InstrumentationSettings()
+        self.instrumentation_settings = options or InstrumentationSettings()
 
     async def request(
         self,
@@ -260,7 +260,7 @@ class InstrumentedModel(WrapperModel):
 
         record_metrics: Callable[[], None] | None = None
         try:
-            with self.settings.tracer.start_as_current_span(span_name, attributes=attributes) as span:
+            with self.instrumentation_settings.tracer.start_as_current_span(span_name, attributes=attributes) as span:
 
                 def finish(response: ModelResponse):
                     # FallbackModel updates these span attributes.
@@ -278,12 +278,12 @@ class InstrumentedModel(WrapperModel):
                             'gen_ai.response.model': response_model,
                         }
                         if response.usage.request_tokens:  # pragma: no branch
-                            self.settings.tokens_histogram.record(
+                            self.instrumentation_settings.tokens_histogram.record(
                                 response.usage.request_tokens,
                                 {**metric_attributes, 'gen_ai.token.type': 'input'},
                             )
                         if response.usage.response_tokens:  # pragma: no branch
-                            self.settings.tokens_histogram.record(
+                            self.instrumentation_settings.tokens_histogram.record(
                                 response.usage.response_tokens,
                                 {**metric_attributes, 'gen_ai.token.type': 'output'},
                             )
@@ -294,8 +294,8 @@ class InstrumentedModel(WrapperModel):
                     if not span.is_recording():
                         return
 
-                    events = self.settings.messages_to_otel_events(messages)
-                    for event in self.settings.messages_to_otel_events([response]):
+                    events = self.instrumentation_settings.messages_to_otel_events(messages)
+                    for event in self.instrumentation_settings.messages_to_otel_events([response]):
                         events.append(
                             Event(
                                 'gen_ai.choice',
@@ -328,9 +328,9 @@ class InstrumentedModel(WrapperModel):
                 record_metrics()
 
     def _emit_events(self, span: Span, events: list[Event]) -> None:
-        if self.settings.event_mode == 'logs':
+        if self.instrumentation_settings.event_mode == 'logs':
             for event in events:
-                self.settings.event_logger.emit(event)
+                self.instrumentation_settings.event_logger.emit(event)
         else:
             attr_name = 'events'
             span.set_attributes(

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/mistral.py

@@ -125,6 +125,7 @@ class MistralModel(Model):
         provider: Literal['mistral'] | Provider[Mistral] = 'mistral',
         profile: ModelProfileSpec | None = None,
         json_mode_schema_prompt: str = """Answer in JSON Object, respect the format:\n```\n{schema}\n```\n""",
+        settings: ModelSettings | None = None,
     ):
         """Initialize a Mistral model.
 
@@ -135,6 +136,7 @@ class MistralModel(Model):
                 created using the other parameters.
             profile: The model profile to use. Defaults to a profile picked by the provider based on the model name.
             json_mode_schema_prompt: The prompt to show when the model expects a JSON object as input.
+            settings: Model-specific settings that will be used as defaults for this model.
         """
         self._model_name = model_name
         self.json_mode_schema_prompt = json_mode_schema_prompt
@@ -142,7 +144,8 @@ class MistralModel(Model):
         if isinstance(provider, str):
             provider = infer_provider(provider)
         self.client = provider.client
-        self._profile = profile or provider.model_profile
+
+        super().__init__(settings=settings, profile=profile or provider.model_profile)
 
     @property
     def base_url(self) -> str:

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/openai.py

@@ -195,6 +195,7 @@ class OpenAIModel(Model):
         | Provider[AsyncOpenAI] = 'openai',
         profile: ModelProfileSpec | None = None,
         system_prompt_role: OpenAISystemPromptRole | None = None,
+        settings: ModelSettings | None = None,
     ):
         """Initialize an OpenAI model.
 
@@ -206,16 +207,18 @@ class OpenAIModel(Model):
             profile: The model profile to use. Defaults to a profile picked by the provider based on the model name.
             system_prompt_role: The role to use for the system prompt message. If not provided, defaults to `'system'`.
                 In the future, this may be inferred from the model name.
+            settings: Default model settings for this model instance.
         """
         self._model_name = model_name
 
         if isinstance(provider, str):
             provider = infer_provider(provider)
         self.client = provider.client
-        self._profile = profile or provider.model_profile
 
         self.system_prompt_role = system_prompt_role
 
+        super().__init__(settings=settings, profile=profile or provider.model_profile)
+
     @property
     def base_url(self) -> str:
         return str(self.client.base_url)
@@ -598,6 +601,7 @@ class OpenAIResponsesModel(Model):
         provider: Literal['openai', 'deepseek', 'azure', 'openrouter', 'grok', 'fireworks', 'together']
         | Provider[AsyncOpenAI] = 'openai',
         profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ):
         """Initialize an OpenAI Responses model.
 
@@ -605,13 +609,15 @@ class OpenAIResponsesModel(Model):
             model_name: The name of the OpenAI model to use.
             provider: The provider to use. Defaults to `'openai'`.
             profile: The model profile to use. Defaults to a profile picked by the provider based on the model name.
+            settings: Default model settings for this model instance.
         """
         self._model_name = model_name
 
         if isinstance(provider, str):
             provider = infer_provider(provider)
         self.client = provider.client
-        self._profile = profile or provider.model_profile
+
+        super().__init__(settings=settings, profile=profile or provider.model_profile)
 
     @property
     def model_name(self) -> OpenAIModelName:
@@ -988,6 +994,12 @@ class OpenAIStreamedResponse(StreamedResponse):
             if content is not None:
                 yield self._parts_manager.handle_text_delta(vendor_part_id='content', content=content)
 
+            # Handle reasoning part of the response, present in DeepSeek models
+            if reasoning_content := getattr(choice.delta, 'reasoning_content', None):
+                yield self._parts_manager.handle_thinking_delta(
+                    vendor_part_id='reasoning_content', content=reasoning_content
+                )
+
             for dtc in choice.delta.tool_calls or []:
                 maybe_event = self._parts_manager.handle_tool_call_delta(
                     vendor_part_id=dtc.index,

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/test.py

@@ -24,6 +24,7 @@ from ..messages import (
     ToolCallPart,
     ToolReturnPart,
 )
+from ..profiles import ModelProfileSpec
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
 from ..usage import Usage
@@ -45,7 +46,7 @@ class _WrappedToolOutput:
     value: Any | None
 
 
-@dataclass
+@dataclass(init=False)
 class TestModel(Model):
     """A model specifically for testing purposes.
 
@@ -79,6 +80,26 @@ class TestModel(Model):
     _model_name: str = field(default='test', repr=False)
     _system: str = field(default='test', repr=False)
 
+    def __init__(
+        self,
+        *,
+        call_tools: list[str] | Literal['all'] = 'all',
+        custom_output_text: str | None = None,
+        custom_output_args: Any | None = None,
+        seed: int = 0,
+        profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
+    ):
+        """Initialize TestModel with optional settings and profile."""
+        self.call_tools = call_tools
+        self.custom_output_text = custom_output_text
+        self.custom_output_args = custom_output_args
+        self.seed = seed
+        self.last_model_request_parameters = None
+        self._model_name = 'test'
+        self._system = 'test'
+        super().__init__(settings=settings, profile=profile)
+
     async def request(
         self,
         messages: list[ModelMessage],

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/wrapper.py

@@ -23,6 +23,7 @@ class WrapperModel(Model):
     """The underlying model being wrapped."""
 
     def __init__(self, wrapped: Model | KnownModelName):
+        super().__init__()
         self.wrapped = infer_model(wrapped)
 
     async def request(self, *args: Any, **kwargs: Any) -> ModelResponse:
@@ -53,5 +54,10 @@ class WrapperModel(Model):
     def profile(self) -> ModelProfile:
         return self.wrapped.profile
 
+    @property
+    def settings(self) -> ModelSettings | None:
+        """Get the settings from the wrapped model."""
+        return self.wrapped.settings
+
     def __getattr__(self, item: str):
         return getattr(self.wrapped, item)  # pragma: no cover

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pydantic_ai/output.py

@@ -2,10 +2,14 @@ from __future__ import annotations
 
 from collections.abc import Awaitable, Sequence
 from dataclasses import dataclass
-from typing import Callable, Generic, Literal, Union
+from typing import Any, Callable, Generic, Literal, Union
 
+from pydantic import GetCoreSchemaHandler, GetJsonSchemaHandler
+from pydantic.json_schema import JsonSchemaValue
+from pydantic_core import core_schema
 from typing_extensions import TypeAliasType, TypeVar
 
+from . import _utils
 from .tools import RunContext
 
 __all__ = (
@@ -14,6 +18,7 @@ __all__ = (
     'NativeOutput',
     'PromptedOutput',
     'TextOutput',
+    'StructuredDict',
     # types
     'OutputDataT',
     'OutputMode',
@@ -266,6 +271,65 @@ class TextOutput(Generic[OutputDataT]):
     """The function that will be called to process the model's plain text output. The function must take a single string argument."""
 
 
+def StructuredDict(
+    json_schema: JsonSchemaValue, name: str | None = None, description: str | None = None
+) -> type[JsonSchemaValue]:
+    """Returns a `dict[str, Any]` subclass with a JSON schema attached that will be used for structured output.
+
+    Args:
+        json_schema: A JSON schema of type `object` defining the structure of the dictionary content.
+        name: Optional name of the structured output. If not provided, the `title` field of the JSON schema will be used if it's present.
+        description: Optional description of the structured output. If not provided, the `description` field of the JSON schema will be used if it's present.
+
+    Example:
+    ```python {title="structured_dict.py"}
+    from pydantic_ai import Agent, StructuredDict
+
+
+    schema = {
+        "type": "object",
+        "properties": {
+            "name": {"type": "string"},
+            "age": {"type": "integer"}
+        },
+        "required": ["name", "age"]
+    }
+
+    agent = Agent('openai:gpt-4o', output_type=StructuredDict(schema))
+    result = agent.run_sync("Create a person")
+    print(result.output)
+    #> {'name': 'John Doe', 'age': 30}
+    ```
+    """
+    json_schema = _utils.check_object_json_schema(json_schema)
+
+    if name:
+        json_schema['title'] = name
+
+    if description:
+        json_schema['description'] = description
+
+    class _StructuredDict(JsonSchemaValue):
+        __is_model_like__ = True
+
+        @classmethod
+        def __get_pydantic_core_schema__(
+            cls, source_type: Any, handler: GetCoreSchemaHandler
+        ) -> core_schema.CoreSchema:
+            return core_schema.dict_schema(
+                keys_schema=core_schema.str_schema(),
+                values_schema=core_schema.any_schema(),
+            )
+
+        @classmethod
+        def __get_pydantic_json_schema__(
+            cls, core_schema: core_schema.CoreSchema, handler: GetJsonSchemaHandler
+        ) -> JsonSchemaValue:
+            return json_schema
+
+    return _StructuredDict
+
+
 OutputSpec = TypeAliasType(
     'OutputSpec',
     Union[

{pydantic_ai_slim-0.4.1 → pydantic_ai_slim-0.4.2}/pyproject.toml

@@ -79,7 +79,7 @@ mcp = ["mcp>=1.9.4; python_version >= '3.10'"]
 # Evals
 evals = ["pydantic-evals=={{ version }}"]
 # A2A
-a2a = ["fasta2a=={{ version }}"]
+a2a = ["fasta2a>=0.4.1"]
 
 [dependency-groups]
 dev = [