pydantic-ai-slim 0.2.15__tar.gz → 0.2.16__tar.gz

{pydantic_ai_slim-0.2.15 → pydantic_ai_slim-0.2.16}/PKG-INFO

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

{pydantic_ai_slim-0.2.15 → pydantic_ai_slim-0.2.16}/pydantic_ai/_agent_graph.py

@@ -151,10 +151,6 @@ class UserPromptNode(AgentNode[DepsT, NodeRunEndT]):
         ctx.state.message_history = history
         run_context.messages = history
 
-        # TODO: We need to make it so that function_tools are not shared between runs
-        #   See comment on the current_retry field of `Tool` for more details.
-        for tool in ctx.deps.function_tools.values():
-            tool.current_retry = 0
         return next_message
 
     async def _prepare_messages(

{pydantic_ai_slim-0.2.15 → pydantic_ai_slim-0.2.16}/pydantic_ai/_function_schema.py

@@ -7,7 +7,7 @@ from __future__ import annotations as _annotations
 
 import inspect
 from collections.abc import Awaitable
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from inspect import Parameter, signature
 from typing import TYPE_CHECKING, Any, Callable, cast
 
@@ -43,9 +43,9 @@ class FunctionSchema:
     # if not None, the function takes a single by that name (besides potentially `info`)
     takes_ctx: bool
     is_async: bool
-    single_arg_name: str | None
-    positional_fields: list[str]
-    var_positional_field: str | None
+    single_arg_name: str | None = None
+    positional_fields: list[str] = field(default_factory=list)
+    var_positional_field: str | None = None
 
     async def call(self, args_dict: dict[str, Any], ctx: RunContext[Any]) -> Any:
         args, kwargs = self._call_args(args_dict, ctx)

{pydantic_ai_slim-0.2.15 → pydantic_ai_slim-0.2.16}/pydantic_ai/_output.py

@@ -138,7 +138,7 @@ class ToolOutput(Generic[OutputDataT]):
 T_co = TypeVar('T_co', covariant=True)
 # output_type=Type or output_type=function or output_type=object.method
 SimpleOutputType = TypeAliasType(
-    'SimpleOutputType', Union[type[T_co], Callable[..., T_co], Callable[..., Awaitable[T_co]]], type_params=(T_co,)
+    'SimpleOutputType', Union[type[T_co], Callable[..., Union[Awaitable[T_co], T_co]]], type_params=(T_co,)
 )
 # output_type=ToolOutput(<see above>) or <see above>
 SimpleOutputTypeOrMarker = TypeAliasType(

{pydantic_ai_slim-0.2.15 → pydantic_ai_slim-0.2.16}/pydantic_ai/_utils.py

@@ -12,7 +12,7 @@ from types import GenericAlias
 from typing import TYPE_CHECKING, Any, Callable, Generic, TypeVar, Union
 
 from anyio.to_thread import run_sync
-from pydantic import BaseModel
+from pydantic import BaseModel, TypeAdapter
 from pydantic.json_schema import JsonSchemaValue
 from typing_extensions import ParamSpec, TypeAlias, TypeGuard, is_typeddict
 
@@ -298,3 +298,7 @@ def dataclasses_no_defaults_repr(self: Any) -> str:
         f'{f.name}={getattr(self, f.name)!r}' for f in fields(self) if f.repr and getattr(self, f.name) != f.default
     )
     return f'{self.__class__.__qualname__}({", ".join(kv_pairs)})'
+
+
+def number_to_datetime(x: int | float) -> datetime:
+    return TypeAdapter(datetime).validate_python(x)

{pydantic_ai_slim-0.2.15 → pydantic_ai_slim-0.2.16}/pydantic_ai/agent.py

@@ -646,11 +646,6 @@ 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)
 
-        # TODO: Instead of this, copy the function tools to ensure they don't share current_retry state between agent
-        #  runs. Requires some changes to `Tool` to make them copyable though.
-        for v in self._function_tools.values():
-            v.current_retry = 0
-
         model_settings = merge_model_settings(self.model_settings, model_settings)
         usage_limits = usage_limits or _usage.UsageLimits()
 
@@ -679,6 +674,10 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
                 instructions += '\n' + await instructions_runner.run(run_context)
             return instructions.strip()
 
