pydantic-ai-slim 0.2.18__tar.gz → 0.2.19__tar.gz

{pydantic_ai_slim-0.2.18 → pydantic_ai_slim-0.2.19}/PKG-INFO

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

{pydantic_ai_slim-0.2.18 → pydantic_ai_slim-0.2.19}/pydantic_ai/_agent_graph.py

@@ -12,18 +12,11 @@ from typing import TYPE_CHECKING, Any, Callable, Generic, Literal, Union, cast
 from opentelemetry.trace import Tracer
 from typing_extensions import TypeGuard, TypeVar, assert_never
 
+from pydantic_ai._utils import is_async_callable, run_in_executor
 from pydantic_graph import BaseNode, Graph, GraphRunContext
 from pydantic_graph.nodes import End, NodeRunEndT
 
-from . import (
-    _output,
-    _system_prompt,
-    exceptions,
-    messages as _messages,
-    models,
-    result,
-    usage as _usage,
-)
+from . import _output, _system_prompt, exceptions, messages as _messages, models, result, usage as _usage
 from .result import OutputDataT
 from .settings import ModelSettings, merge_model_settings
 from .tools import RunContext, Tool, ToolDefinition, ToolsPrepareFunc
@@ -39,6 +32,7 @@ __all__ = (
     'CallToolsNode',
     'build_run_context',
     'capture_run_messages',
+    'HistoryProcessor',
 )
 
 
@@ -54,6 +48,11 @@ EndStrategy = Literal['early', 'exhaustive']
 DepsT = TypeVar('DepsT')
 OutputT = TypeVar('OutputT')
 
+_HistoryProcessorSync = Callable[[list[_messages.ModelMessage]], list[_messages.ModelMessage]]
+_HistoryProcessorAsync = Callable[[list[_messages.ModelMessage]], Awaitable[list[_messages.ModelMessage]]]
+HistoryProcessor = Union[_HistoryProcessorSync, _HistoryProcessorAsync]
+"""A function that processes a list of model messages and returns a list of model messages."""
+
 
 @dataclasses.dataclass
 class GraphAgentState:
@@ -93,6 +92,8 @@ class GraphAgentDeps(Generic[DepsT, OutputDataT]):
     output_schema: _output.OutputSchema[OutputDataT] | None
     output_validators: list[_output.OutputValidator[DepsT, OutputDataT]]
 
+    history_processors: Sequence[HistoryProcessor]
+
     function_tools: dict[str, Tool[DepsT]] = dataclasses.field(repr=False)
     mcp_servers: Sequence[MCPServer] = dataclasses.field(repr=False)
     default_retries: int
@@ -327,8 +328,9 @@ class ModelRequestNode(AgentNode[DepsT, NodeRunEndT]):
 
         model_settings, model_request_parameters = await self._prepare_request(ctx)
         model_request_parameters = ctx.deps.model.customize_request_parameters(model_request_parameters)
+        message_history = await _process_message_history(ctx.state.message_history, ctx.deps.history_processors)
         async with ctx.deps.model.request_stream(
-            ctx.state.message_history, model_settings, model_request_parameters
+            message_history, model_settings, model_request_parameters
         ) as streamed_response:
             self._did_stream = True
             ctx.state.usage.requests += 1
@@ -350,9 +352,8 @@ class ModelRequestNode(AgentNode[DepsT, NodeRunEndT]):
 
         model_settings, model_request_parameters = await self._prepare_request(ctx)
         model_request_parameters = ctx.deps.model.customize_request_parameters(model_request_parameters)
-        model_response = await ctx.deps.model.request(
-            ctx.state.message_history, model_settings, model_request_parameters
-        )
+        message_history = await _process_message_history(ctx.state.message_history, ctx.deps.history_processors)
+        model_response = await ctx.deps.model.request(message_history, model_settings, model_request_parameters)
         ctx.state.usage.incr(_usage.Usage())
 
         return self._finish_handling(ctx, model_response)
