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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.44
+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.44
+Requires-Dist: pydantic-graph==0.0.45
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: anthropic

{pydantic_ai_slim-0.0.44 → pydantic_ai_slim-0.0.45}/pydantic_ai/_parts_manager.py

@@ -29,6 +29,8 @@ from pydantic_ai.messages import (
     ToolCallPartDelta,
 )
 
+from ._utils import generate_tool_call_id as _generate_tool_call_id
+
 VendorId = Hashable
 """
 Type alias for a vendor identifier, which can be any hashable type (e.g., a string, UUID, etc.)
@@ -221,7 +223,11 @@ class ModelResponsePartsManager:
             ModelResponseStreamEvent: A `PartStartEvent` indicating that a new tool call part
             has been added to the manager, or replaced an existing part.
         """
-        new_part = ToolCallPart(tool_name=tool_name, args=args, tool_call_id=tool_call_id)
+        new_part = ToolCallPart(
+            tool_name=tool_name,
+            args=args,
+            tool_call_id=tool_call_id or _generate_tool_call_id(),
+        )
         if vendor_part_id is None:
             # vendor_part_id is None, so we unconditionally append a new ToolCallPart to the end of the list
             new_part_index = len(self._parts)

{pydantic_ai_slim-0.0.44 → pydantic_ai_slim-0.0.45}/pydantic_ai/_utils.py

@@ -2,6 +2,7 @@ from __future__ import annotations as _annotations
 
 import asyncio
 import time
+import uuid
 from collections.abc import AsyncIterable, AsyncIterator, Iterator
 from contextlib import asynccontextmanager, suppress
 from dataclasses import dataclass, is_dataclass
@@ -195,12 +196,17 @@ def now_utc() -> datetime:
     return datetime.now(tz=timezone.utc)
 
 
-def guard_tool_call_id(
-    t: _messages.ToolCallPart | _messages.ToolReturnPart | _messages.RetryPromptPart, model_source: str
-) -> str:
-    """Type guard that checks a `tool_call_id` is not None both for static typing and runtime."""
-    assert t.tool_call_id is not None, f'{model_source} requires `tool_call_id` to be set: {t}'
-    return t.tool_call_id
+def guard_tool_call_id(t: _messages.ToolCallPart | _messages.ToolReturnPart | _messages.RetryPromptPart) -> str:
+    """Type guard that either returns the tool call id or generates a new one if it's None."""
+    return t.tool_call_id or generate_tool_call_id()
+
+
+def generate_tool_call_id() -> str:
+    """Generate a tool call id.
+
+    Ensure that the tool call id is unique.
+    """
+    return f'pyd_ai_{uuid.uuid4().hex}'
 
 
 class PeekableAsyncStream(Generic[T]):

{pydantic_ai_slim-0.0.44 → pydantic_ai_slim-0.0.45}/pydantic_ai/exceptions.py

@@ -3,9 +3,9 @@ from __future__ import annotations as _annotations
 import json
 import sys
 
-if sys.version_info < (3, 11):
+if sys.version_info < (3, 11):  # pragma: no cover
     from exceptiongroup import ExceptionGroup
-else:
+else:  # pragma: no cover
     ExceptionGroup = ExceptionGroup
 
 __all__ = (

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

@@ -12,7 +12,7 @@ import pydantic_core
 from opentelemetry._events import Event
 from typing_extensions import TypeAlias
 
-from ._utils import now_utc as _now_utc
+from ._utils import generate_tool_call_id as _generate_tool_call_id, now_utc as _now_utc
 from .exceptions import UnexpectedModelBehavior
 
 
@@ -268,8 +268,8 @@ class ToolReturnPart:
     content: Any
     """The return value."""
 
-    tool_call_id: str | None = None
-    """Optional tool call identifier, this is used by some models including OpenAI."""
+    tool_call_id: str
+    """The tool call identifier, this is used by some models including OpenAI."""
 
     timestamp: datetime = field(default_factory=_now_utc)
     """The timestamp, when the tool returned."""
@@ -328,8 +328,11 @@ class RetryPromptPart:
     tool_name: str | None = None
     """The name of the tool that was called, if any."""
 
-    tool_call_id: str | None = None
-    """Optional tool call identifier, this is used by some models including OpenAI."""
+    tool_call_id: str = field(default_factory=_generate_tool_call_id)
+    """The tool call identifier, this is used by some models including OpenAI.
+
+    In case the tool call id is not provided by the model, PydanticAI will generate a random one.
+    """
 
     timestamp: datetime = field(default_factory=_now_utc)
     """The timestamp, when the retry was triggered."""
@@ -406,8 +409,11 @@ class ToolCallPart:
     This is stored either as a JSON string or a Python dictionary depending on how data was received.
     """
 
-    tool_call_id: str | None = None
-    """Optional tool call identifier, this is used by some models including OpenAI."""
+    tool_call_id: str = field(default_factory=_generate_tool_call_id)
+    """The tool call identifier, this is used by some models including OpenAI.
+
+    In case the tool call id is not provided by the model, PydanticAI will generate a random one.
+    """
 
     part_kind: Literal['tool-call'] = 'tool-call'
     """Part type identifier, this is available on all parts as a discriminator."""
@@ -564,11 +570,7 @@ class ToolCallPartDelta:
         if self.tool_name_delta is None or self.args_delta is None:
             return None
 
-        return ToolCallPart(
-            self.tool_name_delta,
-            self.args_delta,
-            self.tool_call_id,
-        )
+        return ToolCallPart(self.tool_name_delta, self.args_delta, self.tool_call_id or _generate_tool_call_id())
 
     @overload
     def apply(self, part: ModelResponsePart) -> ToolCallPart: ...
@@ -620,20 +622,11 @@ class ToolCallPartDelta:
             delta = replace(delta, args_delta=updated_args_delta)
 
         if self.tool_call_id:
-            # Set the tool_call_id if it wasn't present, otherwise error if it has changed
-            if delta.tool_call_id is not None and delta.tool_call_id != self.tool_call_id:
-                raise UnexpectedModelBehavior(
-                    f'Cannot apply a new tool_call_id to a ToolCallPartDelta that already has one ({delta=}, {self=})'
-                )
             delta = replace(delta, tool_call_id=self.tool_call_id)
 
         # If we now have enough data to create a full ToolCallPart, do so
         if delta.tool_name_delta is not None and delta.args_delta is not None:
-            return ToolCallPart(
-                delta.tool_name_delta,
-                delta.args_delta,
-                delta.tool_call_id,
-            )
+            return ToolCallPart(delta.tool_name_delta, delta.args_delta, delta.tool_call_id or _generate_tool_call_id())
 
         return delta
 
@@ -656,11 +649,6 @@ class ToolCallPartDelta:
             part = replace(part, args=updated_dict)
 
         if self.tool_call_id:
-            # Replace the tool_call_id entirely if given
-            if part.tool_call_id is not None and part.tool_call_id != self.tool_call_id:
-                raise UnexpectedModelBehavior(
-                    f'Cannot apply a new tool_call_id to a ToolCallPartDelta that already has one ({part=}, {self=})'
-                )
             part = replace(part, tool_call_id=self.tool_call_id)
         return part
 

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

@@ -10,8 +10,7 @@ from json import JSONDecodeError, loads as json_loads
 from typing import Any, Literal, Union, cast, overload
 
 from anthropic.types import DocumentBlockParam
-from httpx import AsyncClient as AsyncHTTPClient
-from typing_extensions import assert_never, deprecated
+from typing_extensions import assert_never
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
 from .._utils import guard_tool_call_id as _guard_tool_call_id
@@ -112,34 +111,11 @@ class AnthropicModel(Model):
     _model_name: AnthropicModelName = field(repr=False)
     _system: str = field(default='anthropic', repr=False)
 
-    @overload
     def __init__(
         self,
         model_name: AnthropicModelName,
         *,
         provider: Literal['anthropic'] | Provider[AsyncAnthropic] = 'anthropic',
-    ) -> None: ...
-
-    @deprecated('Use the `provider` parameter instead of `api_key`, `anthropic_client`, and `http_client`.')
-    @overload
-    def __init__(
-        self,
-        model_name: AnthropicModelName,
-        *,
-        provider: None = None,
-        api_key: str | None = None,
-        anthropic_client: AsyncAnthropic | None = None,
-        http_client: AsyncHTTPClient | None = None,
-    ) -> None: ...
-
-    def __init__(
-        self,
-        model_name: AnthropicModelName,
-        *,
-        provider: Literal['anthropic'] | Provider[AsyncAnthropic] | None = None,
-        api_key: str | None = None,
-        anthropic_client: AsyncAnthropic | None = None,
-        http_client: AsyncHTTPClient | None = None,
     ):
         """Initialize an Anthropic model.
 
@@ -148,27 +124,12 @@ class AnthropicModel(Model):
                 [here](https://docs.anthropic.com/en/docs/about-claude/models).
             provider: The provider to use for the Anthropic API. Can be either the string 'anthropic' or an
                 instance of `Provider[AsyncAnthropic]`. If not provided, the other parameters will be used.
-            api_key: The API key to use for authentication, if not provided, the `ANTHROPIC_API_KEY` environment variable
-                will be used if available.
-            anthropic_client: An existing
-                [`AsyncAnthropic`](https://github.com/anthropics/anthropic-sdk-python?tab=readme-ov-file#async-usage)
-                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.
         """
         self._model_name = model_name
 
-        if provider is not None:
-            if isinstance(provider, str):
-                provider = infer_provider(provider)
-            self.client = provider.client
-        elif anthropic_client is not None:
-            assert http_client is None, 'Cannot provide both `anthropic_client` and `http_client`'
-            assert api_key is None, 'Cannot provide both `anthropic_client` and `api_key`'
-            self.client = anthropic_client
-        elif http_client is not None:
-            self.client = AsyncAnthropic(api_key=api_key, http_client=http_client)
-        else:
-            self.client = AsyncAnthropic(api_key=api_key, http_client=cached_async_http_client())
+        if isinstance(provider, str):
+            provider = infer_provider(provider)
+        self.client = provider.client
 
     @property
     def base_url(self) -> str:
@@ -326,7 +287,7 @@ class AnthropicModel(Model):
                             user_content_params.append(content)
                     elif isinstance(request_part, ToolReturnPart):
                         tool_result_block_param = ToolResultBlockParam(
-                            tool_use_id=_guard_tool_call_id(t=request_part, model_source='Anthropic'),
+                            tool_use_id=_guard_tool_call_id(t=request_part),
                             type='tool_result',
                             content=request_part.model_response_str(),
                             is_error=False,
@@ -337,7 +298,7 @@ class AnthropicModel(Model):
                             retry_param = TextBlockParam(type='text', text=request_part.model_response())
                         else:
                             retry_param = ToolResultBlockParam(
-                                tool_use_id=_guard_tool_call_id(t=request_part, model_source='Anthropic'),
+                                tool_use_id=_guard_tool_call_id(t=request_part),
                                 type='tool_result',
                                 content=request_part.model_response(),
                                 is_error=True,
@@ -351,7 +312,7 @@ class AnthropicModel(Model):
                         assistant_content_params.append(TextBlockParam(text=response_part.content, type='text'))
                     else:
                         tool_use_block_param = ToolUseBlockParam(
-                            id=_guard_tool_call_id(t=response_part, model_source='Anthropic'),
+                            id=_guard_tool_call_id(t=response_part),
                             type='tool_use',
                             name=response_part.tool_name,
                             input=response_part.args_as_dict(),

{pydantic_ai_slim-0.0.44 → pydantic_ai_slim-0.0.45}/pydantic_ai/models/bedrock.py

@@ -143,14 +143,15 @@ class BedrockConverseModel(Model):
             model_name: The name of the model to use.
             model_name: The name of the Bedrock model to use. List of model names available
                 [here](https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html).
-            provider: The provider to use. Defaults to `'bedrock'`.
+            provider: The provider to use for authentication and API access. Can be either the string
+                'bedrock' or an instance of `Provider[BaseClient]`. If not provided, a new provider will be
+                created using the other parameters.
         """
         self._model_name = model_name
 
         if isinstance(provider, str):
-            self.client = infer_provider(provider).client
-        else:
-            self.client = cast('BedrockRuntimeClient', provider.client)
+            provider = infer_provider(provider)
+        self.client = cast('BedrockRuntimeClient', provider.client)
 
     def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[ToolTypeDef]:
         tools = [self._map_tool_definition(r) for r in model_request_parameters.function_tools]
@@ -345,7 +346,7 @@ class BedrockConverseModel(Model):
                         content.append({'text': item.content})
                     else:
                         assert isinstance(item, ToolCallPart)
-                        content.append(self._map_tool_call(item))  # FIXME: MISSING key
+                        content.append(self._map_tool_call(item))
                 bedrock_messages.append({'role': 'assistant', 'content': content})
             else:
                 assert_never(m)
@@ -394,13 +395,8 @@ class BedrockConverseModel(Model):
 
     @staticmethod
     def _map_tool_call(t: ToolCallPart) -> ContentBlockOutputTypeDef:
-        assert t.tool_call_id is not None
         return {
-            'toolUse': {
-                'toolUseId': t.tool_call_id,
-                'name': t.tool_name,
-                'input': t.args_as_dict(),
-            }
+            'toolUse': {'toolUseId': _utils.guard_tool_call_id(t=t), 'name': t.tool_name, 'input': t.args_as_dict()}
         }
 
 

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

@@ -3,14 +3,13 @@ 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, overload
+from typing import Literal, Union, cast
 
 from cohere import TextAssistantMessageContentItem
-from httpx import AsyncClient as AsyncHTTPClient
-from typing_extensions import assert_never, deprecated
+from typing_extensions import assert_never
 
 from .. import ModelHTTPError, result
-from .._utils import guard_tool_call_id as _guard_tool_call_id
+from .._utils import generate_tool_call_id as _generate_tool_call_id, guard_tool_call_id as _guard_tool_call_id
 from ..messages import (
     ModelMessage,
     ModelRequest,
@@ -29,7 +28,6 @@ from ..tools import ToolDefinition
 from . import (
     Model,
     ModelRequestParameters,
-    cached_async_http_client,
     check_allow_model_requests,
 )
 
@@ -102,37 +100,11 @@ 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,
     ):
         """Initialize an Cohere model.
 
@@ -142,24 +114,12 @@ class CohereModel(Model):
             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,
-                `api_key` and `http_client` must be `None`.
-            http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
         """
         self._model_name: CohereModelName = model_name
 
-        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 or cached_async_http_client())
+        if isinstance(provider, str):
+            provider = infer_provider(provider)
+        self.client = provider.client
 
     @property
     def base_url(self) -> str:
@@ -225,7 +185,7 @@ class CohereModel(Model):
                     ToolCallPart(
                         tool_name=c.function.name,
                         args=c.function.arguments,
-                        tool_call_id=c.id,
+                        tool_call_id=c.id or _generate_tool_call_id(),
                     )
                 )
         return ModelResponse(parts=parts, model_name=self._model_name)
@@ -262,7 +222,7 @@ class CohereModel(Model):
     @staticmethod
     def _map_tool_call(t: ToolCallPart) -> ToolCallV2:
         return ToolCallV2(
-            id=_guard_tool_call_id(t=t, model_source='Cohere'),
+            id=_guard_tool_call_id(t=t),
             type='function',
             function=ToolCallV2Function(
                 name=t.tool_name,
@@ -294,7 +254,7 @@ class CohereModel(Model):
             elif isinstance(part, ToolReturnPart):
                 yield ToolChatMessageV2(
                     role='tool',
-                    tool_call_id=_guard_tool_call_id(t=part, model_source='Cohere'),
+                    tool_call_id=_guard_tool_call_id(t=part),
                     content=part.model_response_str(),
                 )
             elif isinstance(part, RetryPromptPart):
@@ -303,7 +263,7 @@ class CohereModel(Model):
                 else:
                     yield ToolChatMessageV2(
                         role='tool',
-                        tool_call_id=_guard_tool_call_id(t=part, model_source='Cohere'),
+                        tool_call_id=_guard_tool_call_id(t=part),
                         content=part.model_response(),
                     )
             else:

{pydantic_ai_slim-0.0.44 → pydantic_ai_slim-0.0.45}/pydantic_ai/models/gemini.py

@@ -1,19 +1,19 @@
 from __future__ import annotations as _annotations
 
 import base64
-import os
 import re
 from collections.abc import AsyncIterator, Sequence
 from contextlib import asynccontextmanager
 from copy import deepcopy
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Annotated, Any, Literal, Protocol, Union, cast, overload
+from typing import Annotated, Any, Literal, Protocol, Union, cast
 from uuid import uuid4
 
+import httpx
 import pydantic
-from httpx import USE_CLIENT_DEFAULT, AsyncClient as AsyncHTTPClient, Response as HTTPResponse
-from typing_extensions import NotRequired, TypedDict, assert_never, deprecated
+from httpx import USE_CLIENT_DEFAULT, Response as HTTPResponse
+from typing_extensions import NotRequired, TypedDict, assert_never
 
 from pydantic_ai.providers import Provider, infer_provider
 
@@ -85,78 +85,36 @@ class GeminiModel(Model):
     Apart from `__init__`, all methods are private or match those of the base class.
     """
 
-    client: AsyncHTTPClient = field(repr=False)
+    client: httpx.AsyncClient = field(repr=False)
 
     _model_name: GeminiModelName = field(repr=False)
-    _provider: Literal['google-gla', 'google-vertex'] | Provider[AsyncHTTPClient] | None = field(repr=False)
+    _provider: Literal['google-gla', 'google-vertex'] | Provider[httpx.AsyncClient] | None = field(repr=False)
     _auth: AuthProtocol | None = field(repr=False)
     _url: str | None = field(repr=False)
     _system: str = field(default='gemini', repr=False)
 
-    @overload
     def __init__(
         self,
         model_name: GeminiModelName,
         *,
-        provider: Literal['google-gla', 'google-vertex'] | Provider[AsyncHTTPClient] = 'google-gla',
-    ) -> None: ...
-
-    @deprecated('Use the `provider` argument instead of the `api_key`, `http_client`, and `url_template` arguments.')
-    @overload
-    def __init__(
-        self,
-        model_name: GeminiModelName,
-        *,
-        provider: None = None,
-        api_key: str | None = None,
-        http_client: AsyncHTTPClient | None = None,
-        url_template: str = 'https://generativelanguage.googleapis.com/v1beta/models/{model}:',
-    ) -> None: ...
-
-    def __init__(
-        self,
-        model_name: GeminiModelName,
-        *,
-        provider: Literal['google-gla', 'google-vertex'] | Provider[AsyncHTTPClient] | None = None,
-        api_key: str | None = None,
-        http_client: AsyncHTTPClient | None = None,
-        url_template: str = 'https://generativelanguage.googleapis.com/v1beta/models/{model}:',
+        provider: Literal['google-gla', 'google-vertex'] | Provider[httpx.AsyncClient] = 'google-gla',
     ):
         """Initialize a Gemini model.
 
         Args:
             model_name: The name of the model to use.
-            provider: The provider to use for the model.
-            api_key: The API key to use for authentication, if not provided, the `GEMINI_API_KEY` environment variable
-                will be used if available.
-            http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
-            url_template: The URL template to use for making requests, you shouldn't need to change this,
-                docs [here](https://ai.google.dev/gemini-api/docs/quickstart?lang=rest#make-first-request),
-                `model` is substituted with the model name, and `function` is added to the end of the URL.
+            provider: The provider to use for authentication and API access. Can be either the string
+                'google-gla' or 'google-vertex' or an instance of `Provider[httpx.AsyncClient]`.
+                If not provided, a new provider will be created using the other parameters.
         """
         self._model_name = model_name
         self._provider = provider
 
-        if provider is not None:
-            if isinstance(provider, str):
-                provider = infer_provider(provider)
-            self._system = provider.name
-            self.client = provider.client
-            self._url = str(self.client.base_url)
-        else:
-            if api_key is None:
-                if env_api_key := os.getenv('GEMINI_API_KEY'):
-                    api_key = env_api_key
-                else:
-                    raise UserError('API key must be provided or set in the GEMINI_API_KEY environment variable')
-            self.client = http_client or cached_async_http_client()
-            self._auth = ApiKeyAuth(api_key)
-            self._url = url_template.format(model=model_name)
-
-    @property
-    def auth(self) -> AuthProtocol:
-        assert self._auth is not None, 'Auth not initialized'
-        return self._auth
+        if isinstance(provider, str):
+            provider = infer_provider(provider)
+        self._system = provider.name
+        self.client = provider.client
+        self._url = str(self.client.base_url)
 
     @property
     def base_url(self) -> str:
@@ -252,18 +210,10 @@ class GeminiModel(Model):
         if generation_config:
             request_data['generation_config'] = generation_config
 
-        headers = {
-            'Content-Type': 'application/json',
-            'User-Agent': get_user_agent(),
-        }
-        if self._provider is None:  # pragma: no cover
-            url = self.base_url + ('streamGenerateContent' if streamed else 'generateContent')
-            headers.update(await self.auth.headers())
-        else:
-            url = f'/{self._model_name}:{"streamGenerateContent" if streamed else "generateContent"}'
+        headers = {'Content-Type': 'application/json', 'User-Agent': get_user_agent()}
+        url = f'/{self._model_name}:{"streamGenerateContent" if streamed else "generateContent"}'
 
         request_json = _gemini_request_ta.dump_json(request_data, by_alias=True)
-
         async with self.client.stream(
             'POST',
             url,
@@ -603,12 +553,7 @@ def _process_response_from_parts(
         if 'text' in part:
             items.append(TextPart(content=part['text']))
         elif 'function_call' in part:
-            items.append(
-                ToolCallPart(
-                    tool_name=part['function_call']['name'],
-                    args=part['function_call']['args'],
-                )
-            )
+            items.append(ToolCallPart(tool_name=part['function_call']['name'], args=part['function_call']['args']))
         elif 'function_response' in part:
             raise UnexpectedModelBehavior(
                 f'Unsupported response from Gemini, expected all parts to be function calls or text, got: {part!r}'