pydantic-ai-slim 0.0.43__py3-none-any.whl → 0.0.45__py3-none-any.whl

pydantic_ai/providers/azure.py

@@ -6,7 +6,9 @@ from typing import overload
 import httpx
 from openai import AsyncOpenAI
 
+from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import cached_async_http_client
+from pydantic_ai.providers import Provider
 
 try:
     from openai import AsyncAzureOpenAI
@@ -17,9 +19,6 @@ except ImportError as _import_error:  # pragma: no cover
     ) from _import_error
 
 
-from . import Provider
-
-
 class AzureProvider(Provider[AsyncOpenAI]):
     """Provider for Azure OpenAI API.
 
@@ -83,18 +82,18 @@ class AzureProvider(Provider[AsyncOpenAI]):
             self._client = openai_client
         else:
             azure_endpoint = azure_endpoint or os.getenv('AZURE_OPENAI_ENDPOINT')
-            if azure_endpoint is None:  # pragma: no cover
-                raise ValueError(
+            if not azure_endpoint:  # pragma: no cover
+                raise UserError(
                     'Must provide one of the `azure_endpoint` argument or the `AZURE_OPENAI_ENDPOINT` environment variable'
                 )
 
-            if api_key is None and 'OPENAI_API_KEY' not in os.environ:  # pragma: no cover
-                raise ValueError(
+            if not api_key and 'OPENAI_API_KEY' not in os.environ:  # pragma: no cover
+                raise UserError(
                     'Must provide one of the `api_key` argument or the `OPENAI_API_KEY` environment variable'
                 )
 
-            if api_version is None and 'OPENAI_API_VERSION' not in os.environ:  # pragma: no cover
-                raise ValueError(
+            if not api_version and 'OPENAI_API_VERSION' not in os.environ:  # pragma: no cover
+                raise UserError(
                     'Must provide one of the `api_version` argument or the `OPENAI_API_VERSION` environment variable'
                 )
 

pydantic_ai/providers/bedrock.py

@@ -2,6 +2,7 @@ from __future__ import annotations as _annotations
 
 from typing import overload
 
+from pydantic_ai.exceptions import UserError
 from pydantic_ai.providers import Provider
 
 try:
@@ -73,4 +74,4 @@ class BedrockProvider(Provider[BaseClient]):
                     region_name=region_name,
                 )
             except NoRegionError as exc:  # pragma: no cover
-                raise ValueError('You must provide a `region_name` or a boto3 client for Bedrock Runtime.') from exc
+                raise UserError('You must provide a `region_name` or a boto3 client for Bedrock Runtime.') from exc

pydantic_ai/providers/cohere.py

@@ -0,0 +1,71 @@
+from __future__ import annotations as _annotations
+
+import os
+
+from httpx import AsyncClient as AsyncHTTPClient
+
+from pydantic_ai.exceptions import UserError
+from pydantic_ai.models import cached_async_http_client
+from pydantic_ai.providers import Provider
+
+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
+
+
+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 not api_key:
+                raise UserError(
+                    '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/providers/deepseek.py

@@ -6,7 +6,9 @@ from typing import overload
 from httpx import AsyncClient as AsyncHTTPClient
 from openai import AsyncOpenAI
 
+from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import cached_async_http_client
+from pydantic_ai.providers import Provider
 
 try:
     from openai import AsyncOpenAI
@@ -16,8 +18,6 @@ except ImportError as _import_error:  # pragma: no cover
         'you can use the `openai` optional group — `pip install "pydantic-ai-slim[openai]"`'
     ) from _import_error
 
-from . import Provider
-
 
 class DeepSeekProvider(Provider[AsyncOpenAI]):
     """Provider for DeepSeek API."""
@@ -54,8 +54,8 @@ class DeepSeekProvider(Provider[AsyncOpenAI]):
         http_client: AsyncHTTPClient | None = None,
     ) -> None:
         api_key = api_key or os.getenv('DEEPSEEK_API_KEY')
-        if api_key is None and openai_client is None:
-            raise ValueError(
+        if not api_key and openai_client is None:
+            raise UserError(
                 'Set the `DEEPSEEK_API_KEY` environment variable or pass it via `DeepSeekProvider(api_key=...)`'
                 'to use the DeepSeek provider.'
             )

pydantic_ai/providers/google_gla.py

@@ -4,6 +4,7 @@ import os
 
 import httpx
 
+from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import cached_async_http_client
 from pydantic_ai.providers import Provider
 
@@ -32,8 +33,8 @@ class GoogleGLAProvider(Provider[httpx.AsyncClient]):
             http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
         """
         api_key = api_key or os.environ.get('GEMINI_API_KEY')
-        if api_key is None:
-            raise ValueError(
+        if not api_key:
+            raise UserError(
                 'Set the `GEMINI_API_KEY` environment variable or pass it via `GoogleGLAProvider(api_key=...)`'
                 'to use the Google GLA provider.'
             )

pydantic_ai/providers/google_vertex.py

@@ -9,9 +9,8 @@ import anyio.to_thread
 import httpx
 
 from pydantic_ai.exceptions import UserError
-
-from ..models import cached_async_http_client
-from . import Provider
+from pydantic_ai.models import cached_async_http_client
+from pydantic_ai.providers import Provider
 
 try:
     import google.auth

pydantic_ai/providers/groq.py

@@ -5,7 +5,9 @@ from typing import overload
 
 from httpx import AsyncClient as AsyncHTTPClient
 
+from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import cached_async_http_client
+from pydantic_ai.providers import Provider
 
 try:
     from groq import AsyncGroq
@@ -16,9 +18,6 @@ except ImportError as _import_error:  # pragma: no cover
     ) from _import_error
 
 
-from . import Provider
-
-
 class GroqProvider(Provider[AsyncGroq]):
     """Provider for Groq API."""
 
@@ -64,8 +63,8 @@ class GroqProvider(Provider[AsyncGroq]):
         else:
             api_key = api_key or os.environ.get('GROQ_API_KEY')
 
-            if api_key is None:
-                raise ValueError(
+            if not api_key:
+                raise UserError(
                     'Set the `GROQ_API_KEY` environment variable or pass it via `GroqProvider(api_key=...)`'
                     'to use the Groq provider.'
                 )

pydantic_ai/providers/mistral.py

@@ -5,7 +5,9 @@ from typing import overload
 
 from httpx import AsyncClient as AsyncHTTPClient
 
+from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import cached_async_http_client
+from pydantic_ai.providers import Provider
 
 try:
     from mistralai import Mistral
@@ -16,9 +18,6 @@ except ImportError as e:  # pragma: no cover
     ) from e
 
 
-from . import Provider
-
-
 class MistralProvider(Provider[Mistral]):
     """Provider for Mistral API."""
 
@@ -62,8 +61,8 @@ class MistralProvider(Provider[Mistral]):
         else:
             api_key = api_key or os.environ.get('MISTRAL_API_KEY')
 
-            if api_key is None:
-                raise ValueError(
+            if not api_key:
+                raise UserError(
                     'Set the `MISTRAL_API_KEY` environment variable or pass it via `MistralProvider(api_key=...)`'
                     'to use the Mistral provider.'
                 )

pydantic_ai/providers/openai.py

@@ -5,6 +5,7 @@ import os
 import httpx
 
 from pydantic_ai.models import cached_async_http_client
+from pydantic_ai.providers import Provider
 
 try:
     from openai import AsyncOpenAI
@@ -15,9 +16,6 @@ except ImportError as _import_error:  # pragma: no cover
     ) from _import_error
 
 
-from . import Provider
-
-
 class OpenAIProvider(Provider[AsyncOpenAI]):
     """Provider for OpenAI API."""
 
@@ -27,7 +25,7 @@ class OpenAIProvider(Provider[AsyncOpenAI]):
 
     @property
     def base_url(self) -> str:
-        return self._base_url
+        return str(self.client.base_url)
 
     @property
     def client(self) -> AsyncOpenAI:
@@ -52,10 +50,9 @@ class OpenAIProvider(Provider[AsyncOpenAI]):
                 client to use. If provided, `base_url`, `api_key`, and `http_client` must be `None`.
             http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
         """
-        self._base_url = base_url or os.getenv('OPENAI_BASE_URL', 'https://api.openai.com/v1')
         # This is a workaround for the OpenAI client requiring an API key, whilst locally served,
         # openai compatible models do not always need an API key, but a placeholder (non-empty) key is required.
-        if api_key is None and 'OPENAI_API_KEY' not in os.environ and openai_client is None:
+        if api_key is None and 'OPENAI_API_KEY' not in os.environ and base_url is not None and openai_client is None:
             api_key = 'api-key-not-set'
 
         if openai_client is not None:
@@ -64,6 +61,6 @@ class OpenAIProvider(Provider[AsyncOpenAI]):
             assert api_key is None, 'Cannot provide both `openai_client` and `api_key`'
             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)
+            self._client = AsyncOpenAI(base_url=base_url, api_key=api_key, http_client=http_client)
         else:
-            self._client = AsyncOpenAI(base_url=self.base_url, api_key=api_key, http_client=cached_async_http_client())
+            self._client = AsyncOpenAI(base_url=base_url, api_key=api_key, http_client=cached_async_http_client())

{pydantic_ai_slim-0.0.43.dist-info → pydantic_ai_slim-0.0.45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.43
+Version: 0.0.45
 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.43
+Requires-Dist: pydantic-graph==0.0.45
 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.45.dist-info/RECORD

@@ -0,0 +1,50 @@
+pydantic_ai/__init__.py,sha256=5or1fE25gmemJGCznkFHC4VMeNT7vTLU6BiGxkmSA2A,959
+pydantic_ai/_agent_graph.py,sha256=aZHgDDEL0kYl7G0LAAPrrf4UufqB_FUN8s4PlnVqA-o,32557
+pydantic_ai/_cli.py,sha256=YrNi4vodEH-o5MlfG4CemdkdJl5kQx56nyCMp2QqRMw,8610
+pydantic_ai/_griffe.py,sha256=Sf_DisE9k2TA0VFeVIK2nf1oOct5MygW86PBCACJkFA,5244
+pydantic_ai/_parts_manager.py,sha256=HIi6eth7z2g0tOn6iQYc633xMqy4d_xZ8vwka8J8150,12016
+pydantic_ai/_pydantic.py,sha256=12hX5hON88meO1QxbWrEPXSvr6RTNgr6ubKY6KRwab4,8890
+pydantic_ai/_result.py,sha256=SlxqR-AKWzDoc7cRRN2jmIZ7pCv3DKzaP-dnZW-e7us,10117
+pydantic_ai/_system_prompt.py,sha256=602c2jyle2R_SesOrITBDETZqsLk4BZ8Cbo8yEhmx04,1120
+pydantic_ai/_utils.py,sha256=s_cVIKiJk1wkLhXDRxxWZGd1QgXFey6HYJ0OGU8Kezs,9657
+pydantic_ai/agent.py,sha256=QF3MQWKjglbtGVWLHSAizN0gDrC1d0B09BKNF03dSow,69491
+pydantic_ai/exceptions.py,sha256=gvbFsFkAzSXOo_d1nfjy09kDHUGv1j5q70Uk-wKYGi8,3167
+pydantic_ai/format_as_xml.py,sha256=QE7eMlg5-YUMw1_2kcI3h0uKYPZZyGkgXFDtfZTMeeI,4480
+pydantic_ai/mcp.py,sha256=d6odfllUQ94ROnkZ1MeEMg5L23rKhOnEs_JVWkWAC-Y,7068
+pydantic_ai/messages.py,sha256=KQXG8BLnQtZzgU4ykOJT6LIs03Vem2eb0VqMyXmFt7I,27067
+pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_ai/result.py,sha256=LXKxRzy_rGMkdZ8xJ7yknPP3wGZtGNeZl-gh5opXbaQ,22542
+pydantic_ai/settings.py,sha256=q__Hordc4dypesNxpy_cBT5rFdSiEY-rQt9G6zfyFaM,3101
+pydantic_ai/tools.py,sha256=ImFy3V4fw_tvh5h8FZFpCrgnzlmoHCo-Y_9EjMwOSWc,14393
+pydantic_ai/usage.py,sha256=9sqoIv_RVVUhKXQScTDqUJc074gifsuSzc9_NOt7C3g,5394
+pydantic_ai/common_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_ai/common_tools/duckduckgo.py,sha256=Iw8Dl2YQ28S483mzfa8CXs-dc-ujS8un085R2O6oOEw,2241
+pydantic_ai/common_tools/tavily.py,sha256=h8deBDrpG-8BGzydM_zXs7z1ASrhdVvUxL4-CAbncBo,2589
+pydantic_ai/models/__init__.py,sha256=HSjLtlnhtYGXHql46WK_V01lmc9PO7X66Dkf-plCafo,16671
+pydantic_ai/models/anthropic.py,sha256=O7gHDqM6V4zQLwjg5xyB6zDCAUXGaXcWtyXjV6vHLu0,21640
+pydantic_ai/models/bedrock.py,sha256=Fh5kNnH0H_OyKOUzSlVJYhc0K_wz3mrOH5Y4-oS6lmU,20532
+pydantic_ai/models/cohere.py,sha256=ogu97Strxsp6wzlNqT22SfgvltTeP1lLC5S86d037Ic,11249
+pydantic_ai/models/fallback.py,sha256=y0bYXM3DfzJNAsyyMzclt33lzZazL-5_hwdgc33gfuM,4876
+pydantic_ai/models/function.py,sha256=HUSgPB3mKVfYI0OSJJJJRiQN-yeewjYIbrtrPfsvlgI,11365
+pydantic_ai/models/gemini.py,sha256=ox9WoqWgZ7Q-xTRJBv9loTy9P49uAwvJwCPoiqljhPM,33215
+pydantic_ai/models/groq.py,sha256=H-7Eu61EOxKoIPjI6wvofrA2PxSQxhd-BJOHT1p7KiA,15862
+pydantic_ai/models/instrumented.py,sha256=FMEcQ8RnASD7bR8Ol5a16W6yTq1P1F8FojgBIUXdt3w,10962
+pydantic_ai/models/mistral.py,sha256=0bA5vRGXOJulY7r-8jUT8gicAuTSg_sSN0riDP_j9oY,27243
+pydantic_ai/models/openai.py,sha256=W_J_pnoJLSYKTfs_4G9SpFzLPdD2trIDFqtNVSmJ1D4,20060
+pydantic_ai/models/test.py,sha256=qQ8ZIaVRdbJv-tKGu6lrdakVAhOsTlyf68TFWyGwOWE,16861
+pydantic_ai/models/wrapper.py,sha256=ff6JPTuIv9C_6Zo4kyYIO7Cn0VI1uSICz1v1aKUyeOc,1506
+pydantic_ai/providers/__init__.py,sha256=lsJn3BStrPMMAFWEkCYPyfMj3fEVfaeS2xllnvE6Gdk,2489
+pydantic_ai/providers/anthropic.py,sha256=RfYpsKMZxUqE1_PbfJi3JCVmYelN-cwtC5vmw-PmIIA,2750
+pydantic_ai/providers/azure.py,sha256=M1QYzoLGBg23V8eXo4e7xSNJgoDGvLeMFgiYD-3iTNc,4197
+pydantic_ai/providers/bedrock.py,sha256=lSfK0mDqrmWLxzDKvtiY_nN2J3S_GGSPMRLJYeyvLrQ,2544
+pydantic_ai/providers/cohere.py,sha256=qk5fu0ao1EjLVgvDOGWjpGw-rE5iEggeyEgm6tou9O4,2646
+pydantic_ai/providers/deepseek.py,sha256=q_-ybngI2IvRl_sKlkARKuKwYCNC2lElIT4eo43UCf8,2136
+pydantic_ai/providers/google_gla.py,sha256=vrzzf8BkGLfJKy4GO3Ywswhf-b9OPr54O6LvBKVSwko,1579
+pydantic_ai/providers/google_vertex.py,sha256=TrMUzNwEJpFdE9lMuTwiQzGA-Qvf8TCOBrztgwk8u0c,9111
+pydantic_ai/providers/groq.py,sha256=BM0hNwSmf4gTuQoH2iiT96HApdqskEafeK_Yq9V_L6c,2769
+pydantic_ai/providers/mistral.py,sha256=oap2wjzc20byC8W0O6qaRUkMo7fFpibwhRvqEXAFI3g,2601
+pydantic_ai/providers/openai.py,sha256=gKbq12z4rzwDmTvWnpMULcyP5bCSagTQKApK9ukROOA,2811
+pydantic_ai_slim-0.0.45.dist-info/METADATA,sha256=TuKSPs8TaUefJ9drnwrQqZ2CmDqXkK1SXbYJ_iwYX38,3436
+pydantic_ai_slim-0.0.45.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-0.0.45.dist-info/entry_points.txt,sha256=KxQSmlMS8GMTkwTsl4_q9a5nJvBjj3HWeXx688wLrKg,45
+pydantic_ai_slim-0.0.45.dist-info/RECORD,,

pydantic_ai/models/vertexai.py

@@ -1,260 +0,0 @@
-from __future__ import annotations as _annotations
-
-import warnings
-from collections.abc import AsyncIterator
-from contextlib import asynccontextmanager
-from dataclasses import dataclass, field
-from datetime import datetime, timedelta
-from pathlib import Path
-from typing import Literal
-
-from httpx import AsyncClient as AsyncHTTPClient
-from typing_extensions import deprecated
-
-from .. import usage
-from .._utils import run_in_executor
-from ..exceptions import UserError
-from ..messages import ModelMessage, ModelResponse
-from ..settings import ModelSettings
-from . import ModelRequestParameters, StreamedResponse, cached_async_http_client
-from .gemini import GeminiModel, GeminiModelName
-
-try:
-    import google.auth
-    from google.auth.credentials import Credentials as BaseCredentials
-    from google.auth.transport.requests import Request
-    from google.oauth2.service_account import Credentials as ServiceAccountCredentials
-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]"`'
-    ) from _import_error
-
-VERTEX_AI_URL_TEMPLATE = (
-    'https://{region}-aiplatform.googleapis.com/v1'
-    '/projects/{project_id}'
-    '/locations/{region}'
-    '/publishers/{model_publisher}'
-    '/models/{model}'
-    ':'
-)
-"""URL template for Vertex AI.
-
-See
-[`generateContent` docs](https://cloud.google.com/vertex-ai/docs/reference/rest/v1/projects.locations.endpoints/generateContent)
-and
-[`streamGenerateContent` docs](https://cloud.google.com/vertex-ai/docs/reference/rest/v1/projects.locations.endpoints/streamGenerateContent)
-for more information.
-
-The template is used thus:
-
-* `region` is substituted with the `region` argument,
-  see [available regions][pydantic_ai.models.vertexai.VertexAiRegion]
-* `model_publisher` is substituted with the `model_publisher` argument
-* `model` is substituted with the `model_name` argument
-* `project_id` is substituted with the `project_id` from auth/credentials
-* `function` (`generateContent` or `streamGenerateContent`) is added to the end of the URL
-"""
-
-
-@deprecated('Please use `GeminiModel(provider=GoogleVertexProvider(...))` instead.')
-@dataclass(init=False)
-class VertexAIModel(GeminiModel):
-    """A model that uses Gemini via the `*-aiplatform.googleapis.com` VertexAI API."""
-
-    service_account_file: Path | str | None
-    project_id: str | None
-    region: VertexAiRegion
-    model_publisher: Literal['google']
-    url_template: str
-
-    _model_name: GeminiModelName = field(repr=False)
-    _system: str = field(default='vertex_ai', repr=False)
-
-    # TODO __init__ can be removed once we drop 3.9 and we can set kw_only correctly on the dataclass
-    def __init__(
-        self,
-        model_name: GeminiModelName,
-        *,
-        service_account_file: Path | str | None = None,
-        project_id: str | None = None,
-        region: VertexAiRegion = 'us-central1',
-        model_publisher: Literal['google'] = 'google',
-        http_client: AsyncHTTPClient | None = None,
-        url_template: str = VERTEX_AI_URL_TEMPLATE,
-    ):
-        """Initialize a Vertex AI Gemini model.
-
-        Args:
-            model_name: The name of the model to use. I couldn't find a list of supported Google models, in VertexAI
-                so for now this uses the same models as the [Gemini model][pydantic_ai.models.gemini.GeminiModel].
-            service_account_file: Path to a service account file.
-                If not provided, the default environment credentials will be used.
-            project_id: The project ID to use, if not provided it will be taken from the credentials.
-            region: The region to make requests to.
-            model_publisher: The model publisher to use, I couldn't find a good list of available publishers,
-                and from trial and error it seems non-google models don't work with the `generateContent` and
-                `streamGenerateContent` functions, hence only `google` is currently supported.
-                Please create an issue or PR if you know how to use other publishers.
-            http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
-            url_template: URL template for Vertex AI, see
-                [`VERTEX_AI_URL_TEMPLATE` docs][pydantic_ai.models.vertexai.VERTEX_AI_URL_TEMPLATE]
-                for more information.
-        """
-        self._model_name = model_name
-        self.service_account_file = service_account_file
-        self.project_id = project_id
-        self.region = region
-        self.model_publisher = model_publisher
-        self.client = http_client or cached_async_http_client()
-        self.url_template = url_template
-
-        self._auth = None
-        self._url = None
-        warnings.warn(
-            'VertexAIModel is deprecated, please use `GeminiModel(provider=GoogleVertexProvider(...))` instead.',
-            DeprecationWarning,
-        )
-        self._provider = None
-
-    async def ainit(self) -> None:
-        """Initialize the model, setting the URL and auth.
-
-        This will raise an error if authentication fails.
-        """
-        if self._url is not None and self._auth is not None:
-            return
-
-        if self.service_account_file is not None:
-            creds: BaseCredentials | ServiceAccountCredentials = _creds_from_file(self.service_account_file)
-            assert creds.project_id is None or isinstance(creds.project_id, str)
-            creds_project_id: str | None = creds.project_id
-            creds_source = 'service account file'
-        else:
-            creds, creds_project_id = await _async_google_auth()
-            creds_source = '`google.auth.default()`'
-
-        if self.project_id is None:
-            if creds_project_id is None:
-                raise UserError(f'No project_id provided and none found in {creds_source}')
-            project_id = creds_project_id
-        else:
-            project_id = self.project_id
-
-        self._url = self.url_template.format(
-            region=self.region,
-            project_id=project_id,
-            model_publisher=self.model_publisher,
-            model=self._model_name,
-        )
-        self._auth = BearerTokenAuth(creds)
-
-    async def request(
-        self,
-        messages: list[ModelMessage],
-        model_settings: ModelSettings | None,
-        model_request_parameters: ModelRequestParameters,
-    ) -> tuple[ModelResponse, usage.Usage]:
-        await self.ainit()
-        return await super().request(messages, model_settings, model_request_parameters)
-
-    @asynccontextmanager
-    async def request_stream(
-        self,
-        messages: list[ModelMessage],
-        model_settings: ModelSettings | None,
-        model_request_parameters: ModelRequestParameters,
-    ) -> AsyncIterator[StreamedResponse]:
-        await self.ainit()
-        async with super().request_stream(messages, model_settings, model_request_parameters) as value:
-            yield value
-
-    @property
-    def model_name(self) -> GeminiModelName:
-        """The model name."""
-        return self._model_name
-
-    @property
-    def system(self) -> str:
-        """The system / model provider."""
-        return self._system
-
-
-# pyright: reportUnknownMemberType=false
-def _creds_from_file(service_account_file: str | Path) -> ServiceAccountCredentials:
-    return ServiceAccountCredentials.from_service_account_file(
-        str(service_account_file), scopes=['https://www.googleapis.com/auth/cloud-platform']
-    )
-
-
-# pyright: reportReturnType=false
-# pyright: reportUnknownVariableType=false
-# pyright: reportUnknownArgumentType=false
-async def _async_google_auth() -> tuple[BaseCredentials, str | None]:
-    return await run_in_executor(google.auth.default, scopes=['https://www.googleapis.com/auth/cloud-platform'])
-
-
-# default expiry is 3600 seconds
-MAX_TOKEN_AGE = timedelta(seconds=3000)
-
-
-@dataclass
-class BearerTokenAuth:
-    """Authentication using a bearer token generated by google-auth."""
-
-    credentials: BaseCredentials | ServiceAccountCredentials
-    token_created: datetime | None = field(default=None, init=False)
-
-    async def headers(self) -> dict[str, str]:
-        if self.credentials.token is None or self._token_expired():
-            await run_in_executor(self._refresh_token)
-            self.token_created = datetime.now()
-        return {'Authorization': f'Bearer {self.credentials.token}'}
-
-    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:
-        self.credentials.refresh(Request())
-        assert isinstance(self.credentials.token, str), f'Expected token to be a string, got {self.credentials.token}'
-        return self.credentials.token
-
-
-VertexAiRegion = Literal[
-    'asia-east1',
-    'asia-east2',
-    'asia-northeast1',
-    'asia-northeast3',
-    'asia-south1',
-    'asia-southeast1',
-    'australia-southeast1',
-    'europe-central2',
-    'europe-north1',
-    'europe-southwest1',
-    'europe-west1',
-    'europe-west2',
-    'europe-west3',
-    'europe-west4',
-    'europe-west6',
-    'europe-west8',
-    'europe-west9',
-    'me-central1',
-    'me-central2',
-    'me-west1',
-    'northamerica-northeast1',
-    'southamerica-east1',
-    'us-central1',
-    'us-east1',
-    'us-east4',
-    'us-east5',
-    'us-south1',
-    'us-west1',
-    'us-west4',
-]
-"""Regions available for Vertex AI.
-
-More details [here](https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations#genai-locations).
-"""