@@ -647,6 +648,7 @@ async def process_function_tools(  # noqa C901
             # if tool_name is in output_schema, it means we found a output tool but an error occurred in
             # validation, we don't add another part here
             if output_tool_name is not None:
+                yield _messages.FunctionToolCallEvent(call)
                 if found_used_output_tool:
                     content = 'Output tool not used - a final result was already processed.'
                 else:
@@ -657,9 +659,14 @@ async def process_function_tools(  # noqa C901
                     content=content,
                     tool_call_id=call.tool_call_id,
                 )
+                yield _messages.FunctionToolResultEvent(part, tool_call_id=call.tool_call_id)
                 output_parts.append(part)
         else:
-            output_parts.append(_unknown_tool(call.tool_name, call.tool_call_id, ctx))
+            yield _messages.FunctionToolCallEvent(call)
+
+            part = _unknown_tool(call.tool_name, call.tool_call_id, ctx)
+            yield _messages.FunctionToolResultEvent(part, tool_call_id=call.tool_call_id)
+            output_parts.append(part)
 
     if not calls_to_run:
         return
@@ -865,3 +872,16 @@ def build_agent_graph(
         auto_instrument=False,
     )
     return graph
+
+
+async def _process_message_history(
+    messages: list[_messages.ModelMessage],
+    processors: Sequence[HistoryProcessor],
+) -> list[_messages.ModelMessage]:
+    """Process message history through a sequence of processors."""
+    for processor in processors:
+        if is_async_callable(processor):
+            messages = await processor(messages)
+        else:
+            messages = await run_in_executor(processor, messages)
+    return messages

{pydantic_ai_slim-0.2.18 → pydantic_ai_slim-0.2.19}/pydantic_ai/_function_schema.py

@@ -5,7 +5,6 @@ This module has to use numerous internal Pydantic APIs and is therefore brittle
 
 from __future__ import annotations as _annotations
 
-import inspect
 from collections.abc import Awaitable
 from dataclasses import dataclass, field
 from inspect import Parameter, signature
@@ -23,7 +22,7 @@ from typing_extensions import get_origin
 from pydantic_ai.tools import RunContext
 
 from ._griffe import doc_descriptions
-from ._utils import check_object_json_schema, is_model_like, run_in_executor
+from ._utils import check_object_json_schema, is_async_callable, is_model_like, run_in_executor
 
 if TYPE_CHECKING:
     from .tools import DocstringFormat, ObjectJsonSchema
@@ -214,7 +213,7 @@ def function_schema(  # noqa: C901
         positional_fields=positional_fields,
         var_positional_field=var_positional_field,
         takes_ctx=takes_ctx,
-        is_async=inspect.iscoroutinefunction(function),
+        is_async=is_async_callable(function),
         function=function,
     )
 

{pydantic_ai_slim-0.2.18 → pydantic_ai_slim-0.2.19}/pydantic_ai/_output.py

@@ -60,7 +60,7 @@ class OutputValidator(Generic[AgentDepsT, OutputDataT_inv]):
 
     def __post_init__(self):
         self._takes_ctx = len(inspect.signature(self.function).parameters) > 1
-        self._is_async = inspect.iscoroutinefunction(self.function)
+        self._is_async = _utils.is_async_callable(self.function)
 
     async def validate(
         self,

{pydantic_ai_slim-0.2.18 → pydantic_ai_slim-0.2.19}/pydantic_ai/_system_prompt.py

@@ -18,7 +18,7 @@ class SystemPromptRunner(Generic[AgentDepsT]):
 
     def __post_init__(self):
         self._takes_ctx = len(inspect.signature(self.function).parameters) > 0
-        self._is_async = inspect.iscoroutinefunction(self.function)
+        self._is_async = _utils.is_async_callable(self.function)
 
     async def run(self, run_context: RunContext[AgentDepsT]) -> str:
         if self._takes_ctx:

{pydantic_ai_slim-0.2.18 → pydantic_ai_slim-0.2.19}/pydantic_ai/_utils.py

@@ -1,20 +1,22 @@
 from __future__ import annotations as _annotations
 
 import asyncio
+import functools
+import inspect
 import time
 import uuid
-from collections.abc import AsyncIterable, AsyncIterator, Iterator
+from collections.abc import AsyncIterable, AsyncIterator, Awaitable, Iterator
 from contextlib import asynccontextmanager, suppress
 from dataclasses import dataclass, fields, is_dataclass
 from datetime import datetime, timezone
 from functools import partial
 from types import GenericAlias
-from typing import TYPE_CHECKING, Any, Callable, Generic, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Callable, Generic, TypeVar, Union, overload
 
 from anyio.to_thread import run_sync
 from pydantic import BaseModel, TypeAdapter
 from pydantic.json_schema import JsonSchemaValue
-from typing_extensions import ParamSpec, TypeAlias, TypeGuard, is_typeddict
+from typing_extensions import ParamSpec, TypeAlias, TypeGuard, TypeIs, is_typeddict
 
 from pydantic_graph._utils import AbstractSpan
 
@@ -302,3 +304,26 @@ def dataclasses_no_defaults_repr(self: Any) -> str:
 
 def number_to_datetime(x: int | float) -> datetime:
     return TypeAdapter(datetime).validate_python(x)
+
+
+AwaitableCallable = Callable[..., Awaitable[T]]
+
+
+@overload
+def is_async_callable(obj: AwaitableCallable[T]) -> TypeIs[AwaitableCallable[T]]: ...
+
+
+@overload
+def is_async_callable(obj: Any) -> TypeIs[AwaitableCallable[Any]]: ...
+
+
+def is_async_callable(obj: Any) -> Any:
+    """Correctly check if a callable is async.
+
+    This function was copied from Starlette:
+    https://github.com/encode/starlette/blob/78da9b9e218ab289117df7d62aee200ed4c59617/starlette/_utils.py#L36-L40
+    """
+    while isinstance(obj, functools.partial):
+        obj = obj.func
+
+    return inspect.iscoroutinefunction(obj) or (callable(obj) and inspect.iscoroutinefunction(obj.__call__))  # type: ignore

{pydantic_ai_slim-0.2.18 → pydantic_ai_slim-0.2.19}/pydantic_ai/agent.py

@@ -28,6 +28,7 @@ from . import (
     result,
     usage as _usage,
 )
+from ._agent_graph import HistoryProcessor
 from .models.instrumented import InstrumentationSettings, InstrumentedModel, instrument_model
 from .result import FinalResult, OutputDataT, StreamedRunResult
 from .settings import ModelSettings, merge_model_settings
@@ -179,6 +180,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
         defer_model_check: bool = False,
         end_strategy: EndStrategy = 'early',
         instrument: InstrumentationSettings | bool | None = None,
+        history_processors: Sequence[HistoryProcessor] | None = None,
     ) -> None: ...
 
     @overload
@@ -208,6 +210,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
         defer_model_check: bool = False,
         end_strategy: EndStrategy = 'early',
         instrument: InstrumentationSettings | bool | None = None,
+        history_processors: Sequence[HistoryProcessor] | None = None,
     ) -> None: ...
 
     def __init__(
@@ -232,6 +235,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
         defer_model_check: bool = False,
         end_strategy: EndStrategy = 'early',
         instrument: InstrumentationSettings | bool | None = None,
+        history_processors: Sequence[HistoryProcessor] | None = None,
         **_deprecated_kwargs: Any,
     ):
         """Create an agent.
@@ -275,6 +279,9 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
                 [`Agent.instrument_all()`][pydantic_ai.Agent.instrument_all]
                 will be used, which defaults to False.
                 See the [Debugging and Monitoring guide](https://ai.pydantic.dev/logfire/) for more info.
+            history_processors: Optional list of callables to process the message history before sending it to the model.
+                Each processor takes a list of messages and returns a modified list of messages.
+                Processors can be sync or async and are applied in sequence.
         """
         if model is None or defer_model_check:
             self.model = model
