pydantic-ai-slim 0.0.6a4__py3-none-any.whl → 0.0.8__py3-none-any.whl

pydantic_ai/__init__.py

@@ -1,8 +1,8 @@
 from importlib.metadata import version
 
 from .agent import Agent
-from .dependencies import CallContext
+from .dependencies import RunContext
 from .exceptions import ModelRetry, UnexpectedModelBehavior, UserError
 
-__all__ = 'Agent', 'CallContext', 'ModelRetry', 'UnexpectedModelBehavior', 'UserError', '__version__'
+__all__ = 'Agent', 'RunContext', 'ModelRetry', 'UnexpectedModelBehavior', 'UserError', '__version__'
 __version__ = version('pydantic_ai_slim')

pydantic_ai/_pydantic.py

@@ -20,8 +20,8 @@ from ._griffe import doc_descriptions
 from ._utils import ObjectJsonSchema, check_object_json_schema, is_model_like
 
 if TYPE_CHECKING:
-    from . import _retriever
-    from .dependencies import AgentDeps, RetrieverParams
+    from . import _tool
+    from .dependencies import AgentDeps, ToolParams
 
 
 __all__ = 'function_schema', 'LazyTypeAdapter'
@@ -39,8 +39,8 @@ class FunctionSchema(TypedDict):
     var_positional_field: str | None
 
 
-def function_schema(either_function: _retriever.RetrieverEitherFunc[AgentDeps, RetrieverParams]) -> FunctionSchema:  # noqa: C901
-    """Build a Pydantic validator and JSON schema from a retriever function.
+def function_schema(either_function: _tool.ToolEitherFunc[AgentDeps, ToolParams]) -> FunctionSchema:  # noqa: C901
+    """Build a Pydantic validator and JSON schema from a tool function.
 
     Args:
         either_function: The function to build a validator and JSON schema for.
