pydantic-ai-slim 0.7.4__py3-none-any.whl → 0.7.6__py3-none-any.whl

pydantic_ai/models/openai.py

@@ -82,8 +82,10 @@ except ImportError as _import_error:
 
 __all__ = (
     'OpenAIModel',
+    'OpenAIChatModel',
     'OpenAIResponsesModel',
     'OpenAIModelSettings',
+    'OpenAIChatModelSettings',
     'OpenAIResponsesModelSettings',
     'OpenAIModelName',
 )
@@ -101,7 +103,7 @@ allows this model to be used more easily with other model types (ie, Ollama, Dee
 """
 
 
-class OpenAIModelSettings(ModelSettings, total=False):
+class OpenAIChatModelSettings(ModelSettings, total=False):
     """Settings used for an OpenAI model request."""
 
     # ALL FIELDS MUST BE `openai_` PREFIXED SO YOU CAN MERGE THEM WITH OTHER MODELS.
@@ -139,7 +141,12 @@ class OpenAIModelSettings(ModelSettings, total=False):
     """
 
 
-class OpenAIResponsesModelSettings(OpenAIModelSettings, total=False):
+@deprecated('Use `OpenAIChatModelSettings` instead.')
+class OpenAIModelSettings(OpenAIChatModelSettings, total=False):
+    """Deprecated alias for `OpenAIChatModelSettings`."""
+
+
+class OpenAIResponsesModelSettings(OpenAIChatModelSettings, total=False):
     """Settings used for an OpenAI Responses model request.
 
     ALL FIELDS MUST BE `openai_` PREFIXED SO YOU CAN MERGE THEM WITH OTHER MODELS.
@@ -185,7 +192,7 @@ class OpenAIResponsesModelSettings(OpenAIModelSettings, total=False):
 
 
 @dataclass(init=False)
-class OpenAIModel(Model):
+class OpenAIChatModel(Model):
     """A model that uses the OpenAI API.
 
     Internally, this uses the [OpenAI Python client](https://github.com/openai/openai-python) to interact with the API.
@@ -204,18 +211,20 @@ class OpenAIModel(Model):
         model_name: OpenAIModelName,
         *,
         provider: Literal[
-            'openai',
-            'deepseek',
             'azure',
-            'openrouter',
-            'moonshotai',
-            'vercel',
-            'grok',
+            'deepseek',
+            'cerebras',
             'fireworks',
-            'together',
-            'heroku',
             'github',
+            'grok',
+            'heroku',
+            'moonshotai',
             'ollama',
+            'openai',
+            'openai-chat',
+            'openrouter',
+            'together',
+            'vercel',
         ]
         | Provider[AsyncOpenAI] = 'openai',
         profile: ModelProfileSpec | None = None,
@@ -229,18 +238,20 @@ class OpenAIModel(Model):
         model_name: OpenAIModelName,
         *,
         provider: Literal[
-            'openai',
-            'deepseek',
             'azure',
-            'openrouter',
-            'moonshotai',
-            'vercel',
-            'grok',
+            'deepseek',
+            'cerebras',
             'fireworks',
-            'together',
-            'heroku',
             'github',
+            'grok',
+            'heroku',
+            'moonshotai',
             'ollama',
+            'openai',
+            'openai-chat',
+            'openrouter',
+            'together',
+            'vercel',
         ]
         | Provider[AsyncOpenAI] = 'openai',
         profile: ModelProfileSpec | None = None,
@@ -253,18 +264,20 @@ class OpenAIModel(Model):
         model_name: OpenAIModelName,
         *,
         provider: Literal[
-            'openai',
-            'deepseek',
             'azure',
-            'openrouter',
-            'moonshotai',
-            'vercel',
-            'grok',
+            'deepseek',
+            'cerebras',
             'fireworks',
-            'together',
-            'heroku',
             'github',
+            'grok',
+            'heroku',
+            'moonshotai',
             'ollama',
+            'openai',
+            'openai-chat',
+            'openrouter',
+            'together',
+            'vercel',
         ]
         | Provider[AsyncOpenAI] = 'openai',
         profile: ModelProfileSpec | None = None,
@@ -322,7 +335,7 @@ class OpenAIModel(Model):
     ) -> ModelResponse:
         check_allow_model_requests()
         response = await self._completions_create(
-            messages, False, cast(OpenAIModelSettings, model_settings or {}), model_request_parameters
+            messages, False, cast(OpenAIChatModelSettings, model_settings or {}), model_request_parameters
         )
         model_response = self._process_response(response)
         return model_response
@@ -337,7 +350,7 @@ class OpenAIModel(Model):
     ) -> AsyncIterator[StreamedResponse]:
         check_allow_model_requests()
         response = await self._completions_create(
-            messages, True, cast(OpenAIModelSettings, model_settings or {}), model_request_parameters
+            messages, True, cast(OpenAIChatModelSettings, model_settings or {}), model_request_parameters
         )
         async with response:
             yield await self._process_streamed_response(response, model_request_parameters)