@@ -343,6 +350,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
         self._max_result_retries = output_retries if output_retries is not None else retries
         self._mcp_servers = mcp_servers
         self._prepare_tools = prepare_tools
+        self.history_processors = history_processors or []
         for tool in tools:
             if isinstance(tool, Tool):
                 self._register_tool(tool)
@@ -669,10 +677,11 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
             if self._instructions is None and not self._instructions_functions:
                 return None
 
-            instructions = self._instructions or ''
+            instructions = [self._instructions] if self._instructions else []
             for instructions_runner in self._instructions_functions:
-                instructions += '\n' + await instructions_runner.run(run_context)
-            return instructions.strip()
+                instructions.append(await instructions_runner.run(run_context))
+            concatenated_instructions = '\n'.join(instruction for instruction in instructions if instruction)
+            return concatenated_instructions.strip() if concatenated_instructions else None
 
         # 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`.
@@ -689,6 +698,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
             end_strategy=self.end_strategy,
             output_schema=output_schema,
             output_validators=output_validators,
+            history_processors=self.history_processors,
             function_tools=run_function_tools,
             mcp_servers=self._mcp_servers,
             default_retries=self._default_retries,

{pydantic_ai_slim-0.2.18 → pydantic_ai_slim-0.2.19}/pydantic_ai/messages.py

