pydantic-ai-slim 1.0.10__tar.gz → 1.0.12__tar.gz

{pydantic_ai_slim-1.0.10 → pydantic_ai_slim-1.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 1.0.10
+Version: 1.0.12
 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
@@ -29,11 +29,11 @@ Classifier: Topic :: Internet
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Requires-Dist: exceptiongroup; python_version < '3.11'
-Requires-Dist: genai-prices>=0.0.23
+Requires-Dist: genai-prices>=0.0.28
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==1.0.10
+Requires-Dist: pydantic-graph==1.0.12
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
@@ -42,7 +42,7 @@ Provides-Extra: ag-ui
 Requires-Dist: ag-ui-protocol>=0.1.8; extra == 'ag-ui'
 Requires-Dist: starlette>=0.45.3; extra == 'ag-ui'
 Provides-Extra: anthropic
-Requires-Dist: anthropic>=0.61.0; extra == 'anthropic'
+Requires-Dist: anthropic>=0.69.0; extra == 'anthropic'
 Provides-Extra: bedrock
 Requires-Dist: boto3>=1.39.0; extra == 'bedrock'
 Provides-Extra: cli
@@ -57,7 +57,7 @@ Requires-Dist: dbos>=1.14.0; extra == 'dbos'
 Provides-Extra: duckduckgo
 Requires-Dist: ddgs>=9.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==1.0.10; extra == 'evals'
+Requires-Dist: pydantic-evals==1.0.12; 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.17.0; extra == 'temporal'
+Requires-Dist: temporalio==1.18.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-1.0.12/pydantic_ai/__init__.py

@@ -0,0 +1,215 @@
+from importlib.metadata import version as _metadata_version
+
+from .agent import (
+    Agent,
+    CallToolsNode,
+    EndStrategy,
+    InstrumentationSettings,
+    ModelRequestNode,
+    UserPromptNode,
+    capture_run_messages,
+)
+from .builtin_tools import CodeExecutionTool, UrlContextTool, WebSearchTool, WebSearchUserLocation
+from .exceptions import (
+    AgentRunError,
+    ApprovalRequired,
+    CallDeferred,
+    FallbackExceptionGroup,
+    ModelHTTPError,
+    ModelRetry,
+    UnexpectedModelBehavior,
+    UsageLimitExceeded,
+    UserError,
+)
+from .format_prompt import format_as_xml
+from .messages import (
+    AgentStreamEvent,
+    AudioFormat,
+    AudioMediaType,
+    AudioUrl,
+    BaseToolCallPart,
+    BaseToolReturnPart,
+    BinaryContent,
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
+    DocumentFormat,
+    DocumentMediaType,
+    DocumentUrl,
+    FileUrl,
+    FinalResultEvent,
+    FinishReason,
+    FunctionToolCallEvent,
+    FunctionToolResultEvent,
+    HandleResponseEvent,
+    ImageFormat,
+    ImageMediaType,
+    ImageUrl,
+    ModelMessage,
+    ModelMessagesTypeAdapter,
+    ModelRequest,
+    ModelRequestPart,
+    ModelResponse,
+    ModelResponsePart,
+    ModelResponsePartDelta,
+    ModelResponseStreamEvent,
+    MultiModalContent,
+    PartDeltaEvent,
+    PartStartEvent,
+    RetryPromptPart,
+    SystemPromptPart,
+    TextPart,
+    TextPartDelta,
+    ThinkingPart,
+    ThinkingPartDelta,
+    ToolCallPart,
+    ToolCallPartDelta,
+    ToolReturn,
+    ToolReturnPart,
+    UserContent,
+    UserPromptPart,
+    VideoFormat,
+    VideoMediaType,
+    VideoUrl,
+)
+from .output import NativeOutput, PromptedOutput, StructuredDict, TextOutput, ToolOutput
+from .profiles import (
+    DEFAULT_PROFILE,
+    InlineDefsJsonSchemaTransformer,
+    JsonSchemaTransformer,
+    ModelProfile,
+    ModelProfileSpec,
+)
+from .settings import ModelSettings
+from .tools import DeferredToolRequests, DeferredToolResults, RunContext, Tool, ToolApproved, ToolDefinition, ToolDenied
+from .toolsets import (
+    AbstractToolset,
+    ApprovalRequiredToolset,
+    CombinedToolset,
+    ExternalToolset,
+    FilteredToolset,
+    FunctionToolset,
+    PrefixedToolset,
+    PreparedToolset,
+    RenamedToolset,
+    ToolsetFunc,
+    ToolsetTool,
+    WrapperToolset,
+)
+from .usage import RequestUsage, RunUsage, UsageLimits
+
+__all__ = (
+    '__version__',
+    # agent
+    'Agent',
+    'EndStrategy',
+    'CallToolsNode',
+    'ModelRequestNode',
+    'UserPromptNode',
+    'capture_run_messages',
+    'InstrumentationSettings',
+    # exceptions
+    'AgentRunError',
+    'CallDeferred',
+    'ApprovalRequired',
+    'ModelRetry',
+    'ModelHTTPError',
+    'FallbackExceptionGroup',
+    'UnexpectedModelBehavior',
+    'UsageLimitExceeded',
+    'UserError',
+    # messages
+    'AgentStreamEvent',
+    'AudioFormat',
+    'AudioMediaType',
+    'AudioUrl',
+    'BaseToolCallPart',
+    'BaseToolReturnPart',
+    'BinaryContent',
+    'BuiltinToolCallPart',
+    'BuiltinToolReturnPart',
+    'DocumentFormat',
+    'DocumentMediaType',
+    'DocumentUrl',
+    'FileUrl',
+    'FinalResultEvent',
+    'FinishReason',
+    'FunctionToolCallEvent',
+    'FunctionToolResultEvent',
+    'HandleResponseEvent',
+    'ImageFormat',
+    'ImageMediaType',
+    'ImageUrl',
+    'ModelMessage',
+    'ModelMessagesTypeAdapter',
+    'ModelRequest',
+    'ModelRequestPart',
+    'ModelResponse',
+    'ModelResponsePart',
+    'ModelResponsePartDelta',
+    'ModelResponseStreamEvent',
+    'MultiModalContent',
+    'PartDeltaEvent',
+    'PartStartEvent',
+    'RetryPromptPart',
+    'SystemPromptPart',
+    'TextPart',
+    'TextPartDelta',
+    'ThinkingPart',
+    'ThinkingPartDelta',
+    'ToolCallPart',
+    'ToolCallPartDelta',
+    'ToolReturn',
+    'ToolReturnPart',
+    'UserContent',
+    'UserPromptPart',
+    'VideoFormat',
+    'VideoMediaType',
+    'VideoUrl',
+    # profiles
+    'ModelProfile',
+    'ModelProfileSpec',
+    'DEFAULT_PROFILE',
+    'InlineDefsJsonSchemaTransformer',
+    'JsonSchemaTransformer',
+    # tools
+    'Tool',
+    'ToolDefinition',
+    'RunContext',
+    'DeferredToolRequests',
+    'DeferredToolResults',
+    'ToolApproved',
+    'ToolDenied',
+    # toolsets
+    'AbstractToolset',
+    'ApprovalRequiredToolset',
+    'CombinedToolset',
+    'ExternalToolset',
+    'FilteredToolset',
+    'FunctionToolset',
+    'PrefixedToolset',
+    'PreparedToolset',
+    'RenamedToolset',
+    'ToolsetFunc',
+    'ToolsetTool',
+    'WrapperToolset',
+    # builtin_tools
+    'WebSearchTool',
+    'WebSearchUserLocation',
+    'UrlContextTool',
+    'CodeExecutionTool',
+    # output
+    'ToolOutput',
+    'NativeOutput',
+    'PromptedOutput',
+    'TextOutput',
+    'StructuredDict',
+    # format_prompt
+    'format_as_xml',
+    # settings
+    'ModelSettings',
+    # usage
+    'RunUsage',
+    'RequestUsage',
+    'UsageLimits',
+)
+__version__ = _metadata_version('pydantic_ai_slim')

{pydantic_ai_slim-1.0.10 → pydantic_ai_slim-1.0.12}/pydantic_ai/_a2a.py

@@ -10,7 +10,7 @@ from typing import Any, Generic, TypeVar
 from pydantic import TypeAdapter
 from typing_extensions import assert_never
 
-from pydantic_ai.messages import (
+from pydantic_ai import (
     AudioUrl,
     BinaryContent,
     DocumentUrl,

{pydantic_ai_slim-1.0.10 → pydantic_ai_slim-1.0.12}/pydantic_ai/_function_schema.py

@@ -231,31 +231,39 @@ R = TypeVar('R')
 
 WithCtx = Callable[Concatenate[RunContext[Any], P], R]
 WithoutCtx = Callable[P, R]
-TargetFunc = WithCtx[P, R] | WithoutCtx[P, R]
+TargetCallable = WithCtx[P, R] | WithoutCtx[P, R]
 
 
-def _takes_ctx(function: TargetFunc[P, R]) -> TypeIs[WithCtx[P, R]]:
-    """Check if a function takes a `RunContext` first argument.
+def _takes_ctx(callable_obj: TargetCallable[P, R]) -> TypeIs[WithCtx[P, R]]:
+    """Check if a callable takes a `RunContext` first argument.
 
     Args:
-        function: The function to check.
+        callable_obj: The callable to check.
 
     Returns:
-        `True` if the function takes a `RunContext` as first argument, `False` otherwise.
+        `True` if the callable takes a `RunContext` as first argument, `False` otherwise.
     """
     try:
-        sig = signature(function)
-    except ValueError:  # pragma: no cover
-        return False  # pragma: no cover
+        sig = signature(callable_obj)
+    except ValueError:
+        return False
     try:
         first_param_name = next(iter(sig.parameters.keys()))
     except StopIteration:
         return False
     else:
-        type_hints = _typing_extra.get_function_type_hints(function)
+        # See https://github.com/pydantic/pydantic/pull/11451 for a similar implementation in Pydantic
+        if not isinstance(callable_obj, _decorators._function_like):  # pyright: ignore[reportPrivateUsage]
+            call_func = getattr(type(callable_obj), '__call__', None)
+            if call_func is not None:
+                callable_obj = call_func
+            else:
+                return False  # pragma: no cover
+
+        type_hints = _typing_extra.get_function_type_hints(_decorators.unwrap_wrapped_function(callable_obj))
         annotation = type_hints.get(first_param_name)
         if annotation is None:
-            return False  # pragma: no cover
+            return False
         return True is not sig.empty and _is_call_ctx(annotation)
 
 

{pydantic_ai_slim-1.0.10/pydantic_ai/profiles → pydantic_ai_slim-1.0.12/pydantic_ai}/_json_schema.py

@@ -6,7 +6,7 @@ from copy import deepcopy
 from dataclasses import dataclass
 from typing import Any, Literal
 
-from pydantic_ai.exceptions import UserError
+from .exceptions import UserError
 
 JsonSchema = dict[str, Any]
 
@@ -54,14 +54,14 @@ class JsonSchemaTransformer(ABC):
         if not self.prefer_inlined_defs and self.defs:
             handled['$defs'] = {k: self._handle(v) for k, v in self.defs.items()}
 
-        elif self.recursive_refs:  # pragma: no cover
+        elif self.recursive_refs:
             # If we are preferring inlined defs and there are recursive refs, we _have_ to use a $defs+$ref structure
             # We try to use whatever the original root key was, but if it is already in use,
             # we modify it to avoid collisions.
             defs = {key: self.defs[key] for key in self.recursive_refs}
             root_ref = self.schema.get('$ref')
             root_key = None if root_ref is None else re.sub(r'^#/\$defs/', '', root_ref)
-            if root_key is None:
+            if root_key is None:  # pragma: no cover
                 root_key = self.schema.get('title', 'root')
                 while root_key in defs:
                     # Modify the root key until it is not already in use
@@ -77,6 +77,8 @@ class JsonSchemaTransformer(ABC):
         if self.prefer_inlined_defs:
             while ref := schema.get('$ref'):
                 key = re.sub(r'^#/\$defs/', '', ref)
+                if key in self.recursive_refs:
+                    break
                 if key in self.refs_stack:
                     self.recursive_refs.add(key)
                     break  # recursive ref can't be unpacked

{pydantic_ai_slim-1.0.10 → pydantic_ai_slim-1.0.12}/pydantic_ai/_output.py

@@ -19,6 +19,7 @@ from .output import (
     NativeOutput,
     OutputDataT,
     OutputMode,
+    OutputObjectDefinition,
     OutputSpec,
     OutputTypeOrFunction,
     PromptedOutput,
@@ -581,14 +582,6 @@ class ToolOrTextOutputSchema(ToolOutputSchema[OutputDataT], PlainTextOutputSchem
         return 'tool_or_text'
 
 
-@dataclass
-class OutputObjectDefinition:
-    json_schema: ObjectJsonSchema
-    name: str | None = None
-    description: str | None = None
-    strict: bool | None = None
-
-
 @dataclass(init=False)
 class BaseOutputProcessor(ABC, Generic[OutputDataT]):
     @abstractmethod

{pydantic_ai_slim-1.0.10 → pydantic_ai_slim-1.0.12}/pydantic_ai/_thinking_part.py

@@ -1,6 +1,6 @@
 from __future__ import annotations as _annotations
 
-from pydantic_ai.messages import TextPart, ThinkingPart
+from pydantic_ai import TextPart, ThinkingPart
 
 
 def split_content_into_text_and_thinking(content: str, thinking_tags: tuple[str, str]) -> list[ThinkingPart | TextPart]:

{pydantic_ai_slim-1.0.10 → pydantic_ai_slim-1.0.12}/pydantic_ai/_utils.py

@@ -6,7 +6,7 @@ import inspect
 import re
 import time
 import uuid
-from collections.abc import AsyncIterable, AsyncIterator, Awaitable, Callable, Iterator
+from collections.abc import AsyncIterable, AsyncIterator, Awaitable, Callable, Iterable, Iterator
 from contextlib import asynccontextmanager, suppress
 from dataclasses import dataclass, fields, is_dataclass
 from datetime import datetime, timezone
@@ -70,16 +70,33 @@ def check_object_json_schema(schema: JsonSchemaValue) -> ObjectJsonSchema:
 
     if schema.get('type') == 'object':
         return schema
-    elif schema.get('$ref') is not None:
-        maybe_result = schema.get('$defs', {}).get(schema['$ref'][8:])  # This removes the initial "#/$defs/".
-
-        if "'$ref': '#/$defs/" in str(maybe_result):
-            return schema  # We can't remove the $defs because the schema contains other references
-        return maybe_result
+    elif ref := schema.get('$ref'):
+        prefix = '#/$defs/'
+        # Return the referenced schema unless it contains additional nested references.
+        if (
+            ref.startswith(prefix)
+            and (resolved := schema.get('$defs', {}).get(ref[len(prefix) :]))
+            and resolved.get('type') == 'object'
+            and not _contains_ref(resolved)
+        ):
+            return resolved
+        return schema
     else:
         raise UserError('Schema must be an object')
 
 
+def _contains_ref(obj: JsonSchemaValue | list[JsonSchemaValue]) -> bool:
+    """Recursively check if an object contains any $ref keys."""
+    items: Iterable[JsonSchemaValue]
+    if isinstance(obj, dict):
+        if '$ref' in obj:
+            return True
+        items = obj.values()
+    else:
+        items = obj
+    return any(isinstance(item, dict | list) and _contains_ref(item) for item in items)  # pyright: ignore[reportUnknownArgumentType]
+
+
 T = TypeVar('T')
 
 

{pydantic_ai_slim-1.0.10 → pydantic_ai_slim-1.0.12}/pydantic_ai/agent/__init__.py

@@ -1206,8 +1206,7 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
 
         Example:
         ```python
-        from pydantic_ai import Agent, RunContext
-        from pydantic_ai.toolsets import AbstractToolset, FunctionToolset
+        from pydantic_ai import AbstractToolset, Agent, FunctionToolset, RunContext
 
         agent = Agent('test', deps_type=str)
 

{pydantic_ai_slim-1.0.10 → pydantic_ai_slim-1.0.12}/pydantic_ai/builtin_tools.py

@@ -6,7 +6,14 @@ from typing import Literal
 
 from typing_extensions import TypedDict
 
-__all__ = ('AbstractBuiltinTool', 'WebSearchTool', 'WebSearchUserLocation', 'CodeExecutionTool', 'UrlContextTool')
+__all__ = (
+    'AbstractBuiltinTool',
+    'WebSearchTool',
+    'WebSearchUserLocation',
+    'CodeExecutionTool',
+    'UrlContextTool',
+    'MemoryTool',
+)
 
 
 @dataclass(kw_only=True)
@@ -133,3 +140,15 @@ class UrlContextTool(AbstractBuiltinTool):
 
     kind: str = 'url_context'
     """The kind of tool."""
+
+
+class MemoryTool(AbstractBuiltinTool):
+    """A builtin tool that allows your agent to use memory.
+
+    Supported by:
+
+    * Anthropic
+    """
+
+    kind: str = 'memory'
+    """The kind of tool."""

{pydantic_ai_slim-1.0.10 → pydantic_ai_slim-1.0.12}/pydantic_ai/common_tools/duckduckgo.py

@@ -4,7 +4,7 @@ from dataclasses import KW_ONLY, dataclass
 import anyio
 import anyio.to_thread
 from pydantic import TypeAdapter
-from typing_extensions import TypedDict
+from typing_extensions import Any, TypedDict
 
 from pydantic_ai.tools import Tool
 
@@ -69,7 +69,7 @@ def duckduckgo_search_tool(duckduckgo_client: DDGS | None = None, max_results: i
         duckduckgo_client: The DuckDuckGo search client.
         max_results: The maximum number of results. If None, returns results only from the first response.
     """
-    return Tool(
+    return Tool[Any](
         DuckDuckGoSearchTool(client=duckduckgo_client or DDGS(), max_results=max_results).__call__,
         name='duckduckgo_search',
         description='Searches DuckDuckGo for the given query and returns the results.',

{pydantic_ai_slim-1.0.10 → pydantic_ai_slim-1.0.12}/pydantic_ai/common_tools/tavily.py

@@ -2,7 +2,7 @@ from dataclasses import dataclass
 from typing import Literal
 
 from pydantic import TypeAdapter
-from typing_extensions import TypedDict
+from typing_extensions import Any, TypedDict
 
 from pydantic_ai.tools import Tool
 
@@ -74,7 +74,7 @@ def tavily_search_tool(api_key: str):
 
             You can get one by signing up at [https://app.tavily.com/home](https://app.tavily.com/home).
     """
-    return Tool(
+    return Tool[Any](
         TavilySearchTool(client=AsyncTavilyClient(api_key)).__call__,
         name='tavily_search',
         description='Searches Tavily for the given query and returns the results.',

{pydantic_ai_slim-1.0.10 → pydantic_ai_slim-1.0.12}/pydantic_ai/direct.py

@@ -44,8 +44,8 @@ async def model_request(
     """Make a non-streamed request to a model.
 
     ```py title="model_request_example.py"
+    from pydantic_ai import ModelRequest
     from pydantic_ai.direct import model_request
-    from pydantic_ai.messages import ModelRequest
 
 
     async def main():
@@ -99,8 +99,8 @@ def model_request_sync(
     `loop.run_until_complete(...)`. You therefore can't use this method inside async code or if there's an active event loop.
 
     ```py title="model_request_sync_example.py"
+    from pydantic_ai import ModelRequest
     from pydantic_ai.direct import model_request_sync
-    from pydantic_ai.messages import ModelRequest
 
     model_response = model_request_sync(
         'anthropic:claude-3-5-haiku-latest',
@@ -153,8 +153,8 @@ def model_request_stream(
 
     ```py {title="model_request_stream_example.py"}
 
+    from pydantic_ai import ModelRequest
     from pydantic_ai.direct import model_request_stream
-    from pydantic_ai.messages import ModelRequest
 
 
     async def main():
@@ -212,8 +212,8 @@ def model_request_stream_sync(
 
     ```py {title="model_request_stream_sync_example.py"}
 
+    from pydantic_ai import ModelRequest
     from pydantic_ai.direct import model_request_stream_sync
-    from pydantic_ai.messages import ModelRequest
 
     messages = [ModelRequest.user_text_prompt('Who was Albert Einstein?')]
     with model_request_stream_sync('openai:gpt-4.1-mini', messages) as stream:

{pydantic_ai_slim-1.0.10 → pydantic_ai_slim-1.0.12}/pydantic_ai/durable_exec/dbos/_agent.py

@@ -8,6 +8,7 @@ from dbos import DBOS, DBOSConfiguredInstance
 from typing_extensions import Never
 
 from pydantic_ai import (
+    AbstractToolset,
     _utils,
     messages as _messages,
     models,
@@ -26,7 +27,6 @@ from pydantic_ai.tools import (
     Tool,
     ToolFuncEither,
 )
-from pydantic_ai.toolsets import AbstractToolset
 
 from ._model import DBOSModel
 from ._utils import StepConfig

{pydantic_ai_slim-1.0.10 → pydantic_ai_slim-1.0.12}/pydantic_ai/durable_exec/dbos/_mcp_server.py

@@ -7,9 +7,8 @@ from typing import TYPE_CHECKING, Any
 from dbos import DBOS
 from typing_extensions import Self
 
+from pydantic_ai import AbstractToolset, ToolsetTool, WrapperToolset
 from pydantic_ai.tools import AgentDepsT, RunContext
-from pydantic_ai.toolsets.abstract import AbstractToolset, ToolsetTool
-from pydantic_ai.toolsets.wrapper import WrapperToolset
 
 from ._utils import StepConfig
 

{pydantic_ai_slim-1.0.10 → pydantic_ai_slim-1.0.12}/pydantic_ai/durable_exec/dbos/_model.py

@@ -7,12 +7,12 @@ from typing import Any
 
 from dbos import DBOS
 
-from pydantic_ai.agent import EventStreamHandler
-from pydantic_ai.messages import (
+from pydantic_ai import (
     ModelMessage,
     ModelResponse,
     ModelResponseStreamEvent,
 )
+from pydantic_ai.agent import EventStreamHandler
 from pydantic_ai.models import Model, ModelRequestParameters, StreamedResponse
 from pydantic_ai.models.wrapper import WrapperModel
 from pydantic_ai.settings import ModelSettings

{pydantic_ai_slim-1.0.10 → pydantic_ai_slim-1.0.12}/pydantic_ai/durable_exec/temporal/_agent.py

@@ -16,6 +16,7 @@ from temporalio.workflow import ActivityConfig
 from typing_extensions import Never
 
 from pydantic_ai import (
+    AbstractToolset,
     _utils,
     messages as _messages,
     models,
@@ -34,7 +35,6 @@ from pydantic_ai.tools import (
     Tool,
     ToolFuncEither,
 )
-from pydantic_ai.toolsets import AbstractToolset
 
 from ._model import TemporalModel
 from ._run_context import TemporalRunContext

{pydantic_ai_slim-1.0.10 → pydantic_ai_slim-1.0.12}/pydantic_ai/durable_exec/temporal/_function_toolset.py

@@ -8,9 +8,9 @@ from pydantic import ConfigDict, Discriminator, with_config
 from temporalio import activity, workflow
 from temporalio.workflow import ActivityConfig
 
+from pydantic_ai import FunctionToolset, ToolsetTool
 from pydantic_ai.exceptions import ApprovalRequired, CallDeferred, ModelRetry, UserError
 from pydantic_ai.tools import AgentDepsT, RunContext
-from pydantic_ai.toolsets import FunctionToolset, ToolsetTool
 from pydantic_ai.toolsets.function import FunctionToolsetTool
 
 from ._run_context import TemporalRunContext

{pydantic_ai_slim-1.0.10 → pydantic_ai_slim-1.0.12}/pydantic_ai/durable_exec/temporal/_mcp_server.py

@@ -9,10 +9,10 @@ from temporalio import activity, workflow
 from temporalio.workflow import ActivityConfig
 from typing_extensions import Self
 
+from pydantic_ai import ToolsetTool
 from pydantic_ai.exceptions import UserError
 from pydantic_ai.mcp import MCPServer, ToolResult
 from pydantic_ai.tools import AgentDepsT, RunContext, ToolDefinition
-from pydantic_ai.toolsets.abstract import ToolsetTool
 
 from ._run_context import TemporalRunContext
 from ._toolset import TemporalWrapperToolset

{pydantic_ai_slim-1.0.10 → pydantic_ai_slim-1.0.12}/pydantic_ai/durable_exec/temporal/_model.py

@@ -10,13 +10,13 @@ from pydantic import ConfigDict, with_config
 from temporalio import activity, workflow
 from temporalio.workflow import ActivityConfig
 
-from pydantic_ai.agent import EventStreamHandler
-from pydantic_ai.exceptions import UserError
-from pydantic_ai.messages import (
+from pydantic_ai import (
     ModelMessage,
     ModelResponse,
     ModelResponseStreamEvent,
 )
+from pydantic_ai.agent import EventStreamHandler
+from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import Model, ModelRequestParameters, StreamedResponse
 from pydantic_ai.models.wrapper import WrapperModel
 from pydantic_ai.settings import ModelSettings

{pydantic_ai_slim-1.0.10 → pydantic_ai_slim-1.0.12}/pydantic_ai/durable_exec/temporal/_toolset.py

@@ -6,10 +6,8 @@ from typing import Any, Literal
 
 from temporalio.workflow import ActivityConfig
 
+from pydantic_ai import AbstractToolset, FunctionToolset, WrapperToolset
 from pydantic_ai.tools import AgentDepsT
-from pydantic_ai.toolsets.abstract import AbstractToolset
-from pydantic_ai.toolsets.function import FunctionToolset
-from pydantic_ai.toolsets.wrapper import WrapperToolset
 
 from ._run_context import TemporalRunContext