+        # Copy the function tools so that retry state is agent-run-specific
+        # Note that the retry count is reset to 0 when this happens due to the `default=0` and `init=False`.
+        run_function_tools = {k: dataclasses.replace(v) for k, v in self._function_tools.items()}
+
         graph_deps = _agent_graph.GraphAgentDeps[AgentDepsT, RunOutputDataT](
             user_deps=deps,
             prompt=user_prompt,
@@ -690,7 +689,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
             end_strategy=self.end_strategy,
             output_schema=output_schema,
             output_validators=output_validators,
-            function_tools=self._function_tools,
+            function_tools=run_function_tools,
             mcp_servers=self._mcp_servers,
             default_retries=self._default_retries,
             tracer=tracer,

pydantic_ai_slim-0.2.16/pydantic_ai/ext/langchain.py

@@ -0,0 +1,61 @@
+from typing import Any, Protocol
+
+from pydantic.json_schema import JsonSchemaValue
+
+from pydantic_ai.tools import Tool
+
+
+class LangChainTool(Protocol):
+    # args are like
+    # {'dir_path': {'default': '.', 'description': 'Subdirectory to search in.', 'title': 'Dir Path', 'type': 'string'},
+    #  'pattern': {'description': 'Unix shell regex, where * matches everything.', 'title': 'Pattern', 'type': 'string'}}
+    @property
+    def args(self) -> dict[str, JsonSchemaValue]: ...
+
+    def get_input_jsonschema(self) -> JsonSchemaValue: ...
+
+    @property
+    def name(self) -> str: ...
+
+    @property
+    def description(self) -> str: ...
+
+    def run(self, *args: Any, **kwargs: Any) -> str: ...
+
+
+__all__ = ('tool_from_langchain',)
+
+
+def tool_from_langchain(langchain_tool: LangChainTool) -> Tool:
+    """Creates a Pydantic tool proxy from a LangChain tool.
+
+    Args:
+        langchain_tool: The LangChain tool to wrap.
+
+    Returns:
+        A Pydantic tool that corresponds to the LangChain tool.
+    """
+    function_name = langchain_tool.name
+    function_description = langchain_tool.description
+    inputs = langchain_tool.args.copy()
+    required = sorted({name for name, detail in inputs.items() if 'default' not in detail})
+    schema: JsonSchemaValue = langchain_tool.get_input_jsonschema()
+    if 'additionalProperties' not in schema:
+        schema['additionalProperties'] = False
+    if required:
+        schema['required'] = required
+
+    defaults = {name: detail['default'] for name, detail in inputs.items() if 'default' in detail}
+
+    # restructures the arguments to match langchain tool run
+    def proxy(*args: Any, **kwargs: Any) -> str:
+        assert not args, 'This should always be called with kwargs'
+        kwargs = defaults | kwargs
+        return langchain_tool.run(kwargs)
+
+    return Tool.from_schema(
+        function=proxy,
+        name=function_name,
+        description=function_description,
+        json_schema=schema,
+    )

{pydantic_ai_slim-0.2.15 → pydantic_ai_slim-0.2.16}/pydantic_ai/models/__init__.py

@@ -211,6 +211,11 @@ KnownModelName = TypeAliasType(
         'groq:llama-3.2-3b-preview',
         'groq:llama-3.2-11b-vision-preview',
         'groq:llama-3.2-90b-vision-preview',
+        'heroku:claude-3-5-haiku',
+        'heroku:claude-3-5-sonnet-latest',
+        'heroku:claude-3-7-sonnet',
+        'heroku:claude-4-sonnet',
+        'heroku:claude-3-haiku',
         'mistral:codestral-latest',
         'mistral:mistral-large-latest',
         'mistral:mistral-moderation-latest',
@@ -543,7 +548,7 @@ def infer_model(model: Model | KnownModelName | str) -> Model:
         from .cohere import CohereModel
 
         return CohereModel(model_name, provider=provider)
-    elif provider in ('openai', 'deepseek', 'azure', 'openrouter', 'grok', 'fireworks', 'together'):
+    elif provider in ('openai', 'deepseek', 'azure', 'openrouter', 'grok', 'fireworks', 'together', 'heroku'):
         from .openai import OpenAIModel
 
         return OpenAIModel(model_name, provider=provider)

{pydantic_ai_slim-0.2.15 → pydantic_ai_slim-0.2.16}/pydantic_ai/models/gemini.py

@@ -228,7 +228,7 @@ class GeminiModel(Model):
 
         if gemini_labels := model_settings.get('gemini_labels'):
             if self._system == 'google-vertex':
-                request_data['labels'] = gemini_labels
+                request_data['labels'] = gemini_labels  # pragma: lax no cover
 
         headers = {'Content-Type': 'application/json', 'User-Agent': get_user_agent()}
         url = f'/{self._model_name}:{"streamGenerateContent" if streamed else "generateContent"}'
@@ -366,6 +366,8 @@ def _settings_to_generation_config(model_settings: GeminiModelSettings) -> _Gemi
     config: _GeminiGenerationConfig = {}
     if (max_tokens := model_settings.get('max_tokens')) is not None:
         config['max_output_tokens'] = max_tokens
+    if (stop_sequences := model_settings.get('stop_sequences')) is not None:
+        config['stop_sequences'] = stop_sequences  # pragma: no cover
     if (temperature := model_settings.get('temperature')) is not None:
         config['temperature'] = temperature
     if (top_p := model_settings.get('top_p')) is not None:

{pydantic_ai_slim-0.2.15 → pydantic_ai_slim-0.2.16}/pydantic_ai/models/google.py

@@ -260,6 +260,7 @@ class GoogleModel(Model):
             temperature=model_settings.get('temperature'),
             top_p=model_settings.get('top_p'),
             max_output_tokens=model_settings.get('max_tokens'),
+            stop_sequences=model_settings.get('stop_sequences'),
             presence_penalty=model_settings.get('presence_penalty'),
             frequency_penalty=model_settings.get('frequency_penalty'),
             safety_settings=model_settings.get('google_safety_settings'),

{pydantic_ai_slim-0.2.15 → pydantic_ai_slim-0.2.16}/pydantic_ai/models/groq.py

@@ -4,13 +4,13 @@ import base64
 from collections.abc import AsyncIterable, AsyncIterator, Iterable
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import Literal, Union, cast, overload
 
 from typing_extensions import assert_never
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
-from .._utils import guard_tool_call_id as _guard_tool_call_id
+from .._utils import guard_tool_call_id as _guard_tool_call_id, number_to_datetime
 from ..messages import (
     BinaryContent,
     DocumentUrl,
@@ -246,7 +246,7 @@ class GroqModel(Model):
 
     def _process_response(self, response: chat.ChatCompletion) -> ModelResponse:
         """Process a non-streamed response, and prepare a message to return."""
-        timestamp = datetime.fromtimestamp(response.created, tz=timezone.utc)
+        timestamp = number_to_datetime(response.created)
         choice = response.choices[0]
         items: list[ModelResponsePart] = []
         if choice.message.content is not None:
@@ -270,7 +270,7 @@ class GroqModel(Model):
         return GroqStreamedResponse(
             _response=peekable_response,
             _model_name=self._model_name,
-            _timestamp=datetime.fromtimestamp(first_chunk.created, tz=timezone.utc),
+            _timestamp=number_to_datetime(first_chunk.created),
         )
 
     def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[chat.ChatCompletionToolParam]:

{pydantic_ai_slim-0.2.15 → pydantic_ai_slim-0.2.16}/pydantic_ai/models/mistral.py

@@ -4,7 +4,7 @@ import base64
 from collections.abc import AsyncIterable, AsyncIterator, Iterable
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import Any, Literal, Union, cast
 
 import pydantic_core
@@ -12,7 +12,7 @@ from httpx import Timeout
 from typing_extensions import assert_never
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils
-from .._utils import generate_tool_call_id as _generate_tool_call_id, now_utc as _now_utc
+from .._utils import generate_tool_call_id as _generate_tool_call_id, now_utc as _now_utc, number_to_datetime
 from ..messages import (
     BinaryContent,
     DocumentUrl,
@@ -312,7 +312,7 @@ class MistralModel(Model):
         assert response.choices, 'Unexpected empty response choice.'
 
         if response.created:
-            timestamp = datetime.fromtimestamp(response.created, tz=timezone.utc)
+            timestamp = number_to_datetime(response.created)
         else:
             timestamp = _now_utc()
 
@@ -347,9 +347,9 @@ class MistralModel(Model):
             )
 
         if first_chunk.data.created:
-            timestamp = datetime.fromtimestamp(first_chunk.data.created, tz=timezone.utc)
+            timestamp = number_to_datetime(first_chunk.data.created)
         else:
-            timestamp = datetime.now(tz=timezone.utc)
+            timestamp = _now_utc()
 
         return MistralStreamedResponse(
             _response=peekable_response,

{pydantic_ai_slim-0.2.15 → pydantic_ai_slim-0.2.16}/pydantic_ai/models/openai.py

@@ -5,7 +5,7 @@ import warnings
 from collections.abc import AsyncIterable, AsyncIterator, Sequence
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import Any, Literal, Union, cast, overload
 
 from typing_extensions import assert_never
@@ -14,7 +14,7 @@ from pydantic_ai.profiles.openai import OpenAIModelProfile
 from pydantic_ai.providers import Provider, infer_provider
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
-from .._utils import guard_tool_call_id as _guard_tool_call_id
+from .._utils import guard_tool_call_id as _guard_tool_call_id, number_to_datetime
 from ..messages import (
     AudioUrl,
     BinaryContent,
@@ -170,7 +170,7 @@ class OpenAIModel(Model):
         self,
         model_name: OpenAIModelName,
         *,
-        provider: Literal['openai', 'deepseek', 'azure', 'openrouter', 'grok', 'fireworks', 'together']
+        provider: Literal['openai', 'deepseek', 'azure', 'openrouter', 'grok', 'fireworks', 'together', 'heroku']
         | Provider[AsyncOpenAI] = 'openai',
         profile: ModelProfileSpec | None = None,
         system_prompt_role: OpenAISystemPromptRole | None = None,
@@ -308,7 +308,7 @@ class OpenAIModel(Model):
 
     def _process_response(self, response: chat.ChatCompletion) -> ModelResponse:
         """Process a non-streamed response, and prepare a message to return."""
-        timestamp = datetime.fromtimestamp(response.created, tz=timezone.utc)
+        timestamp = number_to_datetime(response.created)
         choice = response.choices[0]
         items: list[ModelResponsePart] = []
         vendor_details: dict[str, Any] | None = None
@@ -358,7 +358,7 @@ class OpenAIModel(Model):
         return OpenAIStreamedResponse(
             _model_name=self._model_name,
             _response=peekable_response,
-            _timestamp=datetime.fromtimestamp(first_chunk.created, tz=timezone.utc),
+            _timestamp=number_to_datetime(first_chunk.created),
         )
 
     def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[chat.ChatCompletionToolParam]:
@@ -593,7 +593,7 @@ class OpenAIResponsesModel(Model):
 
     def _process_response(self, response: responses.Response) -> ModelResponse:
         """Process a non-streamed response, and prepare a message to return."""
-        timestamp = datetime.fromtimestamp(response.created_at, tz=timezone.utc)
+        timestamp = number_to_datetime(response.created_at)
         items: list[ModelResponsePart] = []
         items.append(TextPart(response.output_text))
         for item in response.output:
@@ -614,7 +614,7 @@ class OpenAIResponsesModel(Model):
         return OpenAIResponsesStreamedResponse(
             _model_name=self._model_name,
             _response=peekable_response,
-            _timestamp=datetime.fromtimestamp(first_chunk.response.created_at, tz=timezone.utc),
+            _timestamp=number_to_datetime(first_chunk.response.created_at),
         )
 
     @overload

{pydantic_ai_slim-0.2.15 → pydantic_ai_slim-0.2.16}/pydantic_ai/providers/__init__.py

@@ -48,7 +48,7 @@ class Provider(ABC, Generic[InterfaceClient]):
         return None  # pragma: no cover
 
 
-def infer_provider(provider: str) -> Provider[Any]:
+def infer_provider(provider: str) -> Provider[Any]:  # noqa: C901
     """Infer the provider from the provider name."""
     if provider == 'openai':
         from .openai import OpenAIProvider
@@ -107,5 +107,9 @@ def infer_provider(provider: str) -> Provider[Any]:
         from .together import TogetherProvider
 
         return TogetherProvider()
+    elif provider == 'heroku':
+        from .heroku import HerokuProvider
+
+        return HerokuProvider()
     else:  # pragma: no cover
         raise ValueError(f'Unknown provider: {provider}')

{pydantic_ai_slim-0.2.15 → pydantic_ai_slim-0.2.16}/pydantic_ai/providers/google_vertex.py

@@ -50,7 +50,7 @@ class GoogleVertexProvider(Provider[httpx.AsyncClient]):
         return self._client
 
     def model_profile(self, model_name: str) -> ModelProfile | None:
-        return google_model_profile(model_name)
+        return google_model_profile(model_name)  # pragma: lax no cover
 
     @overload
     def __init__(

pydantic_ai_slim-0.2.16/pydantic_ai/providers/heroku.py

@@ -0,0 +1,82 @@
+from __future__ import annotations as _annotations
+
+import os
+from typing import overload
+
+from httpx import AsyncClient as AsyncHTTPClient
+from openai import AsyncOpenAI
+
+from pydantic_ai.exceptions import UserError
+from pydantic_ai.models import cached_async_http_client
+from pydantic_ai.profiles import ModelProfile
+from pydantic_ai.profiles.openai import OpenAIJsonSchemaTransformer, OpenAIModelProfile
+from pydantic_ai.providers import Provider
+
+try:
+    from openai import AsyncOpenAI
+except ImportError as _import_error:  # pragma: no cover
+    raise ImportError(
+        'Please install the `openai` package to use the Heroku provider, '
+        'you can use the `openai` optional group — `pip install "pydantic-ai-slim[openai]"`'
+    ) from _import_error
+
+
+class HerokuProvider(Provider[AsyncOpenAI]):
+    """Provider for Heroku API."""
+
+    @property
+    def name(self) -> str:
+        return 'heroku'
+
+    @property
+    def base_url(self) -> str:
+        return str(self.client.base_url)
+
+    @property
+    def client(self) -> AsyncOpenAI:
+        return self._client
+
+    def model_profile(self, model_name: str) -> ModelProfile | None:
+        # As the Heroku API is OpenAI-compatible, let's assume we also need OpenAIJsonSchemaTransformer.
+        return OpenAIModelProfile(json_schema_transformer=OpenAIJsonSchemaTransformer)
+
+    @overload
+    def __init__(self) -> None: ...
+
+    @overload
+    def __init__(self, *, api_key: str) -> None: ...
+
+    @overload
+    def __init__(self, *, api_key: str, http_client: AsyncHTTPClient) -> None: ...
+
+    @overload
+    def __init__(self, *, openai_client: AsyncOpenAI | None = None) -> None: ...
+
+    def __init__(
+        self,
+        *,
+        base_url: str | None = None,
+        api_key: str | None = None,
+        openai_client: AsyncOpenAI | None = None,
+        http_client: AsyncHTTPClient | None = None,
+    ) -> None:
+        if openai_client is not None:
+            assert http_client is None, 'Cannot provide both `openai_client` and `http_client`'
+            assert api_key is None, 'Cannot provide both `openai_client` and `api_key`'
+            self._client = openai_client
+        else:
+            api_key = api_key or os.environ.get('HEROKU_INFERENCE_KEY')
+            if not api_key:
+                raise UserError(
+                    'Set the `HEROKU_INFERENCE_KEY` environment variable or pass it via `HerokuProvider(api_key=...)`'
+                    'to use the Heroku provider.'
+                )
+
+            base_url = base_url or os.environ.get('HEROKU_INFERENCE_URL', 'https://us.inference.heroku.com')
+            base_url = base_url.rstrip('/') + '/v1'
+
+            if http_client is not None:
+                self._client = AsyncOpenAI(api_key=api_key, http_client=http_client, base_url=base_url)
+            else:
+                http_client = cached_async_http_client(provider='heroku')
+                self._client = AsyncOpenAI(api_key=api_key, http_client=http_client, base_url=base_url)

{pydantic_ai_slim-0.2.15 → pydantic_ai_slim-0.2.16}/pydantic_ai/settings.py

@@ -139,6 +139,7 @@ class ModelSettings(TypedDict, total=False):
     * Mistral
     * Groq
     * Cohere
+    * Google
     """
 
     extra_headers: dict[str, str]

{pydantic_ai_slim-0.2.15 → pydantic_ai_slim-0.2.16}/pydantic_ai/tools.py

@@ -1,5 +1,6 @@
 from __future__ import annotations as _annotations
 
+import asyncio
 import dataclasses
 import json
 from collections.abc import Awaitable, Sequence
@@ -9,8 +10,8 @@ from typing import TYPE_CHECKING, Any, Callable, Generic, Literal, Union
 from opentelemetry.trace import Tracer
 from pydantic import ValidationError
 from pydantic.json_schema import GenerateJsonSchema, JsonSchemaValue
-from pydantic_core import core_schema
-from typing_extensions import Concatenate, ParamSpec, TypeAlias, TypeVar
+from pydantic_core import SchemaValidator, core_schema
+from typing_extensions import Concatenate, ParamSpec, Self, TypeAlias, TypeVar
 
 from . import _function_schema, _utils, messages as _messages
 from .exceptions import ModelRetry, UnexpectedModelBehavior
@@ -63,7 +64,9 @@ class RunContext(Generic[AgentDepsT]):
     """The current step in the run."""
 
     def replace_with(
-        self, retry: int | None = None, tool_name: str | None | _utils.Unset = _utils.UNSET
+        self,
+        retry: int | None = None,
+        tool_name: str | None | _utils.Unset = _utils.UNSET,
     ) -> RunContext[AgentDepsT]:
         # Create a new `RunContext` a new `retry` value and `tool_name`.
         kwargs = {}
@@ -215,8 +218,10 @@ class Tool(Generic[AgentDepsT]):
     This schema may be modified by the `prepare` function or by the Model class prior to including it in an API request.
     """
 
-    # TODO: Move this state off the Tool class, which is otherwise stateless.
-    #   This should be tracked inside a specific agent run, not the tool.
+    # TODO: Consider moving this current_retry state to live on something other than the tool.
+    #   We've worked around this for now by copying instances of the tool when creating new runs,
+    #   but this is a bit fragile. Moving the tool retry counts to live on the agent run state would likely clean things
+    #   up, though is also likely a larger effort to refactor.
     current_retry: int = field(default=0, init=False)
 
     def __init__(
@@ -304,6 +309,45 @@ class Tool(Generic[AgentDepsT]):
         self.require_parameter_descriptions = require_parameter_descriptions
         self.strict = strict
 
+    @classmethod
+    def from_schema(
+        cls,
+        function: Callable[..., Any],
+        name: str,
+        description: str,
+        json_schema: JsonSchemaValue,
+    ) -> Self:
+        """Creates a Pydantic tool from a function and a JSON schema.
+
+        Args:
+            function: The function to call.
+                This will be called with keywords only, and no validation of
+                the arguments will be performed.
+            name: The unique name of the tool that clearly communicates its purpose
+            description: Used to tell the model how/when/why to use the tool.
+                You can provide few-shot examples as a part of the description.
+            json_schema: The schema for the function arguments
+
+        Returns:
+            A Pydantic tool that calls the function
+        """
+        function_schema = _function_schema.FunctionSchema(
+            function=function,
+            description=description,
+            validator=SchemaValidator(schema=core_schema.any_schema()),
+            json_schema=json_schema,
+            takes_ctx=False,
+            is_async=asyncio.iscoroutinefunction(function),
+        )
+
+        return cls(
+            function,
+            takes_ctx=False,
+            name=name,
+            description=description,
+            function_schema=function_schema,
+        )
+
     async def prepare_tool_def(self, ctx: RunContext[AgentDepsT]) -> ToolDefinition | None:
         """Get the tool definition.
 
@@ -325,7 +369,10 @@ class Tool(Generic[AgentDepsT]):
             return tool_def
 
     async def run(
-        self, message: _messages.ToolCallPart, run_context: RunContext[AgentDepsT], tracer: Tracer
+        self,
+        message: _messages.ToolCallPart,
+        run_context: RunContext[AgentDepsT],
+        tracer: Tracer,
     ) -> _messages.ToolReturnPart | _messages.RetryPromptPart:
         """Run the tool function asynchronously.