pydantic-ai-slim 0.8.0__tar.gz → 0.8.1__tar.gz

{pydantic_ai_slim-0.8.0 → pydantic_ai_slim-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.8.0
+Version: 0.8.1
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Project-URL: Homepage, https://github.com/pydantic/pydantic-ai/tree/main/pydantic_ai_slim
 Project-URL: Source, https://github.com/pydantic/pydantic-ai/tree/main/pydantic_ai_slim
@@ -35,7 +35,7 @@ Requires-Dist: genai-prices>=0.0.22
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==0.8.0
+Requires-Dist: pydantic-graph==0.8.1
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
@@ -57,7 +57,7 @@ Requires-Dist: cohere>=5.16.0; (platform_system != 'Emscripten') and extra == 'c
 Provides-Extra: duckduckgo
 Requires-Dist: ddgs>=9.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==0.8.0; extra == 'evals'
+Requires-Dist: pydantic-evals==0.8.1; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.31.0; extra == 'google'
 Provides-Extra: groq
@@ -77,7 +77,7 @@ Requires-Dist: tenacity>=8.2.3; extra == 'retries'
 Provides-Extra: tavily
 Requires-Dist: tavily-python>=0.5.0; extra == 'tavily'
 Provides-Extra: temporal
-Requires-Dist: temporalio==1.15.0; extra == 'temporal'
+Requires-Dist: temporalio==1.16.0; extra == 'temporal'
 Provides-Extra: vertexai
 Requires-Dist: google-auth>=2.36.0; extra == 'vertexai'
 Requires-Dist: requests>=2.32.2; extra == 'vertexai'

{pydantic_ai_slim-0.8.0 → pydantic_ai_slim-0.8.1}/pydantic_ai/agent/__init__.py

@@ -678,22 +678,28 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
         self, state: _agent_graph.GraphAgentState, usage: _usage.RunUsage, settings: InstrumentationSettings
     ):
         if settings.version == 1:
-            attr_name = 'all_messages_events'
-            value = [
-                InstrumentedModel.event_to_dict(e) for e in settings.messages_to_otel_events(state.message_history)
-            ]
+            attrs = {
+                'all_messages_events': json.dumps(
+                    [
+                        InstrumentedModel.event_to_dict(e)
+                        for e in settings.messages_to_otel_events(state.message_history)
+                    ]
+                )
+            }
         else:
-            attr_name = 'pydantic_ai.all_messages'
-            value = settings.messages_to_otel_messages(state.message_history)
+            attrs = {
+                'pydantic_ai.all_messages': json.dumps(settings.messages_to_otel_messages(state.message_history)),
+                **settings.system_instructions_attributes(self._instructions),
+            }
 
         return {
             **usage.opentelemetry_attributes(),
-            attr_name: json.dumps(value),
+            **attrs,
             'logfire.json_schema': json.dumps(
                 {
                     'type': 'object',
                     'properties': {
-                        attr_name: {'type': 'array'},
+                        **{attr: {'type': 'array'} for attr in attrs.keys()},
                         'final_result': {'type': 'object'},
                     },
                 }

{pydantic_ai_slim-0.8.0 → pydantic_ai_slim-0.8.1}/pydantic_ai/durable_exec/temporal/__init__.py

@@ -1,15 +1,24 @@
 from __future__ import annotations
 
 import warnings
-from collections.abc import Sequence
+from collections.abc import AsyncIterator, Sequence
+from contextlib import AbstractAsyncContextManager
 from dataclasses import replace
 from typing import Any, Callable
 
 from pydantic.errors import PydanticUserError
-from temporalio.client import ClientConfig, Plugin as ClientPlugin
+from temporalio.client import ClientConfig, Plugin as ClientPlugin, WorkflowHistory
 from temporalio.contrib.pydantic import PydanticPayloadConverter, pydantic_data_converter
-from temporalio.converter import DefaultPayloadConverter
-from temporalio.worker import Plugin as WorkerPlugin, WorkerConfig
+from temporalio.converter import DataConverter, DefaultPayloadConverter
+from temporalio.service import ConnectConfig, ServiceClient
+from temporalio.worker import (
+    Plugin as WorkerPlugin,
+    Replayer,
+    ReplayerConfig,
+    Worker,
+    WorkerConfig,
+    WorkflowReplayResult,
+)
 from temporalio.worker.workflow_sandbox import SandboxedWorkflowRunner
 
 from ...exceptions import UserError
@@ -31,17 +40,15 @@ __all__ = [
 class PydanticAIPlugin(ClientPlugin, WorkerPlugin):
     """Temporal client and worker plugin for Pydantic AI."""
 
-    def configure_client(self, config: ClientConfig) -> ClientConfig:
-        if (data_converter := config.get('data_converter')) and data_converter.payload_converter_class not in (
-            DefaultPayloadConverter,
-            PydanticPayloadConverter,
-        ):
-            warnings.warn(  # pragma: no cover
-                'A non-default Temporal data converter was used which has been replaced with the Pydantic data converter.'
-            )
+    def init_client_plugin(self, next: ClientPlugin) -> None:
+        self.next_client_plugin = next
 
-        config['data_converter'] = pydantic_data_converter
-        return super().configure_client(config)
+    def init_worker_plugin(self, next: WorkerPlugin) -> None:
+        self.next_worker_plugin = next
+
+    def configure_client(self, config: ClientConfig) -> ClientConfig:
+        config['data_converter'] = self._get_new_data_converter(config.get('data_converter'))
+        return self.next_client_plugin.configure_client(config)
 
     def configure_worker(self, config: WorkerConfig) -> WorkerConfig:
         runner = config.get('workflow_runner')  # pyright: ignore[reportUnknownMemberType]
@@ -67,7 +74,35 @@ class PydanticAIPlugin(ClientPlugin, WorkerPlugin):
             PydanticUserError,
         ]
 
-        return super().configure_worker(config)
+        return self.next_worker_plugin.configure_worker(config)
+
+    async def connect_service_client(self, config: ConnectConfig) -> ServiceClient:
+        return await self.next_client_plugin.connect_service_client(config)
+
+    async def run_worker(self, worker: Worker) -> None:
+        await self.next_worker_plugin.run_worker(worker)
+
+    def configure_replayer(self, config: ReplayerConfig) -> ReplayerConfig:  # pragma: no cover
+        config['data_converter'] = self._get_new_data_converter(config.get('data_converter'))  # pyright: ignore[reportUnknownMemberType]
+        return self.next_worker_plugin.configure_replayer(config)
+
+    def run_replayer(
+        self,
+        replayer: Replayer,
+        histories: AsyncIterator[WorkflowHistory],
+    ) -> AbstractAsyncContextManager[AsyncIterator[WorkflowReplayResult]]:  # pragma: no cover
+        return self.next_worker_plugin.run_replayer(replayer, histories)
+
+    def _get_new_data_converter(self, converter: DataConverter | None) -> DataConverter:
+        if converter and converter.payload_converter_class not in (
+            DefaultPayloadConverter,
+            PydanticPayloadConverter,
+        ):
+            warnings.warn(  # pragma: no cover
+                'A non-default Temporal data converter was used which has been replaced with the Pydantic data converter.'
+            )
+
+        return pydantic_data_converter
 
 
 class AgentPlugin(WorkerPlugin):
@@ -76,8 +111,24 @@ class AgentPlugin(WorkerPlugin):
     def __init__(self, agent: TemporalAgent[Any, Any]):
         self.agent = agent
 
+    def init_worker_plugin(self, next: WorkerPlugin) -> None:
+        self.next_worker_plugin = next
+
     def configure_worker(self, config: WorkerConfig) -> WorkerConfig:
         activities: Sequence[Callable[..., Any]] = config.get('activities', [])  # pyright: ignore[reportUnknownMemberType]
         # Activities are checked for name conflicts by Temporal.
         config['activities'] = [*activities, *self.agent.temporal_activities]
-        return super().configure_worker(config)
+        return self.next_worker_plugin.configure_worker(config)
+
+    async def run_worker(self, worker: Worker) -> None:
+        await self.next_worker_plugin.run_worker(worker)
+
+    def configure_replayer(self, config: ReplayerConfig) -> ReplayerConfig:  # pragma: no cover
+        return self.next_worker_plugin.configure_replayer(config)
+
+    def run_replayer(
+        self,
+        replayer: Replayer,
+        histories: AsyncIterator[WorkflowHistory],
+    ) -> AbstractAsyncContextManager[AsyncIterator[WorkflowReplayResult]]:  # pragma: no cover
+        return self.next_worker_plugin.run_replayer(replayer, histories)

{pydantic_ai_slim-0.8.0 → pydantic_ai_slim-0.8.1}/pydantic_ai/durable_exec/temporal/_logfire.py

@@ -25,10 +25,13 @@ class LogfirePlugin(ClientPlugin):
         self.setup_logfire = setup_logfire
         self.metrics = metrics
 
+    def init_client_plugin(self, next: ClientPlugin) -> None:
+        self.next_client_plugin = next
+
     def configure_client(self, config: ClientConfig) -> ClientConfig:
         interceptors = config.get('interceptors', [])
         config['interceptors'] = [*interceptors, TracingInterceptor(get_tracer('temporalio'))]
-        return super().configure_client(config)
+        return self.next_client_plugin.configure_client(config)
 
     async def connect_service_client(self, config: ConnectConfig) -> ServiceClient:
         logfire = self.setup_logfire()
@@ -45,4 +48,4 @@ class LogfirePlugin(ClientPlugin):
                     telemetry=TelemetryConfig(metrics=OpenTelemetryConfig(url=metrics_url, headers=headers))
                 )
 
-        return await super().connect_service_client(config)
+        return await self.next_client_plugin.connect_service_client(config)

{pydantic_ai_slim-0.8.0 → pydantic_ai_slim-0.8.1}/pydantic_ai/messages.py

@@ -938,7 +938,7 @@ class ModelResponse:
     For OpenAI models, this may include 'logprobs', 'finish_reason', etc.
     """
 
-    provider_request_id: str | None = None
+    provider_response_id: str | None = None
     """request ID as specified by the model provider. This can be used to track the specific request to the model."""
 
     def price(self) -> genai_types.PriceCalculation:
@@ -1026,9 +1026,14 @@ class ModelResponse:
         return self.provider_details
 
     @property
-    @deprecated('`vendor_id` is deprecated, use `provider_request_id` instead')
+    @deprecated('`vendor_id` is deprecated, use `provider_response_id` instead')
     def vendor_id(self) -> str | None:
-        return self.provider_request_id
+        return self.provider_response_id
+
+    @property
+    @deprecated('`provider_request_id` is deprecated, use `provider_response_id` instead')
+    def provider_request_id(self) -> str | None:
+        return self.provider_response_id
 
     __repr__ = _utils.dataclasses_no_defaults_repr
 

{pydantic_ai_slim-0.8.0 → pydantic_ai_slim-0.8.1}/pydantic_ai/models/__init__.py

@@ -7,6 +7,7 @@ specific LLM being used.
 from __future__ import annotations as _annotations
 
 import base64
+import warnings
 from abc import ABC, abstractmethod
 from collections.abc import AsyncIterator, Iterator
 from contextlib import asynccontextmanager, contextmanager
@@ -684,19 +685,29 @@ def infer_model(model: Model | KnownModelName | str) -> Model:  # noqa: C901
     try:
         provider, model_name = model.split(':', maxsplit=1)
     except ValueError:
+        provider = None
         model_name = model
-        # TODO(Marcelo): We should deprecate this way.
         if model_name.startswith(('gpt', 'o1', 'o3')):
             provider = 'openai'
         elif model_name.startswith('claude'):
             provider = 'anthropic'
         elif model_name.startswith('gemini'):
             provider = 'google-gla'
+
+        if provider is not None:
+            warnings.warn(
+                f"Specifying a model name without a provider prefix is deprecated. Instead of {model_name!r}, use '{provider}:{model_name}'.",
+                DeprecationWarning,
+            )
         else:
             raise UserError(f'Unknown model: {model}')
 
-    if provider == 'vertexai':
-        provider = 'google-vertex'  # pragma: no cover
+    if provider == 'vertexai':  # pragma: no cover
+        warnings.warn(
+            "The 'vertexai' provider name is deprecated. Use 'google-vertex' instead.",
+            DeprecationWarning,
+        )
+        provider = 'google-vertex'
 
     if provider == 'cohere':
         from .cohere import CohereModel

{pydantic_ai_slim-0.8.0 → pydantic_ai_slim-0.8.1}/pydantic_ai/models/anthropic.py

@@ -330,7 +330,7 @@ class AnthropicModel(Model):
             items,
             usage=_map_usage(response),
             model_name=response.model,
-            provider_request_id=response.id,
+            provider_response_id=response.id,
             provider_name=self._provider.name,
         )
 

{pydantic_ai_slim-0.8.0 → pydantic_ai_slim-0.8.1}/pydantic_ai/models/bedrock.py

@@ -301,9 +301,13 @@ class BedrockConverseModel(Model):
             input_tokens=response['usage']['inputTokens'],
             output_tokens=response['usage']['outputTokens'],
         )
-        vendor_id = response.get('ResponseMetadata', {}).get('RequestId', None)
+        response_id = response.get('ResponseMetadata', {}).get('RequestId', None)
         return ModelResponse(
-            items, usage=u, model_name=self.model_name, provider_request_id=vendor_id, provider_name=self._provider.name
+            items,
+            usage=u,
+            model_name=self.model_name,
+            provider_response_id=response_id,
+            provider_name=self._provider.name,
         )
 
     @overload

{pydantic_ai_slim-0.8.0 → pydantic_ai_slim-0.8.1}/pydantic_ai/models/gemini.py

@@ -690,7 +690,7 @@ def _process_response_from_parts(
                 f'Unsupported response from Gemini, expected all parts to be function calls or text, got: {part!r}'
             )
     return ModelResponse(
-        parts=items, usage=usage, model_name=model_name, provider_request_id=vendor_id, provider_details=vendor_details
+        parts=items, usage=usage, model_name=model_name, provider_response_id=vendor_id, provider_details=vendor_details
     )
 
 

{pydantic_ai_slim-0.8.0 → pydantic_ai_slim-0.8.1}/pydantic_ai/models/google.py

@@ -648,7 +648,7 @@ def _process_response_from_parts(
         parts=items,
         model_name=model_name,
         usage=usage,
-        provider_request_id=vendor_id,
+        provider_response_id=vendor_id,
         provider_details=vendor_details,
         provider_name=provider_name,
     )

{pydantic_ai_slim-0.8.0 → pydantic_ai_slim-0.8.1}/pydantic_ai/models/groq.py

@@ -289,7 +289,7 @@ class GroqModel(Model):
             usage=_map_usage(response),
             model_name=response.model,
             timestamp=timestamp,
-            provider_request_id=response.id,
+            provider_response_id=response.id,
             provider_name=self._provider.name,
         )
 

{pydantic_ai_slim-0.8.0 → pydantic_ai_slim-0.8.1}/pydantic_ai/models/huggingface.py

@@ -271,7 +271,7 @@ class HuggingFaceModel(Model):
             usage=_map_usage(response),
             model_name=response.model,
             timestamp=timestamp,
-            provider_request_id=response.id,
+            provider_response_id=response.id,
             provider_name=self._provider.name,
         )
 

{pydantic_ai_slim-0.8.0 → pydantic_ai_slim-0.8.1}/pydantic_ai/models/instrumented.py

@@ -236,27 +236,36 @@ class InstrumentationSettings:
             if response.provider_details and 'finish_reason' in response.provider_details:
                 output_message['finish_reason'] = response.provider_details['finish_reason']
             instructions = InstrumentedModel._get_instructions(input_messages)  # pyright: ignore [reportPrivateUsage]
+            system_instructions_attributes = self.system_instructions_attributes(instructions)
             attributes = {
                 'gen_ai.input.messages': json.dumps(self.messages_to_otel_messages(input_messages)),
                 'gen_ai.output.messages': json.dumps([output_message]),
+                **system_instructions_attributes,
                 'logfire.json_schema': json.dumps(
                     {
                         'type': 'object',
                         'properties': {
                             'gen_ai.input.messages': {'type': 'array'},
                             'gen_ai.output.messages': {'type': 'array'},
-                            **({'gen_ai.system_instructions': {'type': 'array'}} if instructions else {}),
+                            **(
+                                {'gen_ai.system_instructions': {'type': 'array'}}
+                                if system_instructions_attributes
+                                else {}
+                            ),
                             'model_request_parameters': {'type': 'object'},
                         },
                     }
                 ),
             }
-            if instructions is not None:
-                attributes['gen_ai.system_instructions'] = json.dumps(
-                    [_otel_messages.TextPart(type='text', content=instructions)]
-                )
             span.set_attributes(attributes)
 
+    def system_instructions_attributes(self, instructions: str | None) -> dict[str, str]:
+        if instructions and self.include_content:
+            return {
+                'gen_ai.system_instructions': json.dumps([_otel_messages.TextPart(type='text', content=instructions)]),
+            }
+        return {}
+
     def _emit_events(self, span: Span, events: list[Event]) -> None:
         if self.event_mode == 'logs':
             for event in events:

{pydantic_ai_slim-0.8.0 → pydantic_ai_slim-0.8.1}/pydantic_ai/models/mistral.py

@@ -79,7 +79,7 @@ try:
     from mistralai.models.usermessage import UserMessage as MistralUserMessage
     from mistralai.types.basemodel import Unset as MistralUnset
     from mistralai.utils.eventstreaming import EventStreamAsync as MistralEventStreamAsync
-except ImportError as e:  # pragma: no cover
+except ImportError as e:
     raise ImportError(
         'Please install `mistral` to use the Mistral model, '
         'you can use the `mistral` optional group — `pip install "pydantic-ai-slim[mistral]"`'
@@ -352,7 +352,7 @@ class MistralModel(Model):
             usage=_map_usage(response),
             model_name=response.model,
             timestamp=timestamp,
-            provider_request_id=response.id,
+            provider_response_id=response.id,
             provider_name=self._provider.name,
         )
 

{pydantic_ai_slim-0.8.0 → pydantic_ai_slim-0.8.1}/pydantic_ai/models/openai.py

@@ -517,7 +517,7 @@ class OpenAIChatModel(Model):
             model_name=response.model,
             timestamp=timestamp,
             provider_details=vendor_details,
-            provider_request_id=response.id,
+            provider_response_id=response.id,
             provider_name=self._provider.name,
         )
 
@@ -831,7 +831,7 @@ class OpenAIResponsesModel(Model):
             items,
             usage=_map_usage(response),
             model_name=response.model,
-            provider_request_id=response.id,
+            provider_response_id=response.id,
             timestamp=timestamp,
             provider_name=self._provider.name,
         )

{pydantic_ai_slim-0.8.0 → pydantic_ai_slim-0.8.1}/pydantic_ai/result.py

@@ -7,7 +7,7 @@ from datetime import datetime
 from typing import Generic, cast
 
 from pydantic import ValidationError
-from typing_extensions import TypeVar
+from typing_extensions import TypeVar, deprecated
 
 from pydantic_ai._tool_manager import ToolManager
 
@@ -62,11 +62,11 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
         async for response in self.stream_responses(debounce_by=debounce_by):
             if self._raw_stream_response.final_result_event is not None:
                 try:
-                    yield await self._validate_response(response, allow_partial=True)
+                    yield await self.validate_response_output(response, allow_partial=True)
                 except ValidationError:
                     pass
         if self._raw_stream_response.final_result_event is not None:  # pragma: no branch
-            yield await self._validate_response(self._raw_stream_response.get())
+            yield await self.validate_response_output(self._raw_stream_response.get())
 
     async def stream_responses(self, *, debounce_by: float | None = 0.1) -> AsyncIterator[_messages.ModelResponse]:
         """Asynchronously stream the (unvalidated) model responses for the agent."""
@@ -127,9 +127,11 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
         async for _ in self:
             pass
 
-        return await self._validate_response(self._raw_stream_response.get())
+        return await self.validate_response_output(self._raw_stream_response.get())
 
-    async def _validate_response(self, message: _messages.ModelResponse, *, allow_partial: bool = False) -> OutputDataT:
+    async def validate_response_output(
+        self, message: _messages.ModelResponse, *, allow_partial: bool = False
+    ) -> OutputDataT:
         """Validate a structured result message."""
         final_result_event = self._raw_stream_response.final_result_event
         if final_result_event is None:
@@ -245,9 +247,9 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
     """Whether the stream has all been received.
 
     This is set to `True` when one of
-    [`stream`][pydantic_ai.result.StreamedRunResult.stream],
+    [`stream_output`][pydantic_ai.result.StreamedRunResult.stream_output],
     [`stream_text`][pydantic_ai.result.StreamedRunResult.stream_text],
-    [`stream_structured`][pydantic_ai.result.StreamedRunResult.stream_structured] or
+    [`stream_responses`][pydantic_ai.result.StreamedRunResult.stream_responses] or
     [`get_output`][pydantic_ai.result.StreamedRunResult.get_output] completes.
     """
 
@@ -318,16 +320,21 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
             self.new_messages(output_tool_return_content=output_tool_return_content)
         )
 
+    @deprecated('`StreamedRunResult.stream` is deprecated, use `stream_output` instead.')
     async def stream(self, *, debounce_by: float | None = 0.1) -> AsyncIterator[OutputDataT]:
-        """Stream the response as an async iterable.
+        async for output in self.stream_output(debounce_by=debounce_by):
+            yield output
+
+    async def stream_output(self, *, debounce_by: float | None = 0.1) -> AsyncIterator[OutputDataT]:
+        """Stream the output as an async iterable.
 
         The pydantic validator for structured data will be called in
         [partial mode](https://docs.pydantic.dev/dev/concepts/experimental/#partial-validation)
         on each iteration.
 
         Args:
-            debounce_by: by how much (if at all) to debounce/group the response chunks by. `None` means no debouncing.
-                Debouncing is particularly important for long structured responses to reduce the overhead of
+            debounce_by: by how much (if at all) to debounce/group the output chunks by. `None` means no debouncing.
+                Debouncing is particularly important for long structured outputs to reduce the overhead of
                 performing validation as each token is received.
 
         Returns:
@@ -354,8 +361,15 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
             yield text
         await self._marked_completed(self._stream_response.get())
 
+    @deprecated('`StreamedRunResult.stream_structured` is deprecated, use `stream_responses` instead.')
     async def stream_structured(
         self, *, debounce_by: float | None = 0.1
+    ) -> AsyncIterator[tuple[_messages.ModelResponse, bool]]:
+        async for msg, last in self.stream_responses(debounce_by=debounce_by):
+            yield msg, last
+
+    async def stream_responses(
+        self, *, debounce_by: float | None = 0.1
     ) -> AsyncIterator[tuple[_messages.ModelResponse, bool]]:
         """Stream the response as an async iterable of Structured LLM Messages.
 
@@ -394,13 +408,17 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
         """Get the timestamp of the response."""
         return self._stream_response.timestamp()
 
+    @deprecated('`validate_structured_output` is deprecated, use `validate_response_output` instead.')
     async def validate_structured_output(
         self, message: _messages.ModelResponse, *, allow_partial: bool = False
+    ) -> OutputDataT:
+        return await self._stream_response.validate_response_output(message, allow_partial=allow_partial)
+
+    async def validate_response_output(
+        self, message: _messages.ModelResponse, *, allow_partial: bool = False
     ) -> OutputDataT:
         """Validate a structured result message."""
-        return await self._stream_response._validate_response(  # pyright: ignore[reportPrivateUsage]
-            message, allow_partial=allow_partial
-        )
+        return await self._stream_response.validate_response_output(message, allow_partial=allow_partial)
 
     async def _marked_completed(self, message: _messages.ModelResponse) -> None:
         self.is_complete = True

{pydantic_ai_slim-0.8.0 → pydantic_ai_slim-0.8.1}/pyproject.toml

@@ -94,7 +94,7 @@ ag-ui = ["ag-ui-protocol>=0.1.8", "starlette>=0.45.3"]
 # Retries
 retries = ["tenacity>=8.2.3"]
 # Temporal
-temporal = ["temporalio==1.15.0"]
+temporal = ["temporalio==1.16.0"]
 
 [tool.hatch.metadata]
 allow-direct-references = true