pydantic-ai-slim 0.0.42__tar.gz → 0.0.44__tar.gz

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.42
+Version: 0.0.44
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -29,7 +29,7 @@ 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.0.42
+Requires-Dist: pydantic-graph==0.0.44
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: anthropic
@@ -53,7 +53,7 @@ Requires-Dist: mcp>=1.4.1; (python_version >= '3.10') and extra == 'mcp'
 Provides-Extra: mistral
 Requires-Dist: mistralai>=1.2.5; extra == 'mistral'
 Provides-Extra: openai
-Requires-Dist: openai>=1.65.1; extra == 'openai'
+Requires-Dist: openai>=1.67.0; extra == 'openai'
 Provides-Extra: tavily
 Requires-Dist: tavily-python>=0.5.0; extra == 'tavily'
 Provides-Extra: vertexai

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/_cli.py

@@ -31,13 +31,13 @@ try:
 except ImportError as _import_error:
     raise ImportError(
         'Please install `rich`, `prompt-toolkit` and `argcomplete` to use the PydanticAI CLI, '
-        "you can use the `cli` optional group — `pip install 'pydantic-ai-slim[cli]'`"
+        'you can use the `cli` optional group — `pip install "pydantic-ai-slim[cli]"`'
     ) from _import_error
 
 from pydantic_ai.agent import Agent
 from pydantic_ai.messages import ModelMessage, PartDeltaEvent, TextPartDelta
 
-__version__ = version('pydantic-ai')
+__version__ = version('pydantic-ai-slim')
 
 
 class SimpleCodeBlock(CodeBlock):

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/_griffe.py

@@ -22,8 +22,16 @@ def doc_descriptions(
 ) -> tuple[str, dict[str, str]]:
     """Extract the function description and parameter descriptions from a function's docstring.
 
+    The function parses the docstring using the specified format (or infers it if 'auto')
+    and extracts both the main description and parameter descriptions. If a returns section
+    is present in the docstring, the main description will be formatted as XML.
+
     Returns:
-        A tuple of (main function description, parameter descriptions).
+        A tuple containing:
+        - str: Main description string, which may be either:
+            * Plain text if no returns section is present
+            * XML-formatted if returns section exists, including <summary> and <returns> tags
+        - dict[str, str]: Dictionary mapping parameter names to their descriptions
     """
     doc = func.__doc__
     if doc is None:
@@ -33,7 +41,14 @@ def doc_descriptions(
     parent = cast(GriffeObject, sig)
 
     docstring_style = _infer_docstring_style(doc) if docstring_format == 'auto' else docstring_format
-    docstring = Docstring(doc, lineno=1, parser=docstring_style, parent=parent)
+    docstring = Docstring(
+        doc,
+        lineno=1,
+        parser=docstring_style,
+        parent=parent,
+        # https://mkdocstrings.github.io/griffe/reference/docstrings/#google-options
+        parser_options={'returns_named_value': False, 'returns_multiple_items': False},
+    )
     with _disable_griffe_logging():
         sections = docstring.parse()
 
@@ -45,6 +60,18 @@ def doc_descriptions(
     if main := next((p for p in sections if p.kind == DocstringSectionKind.text), None):
         main_desc = main.value
 
+    if return_ := next((p for p in sections if p.kind == DocstringSectionKind.returns), None):
+        return_statement = return_.value[0]
+        return_desc = return_statement.description
+        return_type = return_statement.annotation
+        type_tag = f'<type>{return_type}</type>\n' if return_type else ''
+        return_xml = f'<returns>\n{type_tag}<description>{return_desc}</description>\n</returns>'
+
+        if main_desc:
+            main_desc = f'<summary>{main_desc}</summary>\n{return_xml}'
+        else:
+            main_desc = return_xml
+
     return main_desc, params
 
 

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/agent.py

@@ -13,7 +13,7 @@ from pydantic.json_schema import GenerateJsonSchema
 from typing_extensions import TypeGuard, TypeVar, deprecated
 
 from pydantic_graph import End, Graph, GraphRun, GraphRunContext
-from pydantic_graph._utils import get_event_loop
+from pydantic_graph._utils import run_until_complete
 
 from . import (
     _agent_graph,
@@ -195,6 +195,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
                 If this isn't set, then the last value set by
                 [`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.
         """
         if model is None or defer_model_check:
             self.model = model
@@ -445,7 +446,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         usage_limits = usage_limits or _usage.UsageLimits()
 
         if isinstance(model_used, InstrumentedModel):
-            tracer = model_used.options.tracer
+            tracer = model_used.settings.tracer
         else:
             tracer = NoOpTracer()
         agent_name = self.name or 'agent'
@@ -566,7 +567,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         """
         if infer_name and self.name is None:
             self._infer_name(inspect.currentframe())
-        return get_event_loop().run_until_complete(
+        return run_until_complete(
             self.run(
                 user_prompt,
                 result_type=result_type,

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/common_tools/duckduckgo.py

@@ -13,7 +13,7 @@ try:
 except ImportError as _import_error:
     raise ImportError(
         'Please install `duckduckgo-search` to use the DuckDuckGo search tool, '
-        "you can use the `duckduckgo` optional group — `pip install 'pydantic-ai-slim[duckduckgo]'`"
+        'you can use the `duckduckgo` optional group — `pip install "pydantic-ai-slim[duckduckgo]"`'
     ) from _import_error
 
 __all__ = ('duckduckgo_search_tool',)

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/common_tools/tavily.py

@@ -11,7 +11,7 @@ try:
 except ImportError as _import_error:
     raise ImportError(
         'Please install `tavily-python` to use the Tavily search tool, '
-        "you can use the `tavily` optional group — `pip install 'pydantic-ai-slim[tavily]'`"
+        'you can use the `tavily` optional group — `pip install "pydantic-ai-slim[tavily]"`'
     ) from _import_error
 
 __all__ = ('tavily_search_tool',)

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/mcp.py

@@ -21,7 +21,7 @@ try:
 except ImportError as _import_error:
     raise ImportError(
         'Please install the `mcp` package to use the MCP server, '
-        "you can use the `mcp` optional group — `pip install 'pydantic-ai-slim[mcp]'`"
+        'you can use the `mcp` optional group — `pip install "pydantic-ai-slim[mcp]"`'
     ) from _import_error
 
 __all__ = 'MCPServer', 'MCPServerStdio', 'MCPServerHTTP'

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/messages.py

@@ -26,6 +26,9 @@ class SystemPromptPart:
     content: str
     """The content of the prompt."""
 
+    timestamp: datetime = field(default_factory=_now_utc)
+    """The timestamp of the prompt."""
+
     dynamic_ref: str | None = None
     """The ref of the dynamic system prompt function that generated this part.
 

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/models/__init__.py

@@ -12,7 +12,7 @@ from contextlib import asynccontextmanager, contextmanager
 from dataclasses import dataclass, field
 from datetime import datetime
 from functools import cache
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 import httpx
 from typing_extensions import Literal
@@ -133,8 +133,6 @@ KnownModelName = Literal[
     'gpt-4-turbo-2024-04-09',
     'gpt-4-turbo-preview',
     'gpt-4-vision-preview',
-    'gpt-4.5-preview',
-    'gpt-4.5-preview-2025-02-27',
     'gpt-4o',
     'gpt-4o-2024-05-13',
     'gpt-4o-2024-08-06',
@@ -146,6 +144,10 @@ KnownModelName = Literal[
     'gpt-4o-mini-2024-07-18',
     'gpt-4o-mini-audio-preview',
     'gpt-4o-mini-audio-preview-2024-12-17',
+    'gpt-4o-mini-search-preview',
+    'gpt-4o-mini-search-preview-2025-03-11',
+    'gpt-4o-search-preview',
+    'gpt-4o-search-preview-2025-03-11',
     'groq:gemma2-9b-it',
     'groq:llama-3.1-8b-instant',
     'groq:llama-3.2-11b-vision-preview',
@@ -189,8 +191,6 @@ KnownModelName = Literal[
     'openai:gpt-4-turbo-2024-04-09',
     'openai:gpt-4-turbo-preview',
     'openai:gpt-4-vision-preview',
-    'openai:gpt-4.5-preview',
-    'openai:gpt-4.5-preview-2025-02-27',
     'openai:gpt-4o',
     'openai:gpt-4o-2024-05-13',
     'openai:gpt-4o-2024-08-06',
@@ -202,6 +202,10 @@ KnownModelName = Literal[
     'openai:gpt-4o-mini-2024-07-18',
     'openai:gpt-4o-mini-audio-preview',
     'openai:gpt-4o-mini-audio-preview-2024-12-17',
+    'openai:gpt-4o-mini-search-preview',
+    'openai:gpt-4o-mini-search-preview-2025-03-11',
+    'openai:gpt-4o-search-preview',
+    'openai:gpt-4o-search-preview-2025-03-11',
     'openai:o1',
     'openai:o1-2024-12-17',
     'openai:o1-mini',
@@ -379,6 +383,7 @@ def infer_model(model: Model | KnownModelName) -> Model:
 
     try:
         provider, model_name = model.split(':', maxsplit=1)
+        provider = cast(str, provider)
     except ValueError:
         model_name = model
         # TODO(Marcelo): We should deprecate this way.
@@ -397,8 +402,7 @@ def infer_model(model: Model | KnownModelName) -> Model:
     if provider == 'cohere':
         from .cohere import CohereModel
 
-        # TODO(Marcelo): Missing provider API.
-        return CohereModel(model_name)
+        return CohereModel(model_name, provider=provider)
     elif provider in ('deepseek', 'openai'):
         from .openai import OpenAIModel
 
@@ -410,22 +414,19 @@ def infer_model(model: Model | KnownModelName) -> Model:
     elif provider == 'groq':
         from .groq import GroqModel
 
-        # TODO(Marcelo): Missing provider API.
-        return GroqModel(model_name)
+        return GroqModel(model_name, provider=provider)
     elif provider == 'mistral':
         from .mistral import MistralModel
 
-        # TODO(Marcelo): Missing provider API.
-        return MistralModel(model_name)
+        return MistralModel(model_name, provider=provider)
     elif provider == 'anthropic':
         from .anthropic import AnthropicModel
 
-        # TODO(Marcelo): Missing provider API.
-        return AnthropicModel(model_name)
+        return AnthropicModel(model_name, provider=provider)
     elif provider == 'bedrock':
         from .bedrock import BedrockConverseModel
 
-        return BedrockConverseModel(model_name)
+        return BedrockConverseModel(model_name, provider=provider)
     else:
         raise UserError(f'Unknown model: {model}')
 

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/models/anthropic.py

@@ -65,7 +65,7 @@ try:
 except ImportError as _import_error:
     raise ImportError(
         'Please install `anthropic` to use the Anthropic model, '
-        "you can use the `anthropic` optional group — `pip install 'pydantic-ai-slim[anthropic]'`"
+        'you can use the `anthropic` optional group — `pip install "pydantic-ai-slim[anthropic]"`'
     ) from _import_error
 
 LatestAnthropicModelNames = Literal[

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/models/cohere.py

@@ -3,11 +3,11 @@ from __future__ import annotations as _annotations
 from collections.abc import Iterable
 from dataclasses import dataclass, field
 from itertools import chain
-from typing import Literal, Union, cast
+from typing import Literal, Union, cast, overload
 
 from cohere import TextAssistantMessageContentItem
 from httpx import AsyncClient as AsyncHTTPClient
-from typing_extensions import assert_never
+from typing_extensions import assert_never, deprecated
 
 from .. import ModelHTTPError, result
 from .._utils import guard_tool_call_id as _guard_tool_call_id
@@ -23,11 +23,13 @@ from ..messages import (
     ToolReturnPart,
     UserPromptPart,
 )
+from ..providers import Provider, infer_provider
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
 from . import (
     Model,
     ModelRequestParameters,
+    cached_async_http_client,
     check_allow_model_requests,
 )
 
@@ -50,7 +52,7 @@ try:
 except ImportError as _import_error:
     raise ImportError(
         'Please install `cohere` to use the Cohere model, '
-        "you can use the `cohere` optional group — `pip install 'pydantic-ai-slim[cohere]'`"
+        'you can use the `cohere` optional group — `pip install "pydantic-ai-slim[cohere]"`'
     ) from _import_error
 
 LatestCohereModelNames = Literal[
@@ -100,10 +102,34 @@ class CohereModel(Model):
     _model_name: CohereModelName = field(repr=False)
     _system: str = field(default='cohere', repr=False)
 
+    @overload
     def __init__(
         self,
         model_name: CohereModelName,
         *,
+        provider: Literal['cohere'] | Provider[AsyncClientV2] = 'cohere',
+        api_key: None = None,
+        cohere_client: None = None,
+        http_client: None = None,
+    ) -> None: ...
+
+    @deprecated('Use the `provider` parameter instead of `api_key`, `cohere_client`, and `http_client`.')
+    @overload
+    def __init__(
+        self,
+        model_name: CohereModelName,
+        *,
+        provider: None = None,
+        api_key: str | None = None,
+        cohere_client: AsyncClientV2 | None = None,
+        http_client: AsyncHTTPClient | None = None,
+    ) -> None: ...
+
+    def __init__(
+        self,
+        model_name: CohereModelName,
+        *,
+        provider: Literal['cohere'] | Provider[AsyncClientV2] | None = None,
         api_key: str | None = None,
         cohere_client: AsyncClientV2 | None = None,
         http_client: AsyncHTTPClient | None = None,
@@ -113,6 +139,9 @@ class CohereModel(Model):
         Args:
             model_name: The name of the Cohere model to use. List of model names
                 available [here](https://docs.cohere.com/docs/models#command).
+            provider: The provider to use for authentication and API access. Can be either the string
+                'cohere' or an instance of `Provider[AsyncClientV2]`. If not provided, a new provider will be
+                created using the other parameters.
             api_key: The API key to use for authentication, if not provided, the
                 `CO_API_KEY` environment variable will be used if available.
             cohere_client: An existing Cohere async client to use. If provided,
@@ -120,12 +149,17 @@ class CohereModel(Model):
             http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
         """
         self._model_name: CohereModelName = model_name
-        if cohere_client is not None:
+
+        if provider is not None:
+            if isinstance(provider, str):
+                provider = infer_provider(provider)
+            self.client = provider.client
+        elif cohere_client is not None:
             assert http_client is None, 'Cannot provide both `cohere_client` and `http_client`'
             assert api_key is None, 'Cannot provide both `cohere_client` and `api_key`'
             self.client = cohere_client
         else:
-            self.client = AsyncClientV2(api_key=api_key, httpx_client=http_client)
+            self.client = AsyncClientV2(api_key=api_key, httpx_client=http_client or cached_async_http_client())
 
     @property
     def base_url(self) -> str:

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/models/groq.py

@@ -41,7 +41,7 @@ try:
 except ImportError as _import_error:
     raise ImportError(
         'Please install `groq` to use the Groq model, '
-        "you can use the `groq` optional group — `pip install 'pydantic-ai-slim[groq]'`"
+        'you can use the `groq` optional group — `pip install "pydantic-ai-slim[groq]"`'
     ) from _import_error
 
 

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/models/instrumented.py

@@ -52,7 +52,9 @@ class InstrumentationSettings:
 
     - `Agent(instrument=...)`
     - [`Agent.instrument_all()`][pydantic_ai.agent.Agent.instrument_all]
-    - `InstrumentedModel`
+    - [`InstrumentedModel`][pydantic_ai.models.instrumented.InstrumentedModel]
+
+    See the [Debugging and Monitoring guide](https://ai.pydantic.dev/logfire/) for more info.
     """
 
     tracer: Tracer = field(repr=False)
@@ -94,9 +96,13 @@ GEN_AI_REQUEST_MODEL_ATTRIBUTE = 'gen_ai.request.model'
 
 @dataclass
 class InstrumentedModel(WrapperModel):
-    """Model which is instrumented with OpenTelemetry."""
+    """Model which wraps another model so that requests are instrumented with OpenTelemetry.
+
+    See the [Debugging and Monitoring guide](https://ai.pydantic.dev/logfire/) for more info.
+    """
 
-    options: InstrumentationSettings
+    settings: InstrumentationSettings
+    """Configuration for instrumenting requests."""
 
     def __init__(
         self,
@@ -104,7 +110,7 @@ class InstrumentedModel(WrapperModel):
         options: InstrumentationSettings | None = None,
     ) -> None:
         super().__init__(wrapped)
-        self.options = options or InstrumentationSettings()
+        self.settings = options or InstrumentationSettings()
 
     async def request(
         self,
@@ -112,7 +118,7 @@ class InstrumentedModel(WrapperModel):
         model_settings: ModelSettings | None,
         model_request_parameters: ModelRequestParameters,
     ) -> tuple[ModelResponse, Usage]:
-        with self._instrument(messages, model_settings) as finish:
+        with self._instrument(messages, model_settings, model_request_parameters) as finish:
             response, usage = await super().request(messages, model_settings, model_request_parameters)
             finish(response, usage)
             return response, usage
@@ -124,7 +130,7 @@ class InstrumentedModel(WrapperModel):
         model_settings: ModelSettings | None,
         model_request_parameters: ModelRequestParameters,
     ) -> AsyncIterator[StreamedResponse]:
-        with self._instrument(messages, model_settings) as finish:
+        with self._instrument(messages, model_settings, model_request_parameters) as finish:
             response_stream: StreamedResponse | None = None
             try:
                 async with super().request_stream(
@@ -140,6 +146,7 @@ class InstrumentedModel(WrapperModel):
         self,
         messages: list[ModelMessage],
         model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
     ) -> Iterator[Callable[[ModelResponse, Usage], None]]:
         operation = 'chat'
         span_name = f'{operation} {self.model_name}'
@@ -149,6 +156,13 @@ class InstrumentedModel(WrapperModel):
         attributes: dict[str, AttributeValue] = {
             'gen_ai.operation.name': operation,
             **self.model_attributes(self.wrapped),
+            'model_request_parameters': json.dumps(InstrumentedModel.serialize_any(model_request_parameters)),
+            'logfire.json_schema': json.dumps(
+                {
+                    'type': 'object',
+                    'properties': {'model_request_parameters': {'type': 'object'}},
+                }
+            ),
         }
 
         if model_settings:
@@ -156,7 +170,7 @@ class InstrumentedModel(WrapperModel):
                 if isinstance(value := model_settings.get(key), (float, int)):
                     attributes[f'gen_ai.request.{key}'] = value
 
-        with self.options.tracer.start_as_current_span(span_name, attributes=attributes) as span:
+        with self.settings.tracer.start_as_current_span(span_name, attributes=attributes) as span:
 
             def finish(response: ModelResponse, usage: Usage):
                 if not span.is_recording():
@@ -190,9 +204,9 @@ class InstrumentedModel(WrapperModel):
             yield finish
 
     def _emit_events(self, span: Span, events: list[Event]) -> None:
-        if self.options.event_mode == 'logs':
+        if self.settings.event_mode == 'logs':
             for event in events:
-                self.options.event_logger.emit(event)
+                self.settings.event_logger.emit(event)
         else:
             attr_name = 'events'
             span.set_attributes(
@@ -201,7 +215,10 @@ class InstrumentedModel(WrapperModel):
                     'logfire.json_schema': json.dumps(
                         {
                             'type': 'object',
-                            'properties': {attr_name: {'type': 'array'}},
+                            'properties': {
+                                attr_name: {'type': 'array'},
+                                'model_request_parameters': {'type': 'object'},
+                            },
                         }
                     ),
                 }

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/models/mistral.py

@@ -75,7 +75,7 @@ try:
 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]'`"
+        'you can use the `mistral` optional group — `pip install "pydantic-ai-slim[mistral]"`'
     ) from e
 
 LatestMistralModelNames = Literal[

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/models/openai.py

@@ -57,7 +57,7 @@ try:
 except ImportError as _import_error:
     raise ImportError(
         'Please install `openai` to use the OpenAI model, '
-        "you can use the `openai` optional group — `pip install 'pydantic-ai-slim[openai]'`"
+        'you can use the `openai` optional group — `pip install "pydantic-ai-slim[openai]"`'
     ) from _import_error
 
 OpenAIModelName = Union[str, ChatModel]
@@ -99,7 +99,7 @@ class OpenAIModel(Model):
     system_prompt_role: OpenAISystemPromptRole | None = field(default=None)
 
     _model_name: OpenAIModelName = field(repr=False)
-    _system: str = field(repr=False)
+    _system: str = field(default='openai', repr=False)
 
     @overload
     def __init__(
@@ -108,7 +108,6 @@ class OpenAIModel(Model):
         *,
         provider: Literal['openai', 'deepseek', 'azure'] | Provider[AsyncOpenAI] = 'openai',
         system_prompt_role: OpenAISystemPromptRole | None = None,
-        system: str = 'openai',
     ) -> None: ...
 
     @deprecated('Use the `provider` parameter instead of `base_url`, `api_key`, `openai_client` and `http_client`.')
@@ -123,7 +122,6 @@ class OpenAIModel(Model):
         openai_client: AsyncOpenAI | None = None,
         http_client: AsyncHTTPClient | None = None,
         system_prompt_role: OpenAISystemPromptRole | None = None,
-        system: str = 'openai',
     ) -> None: ...
 
     def __init__(
@@ -136,7 +134,6 @@ class OpenAIModel(Model):
         openai_client: AsyncOpenAI | None = None,
         http_client: AsyncHTTPClient | None = None,
         system_prompt_role: OpenAISystemPromptRole | None = None,
-        system: str = 'openai',
     ):
         """Initialize an OpenAI model.
 
@@ -155,8 +152,6 @@ class OpenAIModel(Model):
             http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
             system_prompt_role: The role to use for the system prompt message. If not provided, defaults to `'system'`.
                 In the future, this may be inferred from the model name.
-            system: The model provider used, defaults to `openai`. This is for observability purposes, you must
-                customize the `base_url` and `api_key` to use a different provider.
         """
         self._model_name = model_name
 
@@ -185,7 +180,6 @@ class OpenAIModel(Model):
             else:
                 self.client = AsyncOpenAI(base_url=base_url, api_key=api_key, http_client=cached_async_http_client())
         self.system_prompt_role = system_prompt_role
-        self._system = system
 
     @property
     def base_url(self) -> str:
@@ -279,7 +273,7 @@ class OpenAIModel(Model):
                 tool_choice=tool_choice or NOT_GIVEN,
                 stream=stream,
                 stream_options={'include_usage': True} if stream else NOT_GIVEN,
-                max_tokens=model_settings.get('max_tokens', NOT_GIVEN),
+                max_completion_tokens=model_settings.get('max_tokens', NOT_GIVEN),
                 temperature=model_settings.get('temperature', NOT_GIVEN),
                 top_p=model_settings.get('top_p', NOT_GIVEN),
                 timeout=model_settings.get('timeout', NOT_GIVEN),

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/models/vertexai.py

@@ -27,7 +27,7 @@ try:
 except ImportError as _import_error:
     raise ImportError(
         'Please install `google-auth` to use the VertexAI model, '
-        "you can use the `vertexai` optional group — `pip install 'pydantic-ai-slim[vertexai]'`"
+        'you can use the `vertexai` optional group — `pip install "pydantic-ai-slim[vertexai]"`'
     ) from _import_error
 
 VERTEX_AI_URL_TEMPLATE = (

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/models/wrapper.py

@@ -13,9 +13,13 @@ from . import KnownModelName, Model, ModelRequestParameters, StreamedResponse, i
 
 @dataclass(init=False)
 class WrapperModel(Model):
-    """Model which wraps another model."""
+    """Model which wraps another model.
+
+    Does nothing on its own, used as a base class.
+    """
 
     wrapped: Model
+    """The underlying model being wrapped."""
 
     def __init__(self, wrapped: Model | KnownModelName):
         self.wrapped = infer_model(wrapped)

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/providers/__init__.py

@@ -77,5 +77,9 @@ def infer_provider(provider: str) -> Provider[Any]:
         from .mistral import MistralProvider
 
         return MistralProvider()
+    elif provider == 'cohere':
+        from .cohere import CohereProvider
+
+        return CohereProvider()
     else:  # pragma: no cover
         raise ValueError(f'Unknown provider: {provider}')

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/providers/anthropic.py

@@ -12,7 +12,7 @@ try:
 except ImportError as _import_error:  # pragma: no cover
     raise ImportError(
         'Please install the `anthropic` package to use the Anthropic provider, '
-        "you can use the `anthropic` optional group — `pip install 'pydantic-ai-slim[anthropic]'`"
+        'you can use the `anthropic` optional group — `pip install "pydantic-ai-slim[anthropic]"`'
     ) from _import_error
 
 

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/providers/azure.py

@@ -13,7 +13,7 @@ try:
 except ImportError as _import_error:  # pragma: no cover
     raise ImportError(
         'Please install the `openai` package to use the Azure provider, '
-        "you can use the `openai` optional group — `pip install 'pydantic-ai-slim[openai]'`"
+        'you can use the `openai` optional group — `pip install "pydantic-ai-slim[openai]"`'
     ) from _import_error
 
 

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/providers/bedrock.py

@@ -11,7 +11,7 @@ try:
 except ImportError as _import_error:
     raise ImportError(
         'Please install the `boto3` package to use the Bedrock provider, '
-        "you can use the `bedrock` optional group — `pip install 'pydantic-ai-slim[bedrock]'`"
+        'you can use the `bedrock` optional group — `pip install "pydantic-ai-slim[bedrock]"`'
     ) from _import_error
 
 

pydantic_ai_slim-0.0.44/pydantic_ai/providers/cohere.py

@@ -0,0 +1,72 @@
+from __future__ import annotations as _annotations
+
+import os
+
+from httpx import AsyncClient as AsyncHTTPClient
+
+from pydantic_ai.models import cached_async_http_client
+
+try:
+    from cohere import AsyncClientV2
+except ImportError as _import_error:  # pragma: no cover
+    raise ImportError(
+        'Please install the `cohere` package to use the Cohere provider, '
+        'you can use the `cohere` optional group — `pip install "pydantic-ai-slim[cohere]"`'
+    ) from _import_error
+
+
+from . import Provider
+
+
+class CohereProvider(Provider[AsyncClientV2]):
+    """Provider for Cohere API."""
+
+    @property
+    def name(self) -> str:
+        return 'cohere'
+
+    @property
+    def base_url(self) -> str:
+        client_wrapper = self.client._client_wrapper  # type: ignore
+        return str(client_wrapper.get_base_url())
+
+    @property
+    def client(self) -> AsyncClientV2:
+        return self._client
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        cohere_client: AsyncClientV2 | None = None,
+        http_client: AsyncHTTPClient | None = None,
+    ) -> None:
+        """Create a new Cohere provider.
+
+        Args:
+            api_key: The API key to use for authentication, if not provided, the `CO_API_KEY` environment variable
+                will be used if available.
+            cohere_client: An existing
+                [AsyncClientV2](https://github.com/cohere-ai/cohere-python)
+                client to use. If provided, `api_key` and `http_client` must be `None`.
+            http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
+        """
+        if cohere_client is not None:
+            assert http_client is None, 'Cannot provide both `cohere_client` and `http_client`'
+            assert api_key is None, 'Cannot provide both `cohere_client` and `api_key`'
+            self._client = cohere_client
+        else:
+            api_key = api_key or os.environ.get('CO_API_KEY')
+            if api_key is None:
+                raise ValueError(
+                    'Set the `CO_API_KEY` environment variable or pass it via `CohereProvider(api_key=...)`'
+                    'to use the Cohere provider.'
+                )
+
+            base_url = os.environ.get('CO_BASE_URL')
+            if http_client is not None:
+                self._client = AsyncClientV2(api_key=api_key, httpx_client=http_client, base_url=base_url)
+            else:
+                self._client = AsyncClientV2(
+                    api_key=api_key, httpx_client=cached_async_http_client(), base_url=base_url
+                )

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/providers/deepseek.py

@@ -13,7 +13,7 @@ try:
 except ImportError as _import_error:  # pragma: no cover
     raise ImportError(
         'Please install the `openai` package to use the DeepSeek provider, '
-        "you can use the `openai` optional group — `pip install 'pydantic-ai-slim[openai]'`"
+        'you can use the `openai` optional group — `pip install "pydantic-ai-slim[openai]"`'
     ) from _import_error
 
 from . import Provider

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/providers/google_vertex.py

@@ -2,7 +2,6 @@ from __future__ import annotations as _annotations
 
 import functools
 from collections.abc import AsyncGenerator, Mapping
-from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Literal, overload
 
@@ -22,15 +21,12 @@ try:
 except ImportError as _import_error:
     raise ImportError(
         'Please install the `google-auth` package to use the Google Vertex AI provider, '
-        "you can use the `vertexai` optional group — `pip install 'pydantic-ai-slim[vertexai]'`"
+        'you can use the `vertexai` optional group — `pip install "pydantic-ai-slim[vertexai]"`'
     ) from _import_error
 
 
 __all__ = ('GoogleVertexProvider',)
 
-# default expiry is 3600 seconds
-MAX_TOKEN_AGE = timedelta(seconds=3000)
-
 
 class GoogleVertexProvider(Provider[httpx.AsyncClient]):
     """Provider for Vertex AI API."""
@@ -131,19 +127,21 @@ class _VertexAIAuth(httpx.Auth):
         self.region = region
 
         self.credentials = None
-        self.token_created: datetime | None = None
 
     async def async_auth_flow(self, request: httpx.Request) -> AsyncGenerator[httpx.Request, httpx.Response]:
         if self.credentials is None:
             self.credentials = await self._get_credentials()
-        if self.credentials.token is None or self._token_expired():  # type: ignore[reportUnknownMemberType]
-            await anyio.to_thread.run_sync(self._refresh_token)
-            self.token_created = datetime.now()
+        if self.credentials.token is None:  # type: ignore[reportUnknownMemberType]
+            await self._refresh_token()
         request.headers['Authorization'] = f'Bearer {self.credentials.token}'  # type: ignore[reportUnknownMemberType]
-
         # NOTE: This workaround is in place because we might get the project_id from the credentials.
         request.url = httpx.URL(str(request.url).replace('projects/None', f'projects/{self.project_id}'))
-        yield request
+        response = yield request
+
+        if response.status_code == 401:
+            await self._refresh_token()
+            request.headers['Authorization'] = f'Bearer {self.credentials.token}'  # type: ignore[reportUnknownMemberType]
+            yield request
 
     async def _get_credentials(self) -> BaseCredentials | ServiceAccountCredentials:
         if self.service_account_file is not None:
@@ -166,15 +164,9 @@ class _VertexAIAuth(httpx.Auth):
             self.project_id = creds_project_id
         return creds
 
-    def _token_expired(self) -> bool:
-        if self.token_created is None:
-            return True
-        else:
-            return (datetime.now() - self.token_created) > MAX_TOKEN_AGE
-
-    def _refresh_token(self) -> str:  # pragma: no cover
+    async def _refresh_token(self) -> str:  # pragma: no cover
         assert self.credentials is not None
-        self.credentials.refresh(Request())  # type: ignore[reportUnknownMemberType]
+        await anyio.to_thread.run_sync(self.credentials.refresh, Request())  # type: ignore[reportUnknownMemberType]
         assert isinstance(self.credentials.token, str), f'Expected token to be a string, got {self.credentials.token}'  # type: ignore[reportUnknownMemberType]
         return self.credentials.token
 

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/providers/groq.py

@@ -12,7 +12,7 @@ try:
 except ImportError as _import_error:  # pragma: no cover
     raise ImportError(
         'Please install the `groq` package to use the Groq provider, '
-        "you can use the `groq` optional group — `pip install 'pydantic-ai-slim[groq]'`"
+        'you can use the `groq` optional group — `pip install "pydantic-ai-slim[groq]"`'
     ) from _import_error
 
 

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/providers/mistral.py

@@ -12,7 +12,7 @@ try:
 except ImportError as e:  # pragma: no cover
     raise ImportError(
         'Please install the `mistral` package to use the Mistral provider, '
-        "you can use the `mistral` optional group — `pip install 'pydantic-ai-slim[mistral]'`"
+        'you can use the `mistral` optional group — `pip install "pydantic-ai-slim[mistral]"`'
     ) from e
 
 

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pydantic_ai/providers/openai.py

@@ -11,7 +11,7 @@ try:
 except ImportError as _import_error:  # pragma: no cover
     raise ImportError(
         'Please install the `openai` package to use the OpenAI provider, '
-        "you can use the `openai` optional group — `pip install 'pydantic-ai-slim[openai]'`"
+        'you can use the `openai` optional group — `pip install "pydantic-ai-slim[openai]"`'
     ) from _import_error
 
 

{pydantic_ai_slim-0.0.42 → pydantic_ai_slim-0.0.44}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pydantic-ai-slim"
-version = "0.0.42"
+version = "0.0.44"
 description = "Agent Framework / shim to use Pydantic with LLMs, slim package"
 authors = [{ name = "Samuel Colvin", email = "samuel@pydantic.dev" }]
 license = "MIT"
@@ -36,7 +36,7 @@ dependencies = [
     "griffe>=1.3.2",
     "httpx>=0.27",
     "pydantic>=2.10",
-    "pydantic-graph==0.0.42",
+    "pydantic-graph==0.0.44",
     "exceptiongroup; python_version < '3.11'",
     "opentelemetry-api>=1.28.0",
     "typing-inspection>=0.4.0",
@@ -46,7 +46,7 @@ dependencies = [
 # WARNING if you add optional groups, please update docs/install.md
 logfire = ["logfire>=2.3"]
 # Models
-openai = ["openai>=1.65.1"]
+openai = ["openai>=1.67.0"]
 cohere = ["cohere>=5.13.11"]
 vertexai = ["google-auth>=2.36.0", "requests>=2.32.3"]
 anthropic = ["anthropic>=0.49.0"]