@@ -347,7 +360,7 @@ class OpenAIModel(Model):
         self,
         messages: list[ModelMessage],
         stream: Literal[True],
-        model_settings: OpenAIModelSettings,
+        model_settings: OpenAIChatModelSettings,
         model_request_parameters: ModelRequestParameters,
     ) -> AsyncStream[ChatCompletionChunk]: ...
 
@@ -356,7 +369,7 @@ class OpenAIModel(Model):
         self,
         messages: list[ModelMessage],
         stream: Literal[False],
-        model_settings: OpenAIModelSettings,
+        model_settings: OpenAIChatModelSettings,
         model_request_parameters: ModelRequestParameters,
     ) -> chat.ChatCompletion: ...
 
@@ -364,7 +377,7 @@ class OpenAIModel(Model):
         self,
         messages: list[ModelMessage],
         stream: bool,
-        model_settings: OpenAIModelSettings,
+        model_settings: OpenAIChatModelSettings,
         model_request_parameters: ModelRequestParameters,
     ) -> chat.ChatCompletion | AsyncStream[ChatCompletionChunk]:
         tools = self._get_tools(model_request_parameters)
@@ -392,10 +405,15 @@ class OpenAIModel(Model):
         ):  # pragma: no branch
             response_format = {'type': 'json_object'}
 
+        unsupported_model_settings = OpenAIModelProfile.from_profile(self.profile).openai_unsupported_model_settings
+        for setting in unsupported_model_settings:
+            model_settings.pop(setting, None)
+
+        # TODO(Marcelo): Deprecate this in favor of `openai_unsupported_model_settings`.
         sampling_settings = (
             model_settings
             if OpenAIModelProfile.from_profile(self.profile).openai_supports_sampling_settings
-            else OpenAIModelSettings()
+            else OpenAIChatModelSettings()
         )
 
         try:
@@ -500,6 +518,7 @@ class OpenAIModel(Model):
             timestamp=timestamp,
             provider_details=vendor_details,
             provider_request_id=response.id,
+            provider_name=self._provider.name,
         )
 
     async def _process_streamed_response(
@@ -519,6 +538,7 @@ class OpenAIModel(Model):
             _model_profile=self.profile,
             _response=peekable_response,
             _timestamp=number_to_datetime(first_chunk.created),
+            _provider_name=self._provider.name,
         )
 
     def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[chat.ChatCompletionToolParam]:
@@ -571,6 +591,8 @@ class OpenAIModel(Model):
                     # Note: model responses from this model should only have one text item, so the following
                     # shouldn't merge multiple texts into one unless you switch models between runs:
                     message_param['content'] = '\n\n'.join(texts)
+                else:
+                    message_param['content'] = None
                 if tool_calls:
                     message_param['tool_calls'] = tool_calls
                 openai_messages.append(message_param)
@@ -632,9 +654,7 @@ class OpenAIModel(Model):
                 )
             elif isinstance(part, RetryPromptPart):
                 if part.tool_name is None:
-                    yield chat.ChatCompletionUserMessageParam(  # pragma: no cover
-                        role='user', content=part.model_response()
-                    )
+                    yield chat.ChatCompletionUserMessageParam(role='user', content=part.model_response())
                 else:
                     yield chat.ChatCompletionToolMessageParam(
                         role='tool',
@@ -702,6 +722,16 @@ class OpenAIModel(Model):
         return chat.ChatCompletionUserMessageParam(role='user', content=content)
 
 
+@deprecated(
+    '`OpenAIModel` was renamed to `OpenAIChatModel` to clearly distinguish it from `OpenAIResponsesModel` which '
+    "uses OpenAI's newer Responses API. Use that unless you're using an OpenAI Chat Completions-compatible API, or "
+    "require a feature that the Responses API doesn't support yet like audio."
+)
+@dataclass(init=False)
+class OpenAIModel(OpenAIChatModel):
+    """Deprecated alias for `OpenAIChatModel`."""
+
+
 @dataclass(init=False)
 class OpenAIResponsesModel(Model):
     """A model that uses the OpenAI Responses API.
@@ -803,6 +833,7 @@ class OpenAIResponsesModel(Model):
             model_name=response.model,
             provider_request_id=response.id,
             timestamp=timestamp,
+            provider_name=self._provider.name,
         )
 
     async def _process_streamed_response(
@@ -822,6 +853,7 @@ class OpenAIResponsesModel(Model):
             _model_name=self._model_name,
             _response=peekable_response,
             _timestamp=number_to_datetime(first_chunk.response.created_at),
+            _provider_name=self._provider.name,
         )
 
     @overload
@@ -1137,6 +1169,7 @@ class OpenAIStreamedResponse(StreamedResponse):
     _model_profile: ModelProfile
     _response: AsyncIterable[ChatCompletionChunk]
     _timestamp: datetime
+    _provider_name: str
 
     async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
         async for chunk in self._response:
@@ -1180,6 +1213,11 @@ class OpenAIStreamedResponse(StreamedResponse):
         """Get the model name of the response."""
         return self._model_name
 
+    @property
+    def provider_name(self) -> str:
+        """Get the provider name."""
+        return self._provider_name
+
     @property
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""
@@ -1193,6 +1231,7 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
     _model_name: OpenAIModelName
     _response: AsyncIterable[responses.ResponseStreamEvent]
     _timestamp: datetime
+    _provider_name: str
 
     async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:  # noqa: C901
         async for chunk in self._response:
@@ -1313,6 +1352,11 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
         """Get the model name of the response."""
         return self._model_name
 
+    @property
+    def provider_name(self) -> str:
+        """Get the provider name."""
+        return self._provider_name
+
     @property
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""

pydantic_ai/models/test.py

@@ -131,6 +131,7 @@ class TestModel(Model):
             _model_name=self._model_name,
             _structured_response=model_response,
             _messages=messages,
+            _provider_name=self._system,
         )
 
     @property
@@ -263,6 +264,7 @@ class TestStreamedResponse(StreamedResponse):
     _model_name: str
     _structured_response: ModelResponse
     _messages: InitVar[Iterable[ModelMessage]]
+    _provider_name: str
     _timestamp: datetime = field(default_factory=_utils.now_utc, init=False)
 
     def __post_init__(self, _messages: Iterable[ModelMessage]):
@@ -305,6 +307,11 @@ class TestStreamedResponse(StreamedResponse):
         """Get the model name of the response."""
         return self._model_name
 
+    @property
+    def provider_name(self) -> str:
+        """Get the provider name."""
+        return self._provider_name
+
     @property
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""

pydantic_ai/profiles/__init__.py

@@ -52,7 +52,7 @@ class ModelProfile:
     This is a workaround for models that emit `<think>\n</think>\n\n` or an empty text part ahead of tool calls (e.g. Ollama + Qwen3),
     which we don't want to end up treating as a final result when using `run_stream` with `str` a valid `output_type`.
 
-    This is currently only used by `OpenAIModel`, `HuggingFaceModel`, and `GroqModel`.
+    This is currently only used by `OpenAIChatModel`, `HuggingFaceModel`, and `GroqModel`.
     """
 
     @classmethod

pydantic_ai/profiles/harmony.py

@@ -0,0 +1,13 @@
+from __future__ import annotations as _annotations
+
+from . import ModelProfile
+from .openai import OpenAIModelProfile, openai_model_profile
+
+
+def harmony_model_profile(model_name: str) -> ModelProfile | None:
+    """The model profile for the OpenAI Harmony Response format.
+
+    See <https://cookbook.openai.com/articles/openai-harmony> for more details.
+    """
+    profile = openai_model_profile(model_name)
+    return OpenAIModelProfile(openai_supports_tool_choice_required=False).update(profile)

pydantic_ai/profiles/openai.py

@@ -1,6 +1,7 @@
 from __future__ import annotations as _annotations
 
 import re
+from collections.abc import Sequence
 from dataclasses import dataclass
 from typing import Any, Literal
 
@@ -12,7 +13,7 @@ OpenAISystemPromptRole = Literal['system', 'developer', 'user']
 
 @dataclass
 class OpenAIModelProfile(ModelProfile):
-    """Profile for models used with OpenAIModel.
+    """Profile for models used with `OpenAIChatModel`.
 
     ALL FIELDS MUST BE `openai_` PREFIXED SO YOU CAN MERGE THEM WITH OTHER MODELS.
     """
@@ -20,9 +21,13 @@ class OpenAIModelProfile(ModelProfile):
     openai_supports_strict_tool_definition: bool = True
     """This can be set by a provider or user if the OpenAI-"compatible" API doesn't support strict tool definitions."""
 
+    # TODO(Marcelo): Deprecate this in favor of `openai_unsupported_model_settings`.
     openai_supports_sampling_settings: bool = True
     """Turn off to don't send sampling settings like `temperature` and `top_p` to models that don't support them, like OpenAI's o-series reasoning models."""
 
+    openai_unsupported_model_settings: Sequence[str] = ()
+    """A list of model settings that are not supported by the model."""
+
     # Some OpenAI-compatible providers (e.g. MoonshotAI) currently do **not** accept
     # `tool_choice="required"`.  This flag lets the calling model know whether it's
     # safe to pass that value along.  Default is `True` to preserve existing

pydantic_ai/profiles/qwen.py

@@ -1,10 +1,18 @@
 from __future__ import annotations as _annotations
 
+from ..profiles.openai import OpenAIModelProfile
 from . import InlineDefsJsonSchemaTransformer, ModelProfile
 
 
 def qwen_model_profile(model_name: str) -> ModelProfile | None:
     """Get the model profile for a Qwen model."""
+    if model_name.startswith('qwen-3-coder'):
+        return OpenAIModelProfile(
+            json_schema_transformer=InlineDefsJsonSchemaTransformer,
+            openai_supports_tool_choice_required=False,
+            openai_supports_strict_tool_definition=False,
+            ignore_streamed_leading_whitespace=True,
+        )
     return ModelProfile(
         json_schema_transformer=InlineDefsJsonSchemaTransformer,
         ignore_streamed_leading_whitespace=True,

pydantic_ai/providers/__init__.py

@@ -20,7 +20,7 @@ class Provider(ABC, Generic[InterfaceClient]):
 
     Each provider only supports a specific interface. A interface can be supported by multiple providers.
 
-    For example, the OpenAIModel interface can be supported by the OpenAIProvider and the DeepSeekProvider.
+    For example, the `OpenAIChatModel` interface can be supported by the `OpenAIProvider` and the `DeepSeekProvider`.
     """
 
     _client: InterfaceClient
@@ -95,6 +95,10 @@ def infer_provider_class(provider: str) -> type[Provider[Any]]:  # noqa: C901
         from .mistral import MistralProvider
 
         return MistralProvider
+    elif provider == 'cerebras':
+        from .cerebras import CerebrasProvider
+
+        return CerebrasProvider
     elif provider == 'cohere':
         from .cohere import CohereProvider
 

pydantic_ai/providers/anthropic.py

@@ -1,9 +1,10 @@
 from __future__ import annotations as _annotations
 
 import os
-from typing import overload
+from typing import Union, overload
 
 import httpx
+from typing_extensions import TypeAlias
 
 from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import cached_async_http_client
@@ -12,15 +13,18 @@ from pydantic_ai.profiles.anthropic import anthropic_model_profile
 from pydantic_ai.providers import Provider
 
 try:
-    from anthropic import AsyncAnthropic
-except ImportError as _import_error:  # pragma: no cover
+    from anthropic import AsyncAnthropic, AsyncAnthropicBedrock
+except ImportError as _import_error:
     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]"`'
     ) from _import_error
 
 
-class AnthropicProvider(Provider[AsyncAnthropic]):
+AsyncAnthropicClient: TypeAlias = Union[AsyncAnthropic, AsyncAnthropicBedrock]
+
+
+class AnthropicProvider(Provider[AsyncAnthropicClient]):
     """Provider for Anthropic API."""
 
     @property
@@ -32,14 +36,14 @@ class AnthropicProvider(Provider[AsyncAnthropic]):
         return str(self._client.base_url)
 
     @property
-    def client(self) -> AsyncAnthropic:
+    def client(self) -> AsyncAnthropicClient:
         return self._client
 
     def model_profile(self, model_name: str) -> ModelProfile | None:
         return anthropic_model_profile(model_name)
 
     @overload
-    def __init__(self, *, anthropic_client: AsyncAnthropic | None = None) -> None: ...
+    def __init__(self, *, anthropic_client: AsyncAnthropicClient | None = None) -> None: ...
 
     @overload
     def __init__(self, *, api_key: str | None = None, http_client: httpx.AsyncClient | None = None) -> None: ...
@@ -48,7 +52,7 @@ class AnthropicProvider(Provider[AsyncAnthropic]):
         self,
         *,
         api_key: str | None = None,
-        anthropic_client: AsyncAnthropic | None = None,
+        anthropic_client: AsyncAnthropicClient | None = None,
         http_client: httpx.AsyncClient | None = None,
     ) -> None:
         """Create a new Anthropic provider.
@@ -71,7 +75,6 @@ class AnthropicProvider(Provider[AsyncAnthropic]):
                     'Set the `ANTHROPIC_API_KEY` environment variable or pass it via `AnthropicProvider(api_key=...)`'
                     'to use the Anthropic provider.'
                 )
-
             if http_client is not None:
                 self._client = AsyncAnthropic(api_key=api_key, http_client=http_client)
             else:

pydantic_ai/providers/azure.py

@@ -65,7 +65,7 @@ class AzureProvider(Provider[AsyncOpenAI]):
 
                 profile = profile_func(model_name)
 
-                # As AzureProvider is always used with OpenAIModel, which used to unconditionally use OpenAIJsonSchemaTransformer,
+                # As AzureProvider is always used with OpenAIChatModel, which used to unconditionally use OpenAIJsonSchemaTransformer,
                 # we need to maintain that behavior unless json_schema_transformer is set explicitly
                 return OpenAIModelProfile(json_schema_transformer=OpenAIJsonSchemaTransformer).update(profile)
 

pydantic_ai/providers/cerebras.py

@@ -0,0 +1,96 @@
+from __future__ import annotations as _annotations
+
+import os
+from typing import overload
+
+import httpx
+
+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.harmony import harmony_model_profile
+from pydantic_ai.profiles.meta import meta_model_profile
+from pydantic_ai.profiles.openai import OpenAIJsonSchemaTransformer, OpenAIModelProfile
+from pydantic_ai.profiles.qwen import qwen_model_profile
+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 Cerebras provider, '
+        'you can use the `openai` optional group — `pip install "pydantic-ai-slim[openai]"`'
+    ) from _import_error
+
+
+class CerebrasProvider(Provider[AsyncOpenAI]):
+    """Provider for Cerebras API."""
+
+    @property
+    def name(self) -> str:
+        return 'cerebras'
+
+    @property
+    def base_url(self) -> str:
+        return 'https://api.cerebras.ai/v1'
+
+    @property
+    def client(self) -> AsyncOpenAI:
+        return self._client
+
+    def model_profile(self, model_name: str) -> ModelProfile | None:
+        prefix_to_profile = {'llama': meta_model_profile, 'qwen': qwen_model_profile, 'gpt-oss': harmony_model_profile}
+
+        profile = None
+        for prefix, profile_func in prefix_to_profile.items():
+            model_name = model_name.lower()
+            if model_name.startswith(prefix):
+                profile = profile_func(model_name)
+
+        # According to https://inference-docs.cerebras.ai/resources/openai#currently-unsupported-openai-features,
+        # Cerebras doesn't support some model settings.
+        unsupported_model_settings = (
+            'frequency_penalty',
+            'logit_bias',
+            'presence_penalty',
+            'parallel_tool_calls',
+            'service_tier',
+        )
+        return OpenAIModelProfile(
+            json_schema_transformer=OpenAIJsonSchemaTransformer,
+            openai_unsupported_model_settings=unsupported_model_settings,
+        ).update(profile)
+
+    @overload
+    def __init__(self) -> None: ...
+
+    @overload
+    def __init__(self, *, api_key: str) -> None: ...
+
+    @overload
+    def __init__(self, *, api_key: str, http_client: httpx.AsyncClient) -> None: ...
+
+    @overload
+    def __init__(self, *, openai_client: AsyncOpenAI | None = None) -> None: ...
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        openai_client: AsyncOpenAI | None = None,
+        http_client: httpx.AsyncClient | None = None,
+    ) -> None:
+        api_key = api_key or os.getenv('CEREBRAS_API_KEY')
+        if not api_key and openai_client is None:
+            raise UserError(
+                'Set the `CEREBRAS_API_KEY` environment variable or pass it via `CerebrasProvider(api_key=...)` '
+                'to use the Cerebras provider.'
+            )
+
+        if openai_client is not None:
+            self._client = openai_client
+        elif http_client is not None:
+            self._client = AsyncOpenAI(base_url=self.base_url, api_key=api_key, http_client=http_client)
+        else:
+            http_client = cached_async_http_client(provider='cerebras')
+            self._client = AsyncOpenAI(base_url=self.base_url, api_key=api_key, http_client=http_client)