@@ -1,7 +1,6 @@
 from __future__ import annotations as _annotations
 
 import base64
-import uuid
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
 from dataclasses import dataclass, field, replace
@@ -888,13 +887,13 @@ class FunctionToolCallEvent:
 
     part: ToolCallPart
     """The (function) tool call to make."""
-    call_id: str = field(init=False)
-    """An ID used for matching details about the call to its result. If present, defaults to the part's tool_call_id."""
     event_kind: Literal['function_tool_call'] = 'function_tool_call'
     """Event type identifier, used as a discriminator."""
 
-    def __post_init__(self):
-        self.call_id = self.part.tool_call_id or str(uuid.uuid4())
+    @property
+    def call_id(self) -> str:
+        """An ID used for matching details about the call to its result. If present, defaults to the part's tool_call_id."""
+        return self.part.tool_call_id
 
     __repr__ = _utils.dataclasses_no_defaults_repr
 

{pydantic_ai_slim-0.2.18 → pydantic_ai_slim-0.2.19}/pydantic_ai/models/anthropic.py

@@ -220,7 +220,7 @@ class AnthropicModel(Model):
             extra_headers = model_settings.get('extra_headers', {})
             extra_headers.setdefault('User-Agent', get_user_agent())
             return await self.client.beta.messages.create(
-                max_tokens=model_settings.get('max_tokens', 1024),
+                max_tokens=model_settings.get('max_tokens', 4096),
                 system=system_prompt or NOT_GIVEN,
                 messages=anthropic_messages,
                 model=self._model_name,

{pydantic_ai_slim-0.2.18 → pydantic_ai_slim-0.2.19}/pydantic_ai/models/gemini.py

@@ -723,9 +723,7 @@ class _GeminiFunction(TypedDict):
 
 def _function_from_abstract_tool(tool: ToolDefinition) -> _GeminiFunction:
     json_schema = tool.parameters_json_schema
-    f = _GeminiFunction(name=tool.name, description=tool.description)
-    if json_schema.get('properties'):
-        f['parameters'] = json_schema
+    f = _GeminiFunction(name=tool.name, description=tool.description, parameters=json_schema)
     return f
 
 

{pydantic_ai_slim-0.2.18 → pydantic_ai_slim-0.2.19}/pydantic_ai/models/google.py

@@ -469,9 +469,11 @@ def _process_response_from_parts(
 
 def _function_declaration_from_tool(tool: ToolDefinition) -> FunctionDeclarationDict:
     json_schema = tool.parameters_json_schema
-    f = FunctionDeclarationDict(name=tool.name, description=tool.description)
-    if json_schema.get('properties'):  # pragma: no branch
-        f['parameters'] = json_schema  # type: ignore
+    f = FunctionDeclarationDict(
+        name=tool.name,
+        description=tool.description,
+        parameters=json_schema,  # type: ignore
+    )
     return f
 
 

{pydantic_ai_slim-0.2.18 → pydantic_ai_slim-0.2.19}/pydantic_ai/providers/__init__.py

@@ -48,68 +48,74 @@ class Provider(ABC, Generic[InterfaceClient]):
         return None  # pragma: no cover
 
 
-def infer_provider(provider: str) -> Provider[Any]:  # noqa: C901
-    """Infer the provider from the provider name."""
+def infer_provider_class(provider: str) -> type[Provider[Any]]:  # noqa: C901
+    """Infers the provider class from the provider name."""
     if provider == 'openai':
         from .openai import OpenAIProvider
 
-        return OpenAIProvider()
+        return OpenAIProvider
     elif provider == 'deepseek':
         from .deepseek import DeepSeekProvider
 
-        return DeepSeekProvider()
+        return DeepSeekProvider
     elif provider == 'openrouter':
         from .openrouter import OpenRouterProvider
 
-        return OpenRouterProvider()
+        return OpenRouterProvider
     elif provider == 'azure':
         from .azure import AzureProvider
 
-        return AzureProvider()
+        return AzureProvider
     elif provider == 'google-vertex':
         from .google_vertex import GoogleVertexProvider
 
-        return GoogleVertexProvider()
+        return GoogleVertexProvider
     elif provider == 'google-gla':
         from .google_gla import GoogleGLAProvider
 
-        return GoogleGLAProvider()
+        return GoogleGLAProvider
     # NOTE: We don't test because there are many ways the `boto3.client` can retrieve the credentials.
     elif provider == 'bedrock':
         from .bedrock import BedrockProvider
 
-        return BedrockProvider()
+        return BedrockProvider
     elif provider == 'groq':
         from .groq import GroqProvider
 
-        return GroqProvider()
+        return GroqProvider
     elif provider == 'anthropic':
         from .anthropic import AnthropicProvider
 
-        return AnthropicProvider()
+        return AnthropicProvider
     elif provider == 'mistral':
         from .mistral import MistralProvider
 
-        return MistralProvider()
+        return MistralProvider
     elif provider == 'cohere':
         from .cohere import CohereProvider
 
-        return CohereProvider()
+        return CohereProvider
     elif provider == 'grok':
         from .grok import GrokProvider
 
-        return GrokProvider()
+        return GrokProvider
     elif provider == 'fireworks':
         from .fireworks import FireworksProvider
 
-        return FireworksProvider()
+        return FireworksProvider
     elif provider == 'together':
         from .together import TogetherProvider
 
-        return TogetherProvider()
+        return TogetherProvider
     elif provider == 'heroku':
         from .heroku import HerokuProvider
 
-        return HerokuProvider()
+        return HerokuProvider
     else:  # pragma: no cover
         raise ValueError(f'Unknown provider: {provider}')
+
+
+def infer_provider(provider: str) -> Provider[Any]:
+    """Infer the provider from the provider name."""
+    provider_class = infer_provider_class(provider)
+    return provider_class()

{pydantic_ai_slim-0.2.18 → pydantic_ai_slim-0.2.19}/pydantic_ai/tools.py

@@ -1,6 +1,5 @@
 from __future__ import annotations as _annotations
 
-import asyncio
 import dataclasses
 import json
 from collections.abc import Awaitable, Sequence
@@ -337,7 +336,7 @@ class Tool(Generic[AgentDepsT]):
             validator=SchemaValidator(schema=core_schema.any_schema()),
             json_schema=json_schema,
             takes_ctx=False,
-            is_async=asyncio.iscoroutinefunction(function),
+            is_async=_utils.is_async_callable(function),
         )
 
         return cls(