@@ -78,13 +78,13 @@ def function_schema(either_function: _retriever.RetrieverEitherFunc[AgentDeps, R
 
             if index == 0 and takes_ctx:
                 if not _is_call_ctx(annotation):
-                    errors.append('First argument must be a CallContext instance when using `.retriever`')
+                    errors.append('First argument must be a RunContext instance when using `.tool`')
                 continue
             elif not takes_ctx and _is_call_ctx(annotation):
-                errors.append('CallContext instance can only be used with `.retriever`')
+                errors.append('RunContext instance can only be used with `.tool`')
                 continue
             elif index != 0 and _is_call_ctx(annotation):
-                errors.append('CallContext instance can only be used as the first argument')
+                errors.append('RunContext instance can only be used as the first argument')
                 continue
 
         field_name = p.name
@@ -191,10 +191,10 @@ def _build_schema(
 
 
 def _is_call_ctx(annotation: Any) -> bool:
-    from .dependencies import CallContext
+    from .dependencies import RunContext
 
-    return annotation is CallContext or (
-        _typing_extra.is_generic_alias(annotation) and get_origin(annotation) is CallContext
+    return annotation is RunContext or (
+        _typing_extra.is_generic_alias(annotation) and get_origin(annotation) is RunContext
     )
 
 

pydantic_ai/_result.py

@@ -11,7 +11,7 @@ from pydantic import TypeAdapter, ValidationError
 from typing_extensions import Self, TypeAliasType, TypedDict
 
 from . import _utils, messages
-from .dependencies import AgentDeps, CallContext, ResultValidatorFunc
+from .dependencies import AgentDeps, ResultValidatorFunc, RunContext
 from .exceptions import ModelRetry
 from .messages import ModelStructuredResponse, ToolCall
 from .result import ResultData
@@ -42,7 +42,7 @@ class ResultValidator(Generic[AgentDeps, ResultData]):
             Result of either the validated result data (ok) or a retry message (Err).
         """
         if self._takes_ctx:
-            args = CallContext(deps, retry, tool_call.tool_name if tool_call else None), result
+            args = RunContext(deps, retry, tool_call.tool_name if tool_call else None), result
         else:
             args = (result,)
 
@@ -75,7 +75,7 @@ class ToolRetryError(Exception):
 class ResultSchema(Generic[ResultData]):
     """Model the final response from an agent run.
 
-    Similar to `Retriever` but for the final result of running an agent.
+    Similar to `Tool` but for the final result of running an agent.
     """
 
     tools: dict[str, ResultTool[ResultData]]
@@ -191,7 +191,7 @@ class ResultTool(Generic[ResultData]):
                 )
             else:
                 result = self.type_adapter.validate_python(
-                    tool_call.args.args_object, experimental_allow_partial=pyd_allow_partial
+                    tool_call.args.args_dict, experimental_allow_partial=pyd_allow_partial
                 )
         except ValidationError as e:
             if wrap_validation_errors:

pydantic_ai/_system_prompt.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass, field
 from typing import Any, Callable, Generic, cast
 
 from . import _utils
-from .dependencies import AgentDeps, CallContext, SystemPromptFunc
+from .dependencies import AgentDeps, RunContext, SystemPromptFunc
 
 
 @dataclass
@@ -21,7 +21,7 @@ class SystemPromptRunner(Generic[AgentDeps]):
 
     async def run(self, deps: AgentDeps) -> str:
         if self._takes_ctx:
-            args = (CallContext(deps, 0, None),)
+            args = (RunContext(deps, 0, None),)
         else:
             args = ()
 

pydantic_ai/{_retriever.py → _tool.py}

@@ -9,22 +9,20 @@ from pydantic import ValidationError
 from pydantic_core import SchemaValidator
 
 from . import _pydantic, _utils, messages
-from .dependencies import AgentDeps, CallContext, RetrieverContextFunc, RetrieverParams, RetrieverPlainFunc
+from .dependencies import AgentDeps, RunContext, ToolContextFunc, ToolParams, ToolPlainFunc
 from .exceptions import ModelRetry, UnexpectedModelBehavior
 
-# Usage `RetrieverEitherFunc[AgentDependencies, P]`
-RetrieverEitherFunc = _utils.Either[
-    RetrieverContextFunc[AgentDeps, RetrieverParams], RetrieverPlainFunc[RetrieverParams]
-]
+# Usage `ToolEitherFunc[AgentDependencies, P]`
+ToolEitherFunc = _utils.Either[ToolContextFunc[AgentDeps, ToolParams], ToolPlainFunc[ToolParams]]
 
 
 @dataclass(init=False)
-class Retriever(Generic[AgentDeps, RetrieverParams]):
-    """A retriever function for an agent."""
+class Tool(Generic[AgentDeps, ToolParams]):
+    """A tool function for an agent."""
 
     name: str
     description: str
-    function: RetrieverEitherFunc[AgentDeps, RetrieverParams] = field(repr=False)
+    function: ToolEitherFunc[AgentDeps, ToolParams] = field(repr=False)
     is_async: bool
     single_arg_name: str | None
     positional_fields: list[str]
@@ -35,8 +33,8 @@ class Retriever(Generic[AgentDeps, RetrieverParams]):
     _current_retry: int = 0
     outer_typed_dict_key: str | None = None
 
-    def __init__(self, function: RetrieverEitherFunc[AgentDeps, RetrieverParams], retries: int):
-        """Build a Retriever dataclass from a function."""
+    def __init__(self, function: ToolEitherFunc[AgentDeps, ToolParams], retries: int):
+        """Build a Tool dataclass from a function."""
         self.function = function
         # noinspection PyTypeChecker
         f = _pydantic.function_schema(function)
@@ -56,12 +54,12 @@ class Retriever(Generic[AgentDeps, RetrieverParams]):
         self._current_retry = 0
 
     async def run(self, deps: AgentDeps, message: messages.ToolCall) -> messages.Message:
-        """Run the retriever function asynchronously."""
+        """Run the tool function asynchronously."""
         try:
             if isinstance(message.args, messages.ArgsJson):
                 args_dict = self.validator.validate_json(message.args.args_json)
             else:
-                args_dict = self.validator.validate_python(message.args.args_object)
+                args_dict = self.validator.validate_python(message.args.args_dict)
         except ValidationError as e:
             return self._on_error(e, message)
 
@@ -89,7 +87,7 @@ class Retriever(Generic[AgentDeps, RetrieverParams]):
         if self.single_arg_name:
             args_dict = {self.single_arg_name: args_dict}
 
-        args = [CallContext(deps, self._current_retry, message.tool_name)] if self.function.is_left() else []
+        args = [RunContext(deps, self._current_retry, message.tool_name)] if self.function.is_left() else []
         for positional_field in self.positional_fields:
             args.append(args_dict.pop(positional_field))
         if self.var_positional_field:
@@ -100,8 +98,8 @@ class Retriever(Generic[AgentDeps, RetrieverParams]):
     def _on_error(self, exc: ValidationError | ModelRetry, call_message: messages.ToolCall) -> messages.RetryPrompt:
         self._current_retry += 1
         if self._current_retry > self.max_retries:
-            # TODO custom error with details of the retriever
-            raise UnexpectedModelBehavior(f'Retriever exceeded max retries count of {self.max_retries}') from exc
+            # TODO custom error with details of the tool
+            raise UnexpectedModelBehavior(f'Tool exceeded max retries count of {self.max_retries}') from exc
         else:
             if isinstance(exc, ValidationError):
                 content = exc.errors(include_url=False)

pydantic_ai/_utils.py

@@ -12,7 +12,7 @@ from typing import Any, Callable, Generic, TypeVar, Union, cast, overload
 
 from pydantic import BaseModel
 from pydantic.json_schema import JsonSchemaValue
-from typing_extensions import ParamSpec, TypeAlias, is_typeddict
+from typing_extensions import ParamSpec, TypeAlias, TypeGuard, is_typeddict
 
 _P = ParamSpec('_P')
 _R = TypeVar('_R')
@@ -66,10 +66,6 @@ Option: TypeAlias = Union[Some[T], None]
 """Analogous to Rust's `Option` type, usage: `Option[Thing]` is equivalent to `Some[Thing] | None`."""
 
 
-Left = TypeVar('Left')
-Right = TypeVar('Right')
-
-
 class Unset:
     """A singleton to represent an unset value."""
 
@@ -79,6 +75,14 @@ class Unset:
 UNSET = Unset()
 
 
+def is_set(t_or_unset: T | Unset) -> TypeGuard[T]:
+    return t_or_unset is not UNSET
+
+
+Left = TypeVar('Left')
+Right = TypeVar('Right')
+
+
 class Either(Generic[Left, Right]):
     """Two member Union that records which member was set, this is analogous to Rust enums with two variants.