pydantic_ai/providers/cohere.py

@@ -2,7 +2,7 @@ from __future__ import annotations as _annotations
 
 import os
 
-from httpx import AsyncClient as AsyncHTTPClient
+import httpx
 
 from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import cached_async_http_client
@@ -43,7 +43,7 @@ class CohereProvider(Provider[AsyncClientV2]):
         *,
         api_key: str | None = None,
         cohere_client: AsyncClientV2 | None = None,
-        http_client: AsyncHTTPClient | None = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> None:
         """Create a new Cohere provider.
 

pydantic_ai/providers/deepseek.py

@@ -3,7 +3,7 @@ from __future__ import annotations as _annotations
 import os
 from typing import overload
 
-from httpx import AsyncClient as AsyncHTTPClient
+import httpx
 from openai import AsyncOpenAI
 
 from pydantic_ai.exceptions import UserError
@@ -40,7 +40,7 @@ class DeepSeekProvider(Provider[AsyncOpenAI]):
     def model_profile(self, model_name: str) -> ModelProfile | None:
         profile = deepseek_model_profile(model_name)
 
-        # As DeepSeekProvider is always used with OpenAIModel, which used to unconditionally use OpenAIJsonSchemaTransformer,
+        # As DeepSeekProvider is always used with OpenAIChatModel, which used to unconditionally use OpenAIJsonSchemaTransformer,
         # we need to maintain that behavior unless json_schema_transformer is set explicitly.
         # This was not the case when using a DeepSeek model with another model class (e.g. BedrockConverseModel or GroqModel),
         # so we won't do this in `deepseek_model_profile` unless we learn it's always needed.
@@ -53,7 +53,7 @@ class DeepSeekProvider(Provider[AsyncOpenAI]):
     def __init__(self, *, api_key: str) -> None: ...
 
     @overload
-    def __init__(self, *, api_key: str, http_client: AsyncHTTPClient) -> None: ...
+    def __init__(self, *, api_key: str, http_client: httpx.AsyncClient) -> None: ...
 
     @overload
     def __init__(self, *, openai_client: AsyncOpenAI | None = None) -> None: ...
@@ -63,7 +63,7 @@ class DeepSeekProvider(Provider[AsyncOpenAI]):
         *,
         api_key: str | None = None,
         openai_client: AsyncOpenAI | None = None,
-        http_client: AsyncHTTPClient | None = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> None:
         api_key = api_key or os.getenv('DEEPSEEK_API_KEY')
         if not api_key and openai_client is None:

pydantic_ai/providers/fireworks.py

@@ -3,7 +3,7 @@ from __future__ import annotations as _annotations
 import os
 from typing import overload
 
-from httpx import AsyncClient as AsyncHTTPClient
+import httpx
 from openai import AsyncOpenAI
 
 from pydantic_ai.exceptions import UserError
@@ -71,7 +71,7 @@ class FireworksProvider(Provider[AsyncOpenAI]):
     def __init__(self, *, api_key: str) -> None: ...
 
     @overload
-    def __init__(self, *, api_key: str, http_client: AsyncHTTPClient) -> None: ...
+    def __init__(self, *, api_key: str, http_client: httpx.AsyncClient) -> None: ...
 
     @overload
     def __init__(self, *, openai_client: AsyncOpenAI | None = None) -> None: ...
@@ -81,7 +81,7 @@ class FireworksProvider(Provider[AsyncOpenAI]):
         *,
         api_key: str | None = None,
         openai_client: AsyncOpenAI | None = None,
-        http_client: AsyncHTTPClient | None = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> None:
         api_key = api_key or os.getenv('FIREWORKS_API_KEY')
         if not api_key and openai_client is None: