google-genai 1.27.0__tar.gz → 1.28.0__tar.gz

{google_genai-1.27.0/google_genai.egg-info → google_genai-1.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-genai
-Version: 1.27.0
+Version: 1.28.0
 Summary: GenAI Python SDK
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache-2.0

{google_genai-1.27.0 → google_genai-1.28.0}/google/genai/__init__.py

@@ -15,6 +15,7 @@
 
 """Google Gen AI SDK"""
 
+from . import types
 from . import version
 from .client import Client
 

{google_genai-1.27.0 → google_genai-1.28.0}/google/genai/_api_client.py

@@ -32,6 +32,7 @@ import logging
 import math
 import os
 import ssl
+import random
 import sys
 import threading
 import time
@@ -81,6 +82,7 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger('google_genai._api_client')
 CHUNK_SIZE = 8 * 1024 * 1024  # 8 MB chunk size
+READ_BUFFER_SIZE = 2**20
 MAX_RETRY_COUNT = 3
 INITIAL_RETRY_DELAY = 1  # second
 DELAY_MULTIPLIER = 2
@@ -363,7 +365,7 @@ _RETRY_HTTP_STATUS_CODES = (
 )
 
 
-def _retry_args(options: Optional[HttpRetryOptions]) -> dict[str, Any]:
+def _retry_args(options: Optional[HttpRetryOptions]) -> _common.StringDict:
   """Returns the retry args for the given http retry options.
 
   Args:
@@ -533,17 +535,30 @@ class BaseApiClient:
             + ' precedence over the API key from the environment variables.'
         )
         self.api_key = None
-      if not self.project and not self.api_key:
+
+      # Skip fetching project from ADC if base url is provided in http options.
+      if (
+          not self.project
+          and not self.api_key
+          and not validated_http_options.base_url
+      ):
         credentials, self.project = _load_auth(project=None)
         if not self._credentials:
           self._credentials = credentials
-      if not ((self.project and self.location) or self.api_key):
+
+      has_sufficient_auth = (self.project and self.location) or self.api_key
+
+      if (not has_sufficient_auth and not validated_http_options.base_url):
+        # Skip sufficient auth check if base url is provided in http options.
         raise ValueError(
             'Project and location or API key must be set when using the Vertex '
             'AI API.'
         )
       if self.api_key or self.location == 'global':
         self._http_options.base_url = f'https://aiplatform.googleapis.com/'
+      elif validated_http_options.base_url and not has_sufficient_auth:
+        # Avoid setting default base url and api version if base_url provided.
+        self._http_options.base_url = validated_http_options.base_url
       else:
         self._http_options.base_url = (
             f'https://{self.location}-aiplatform.googleapis.com/'
@@ -592,7 +607,7 @@ class BaseApiClient:
   @staticmethod
   def _ensure_httpx_ssl_ctx(
       options: HttpOptions,
-  ) -> Tuple[dict[str, Any], dict[str, Any]]:
+  ) -> Tuple[_common.StringDict, _common.StringDict]:
     """Ensures the SSL context is present in the HTTPX client args.
 
     Creates a default SSL context if one is not provided.
@@ -626,9 +641,9 @@ class BaseApiClient:
       )
 
     def _maybe_set(
-        args: Optional[dict[str, Any]],
+        args: Optional[_common.StringDict],
         ctx: ssl.SSLContext,
-    ) -> dict[str, Any]:
+    ) -> _common.StringDict:
       """Sets the SSL context in the client args if not set.
 
       Does not override the SSL context if it is already set.
@@ -656,7 +671,7 @@ class BaseApiClient:
     )
 
   @staticmethod
-  def _ensure_aiohttp_ssl_ctx(options: HttpOptions) -> dict[str, Any]:
+  def _ensure_aiohttp_ssl_ctx(options: HttpOptions) -> _common.StringDict:
     """Ensures the SSL context is present in the async client args.
 
     Creates a default SSL context if one is not provided.
@@ -684,9 +699,9 @@ class BaseApiClient:
       )
 
     def _maybe_set(
-        args: Optional[dict[str, Any]],
+        args: Optional[_common.StringDict],
         ctx: ssl.SSLContext,
-    ) -> dict[str, Any]:
+    ) -> _common.StringDict:
       """Sets the SSL context in the client args if not set.
 
       Does not override the SSL context if it is already set.
@@ -714,7 +729,7 @@ class BaseApiClient:
     return _maybe_set(async_args, ctx)
 
   @staticmethod
-  def _ensure_websocket_ssl_ctx(options: HttpOptions) -> dict[str, Any]:
+  def _ensure_websocket_ssl_ctx(options: HttpOptions) -> _common.StringDict:
     """Ensures the SSL context is present in the async client args.
 
     Creates a default SSL context if one is not provided.
@@ -742,9 +757,9 @@ class BaseApiClient:
       )
 
     def _maybe_set(
-        args: Optional[dict[str, Any]],
+        args: Optional[_common.StringDict],
         ctx: ssl.SSLContext,
-    ) -> dict[str, Any]:
+    ) -> _common.StringDict:
       """Sets the SSL context in the client args if not set.
 
       Does not override the SSL context if it is already set.
@@ -864,7 +879,7 @@ class BaseApiClient:
         self.vertexai
         and not path.startswith('projects/')
         and not query_vertex_base_models
-        and not self.api_key
+        and (self.project or self.location)
     ):
       path = f'projects/{self.project}/locations/{self.location}/' + path
 
@@ -920,7 +935,8 @@ class BaseApiClient:
       stream: bool = False,
   ) -> HttpResponse:
     data: Optional[Union[str, bytes]] = None
-    if self.vertexai and not self.api_key:
+    # If using proj/location, fetch ADC
+    if self.vertexai and (self.project or self.location):
       http_request.headers['Authorization'] = f'Bearer {self._access_token()}'
       if self._credentials and self._credentials.quota_project_id:
         http_request.headers['x-goog-user-project'] = (
@@ -963,8 +979,21 @@ class BaseApiClient:
   def _request(
       self,
       http_request: HttpRequest,
+      http_options: Optional[HttpOptionsOrDict] = None,
       stream: bool = False,
   ) -> HttpResponse:
+    if http_options:
+      parameter_model = (
+          HttpOptions(**http_options)
+          if isinstance(http_options, dict)
+          else http_options
+      )
+      # Support per request retry options.
+      if parameter_model.retry_options:
+        retry_kwargs = _retry_args(parameter_model.retry_options)
+        retry = tenacity.Retrying(**retry_kwargs)
+        return retry(self._request_once, http_request, stream)  # type: ignore[no-any-return]
+
     return self._retry(self._request_once, http_request, stream)  # type: ignore[no-any-return]
 
   async def _async_request_once(
@@ -972,7 +1001,8 @@ class BaseApiClient:
   ) -> HttpResponse:
     data: Optional[Union[str, bytes]] = None
 
-    if self.vertexai and not self.api_key:
+    # If using proj/location, fetch ADC
+    if self.vertexai and (self.project or self.location):
       http_request.headers['Authorization'] = (
           f'Bearer {await self._async_access_token()}'
       )
@@ -993,15 +1023,43 @@ class BaseApiClient:
         session = aiohttp.ClientSession(
             headers=http_request.headers,
             trust_env=True,
+            read_bufsize=READ_BUFFER_SIZE,
         )
-        response = await session.request(
-            method=http_request.method,
-            url=http_request.url,
-            headers=http_request.headers,
-            data=data,
-            timeout=aiohttp.ClientTimeout(connect=http_request.timeout),
-            **self._async_client_session_request_args,
-        )
+        try:
+          response = await session.request(
+              method=http_request.method,
+              url=http_request.url,
+              headers=http_request.headers,
+              data=data,
+              timeout=aiohttp.ClientTimeout(connect=http_request.timeout),
+              **self._async_client_session_request_args,
+          )
+        except (
+            aiohttp.ClientConnectorError,
+            aiohttp.ClientConnectorDNSError,
+            aiohttp.ClientOSError,
+            aiohttp.ServerDisconnectedError,
+        ) as e:
+          await asyncio.sleep(1 + random.randint(0, 9))
+          logger.info('Retrying due to aiohttp error: %s' % e)
+          # Retrieve the SSL context from the session.
+          self._async_client_session_request_args = (
+              self._ensure_aiohttp_ssl_ctx(self._http_options)
+          )
+          # Instantiate a new session with the updated SSL context.
+          session = aiohttp.ClientSession(
+              headers=http_request.headers,
+              trust_env=True,
+              read_bufsize=READ_BUFFER_SIZE,
+          )
+          response = await session.request(
+              method=http_request.method,
+              url=http_request.url,
+              headers=http_request.headers,
+              data=data,
+              timeout=aiohttp.ClientTimeout(connect=http_request.timeout),
+              **self._async_client_session_request_args,
+          )
 
         await errors.APIError.raise_for_async_response(response)
         return HttpResponse(response.headers, response, session=session)
@@ -1022,20 +1080,50 @@ class BaseApiClient:
         return HttpResponse(client_response.headers, client_response)
     else:
       if self._use_aiohttp():
-        async with aiohttp.ClientSession(
-            headers=http_request.headers,
-            trust_env=True,
-        ) as session:
-          response = await session.request(
-              method=http_request.method,
-              url=http_request.url,
+        try:
+          async with aiohttp.ClientSession(
               headers=http_request.headers,
-              data=data,
-              timeout=aiohttp.ClientTimeout(connect=http_request.timeout),
-              **self._async_client_session_request_args,
+              trust_env=True,
+              read_bufsize=READ_BUFFER_SIZE,
+          ) as session:
+            response = await session.request(
+                method=http_request.method,
+                url=http_request.url,
+                headers=http_request.headers,
+                data=data,
+                timeout=aiohttp.ClientTimeout(connect=http_request.timeout),
+                **self._async_client_session_request_args,
+            )
+            await errors.APIError.raise_for_async_response(response)
+            return HttpResponse(response.headers, [await response.text()])
+        except (
+            aiohttp.ClientConnectorError,
+            aiohttp.ClientConnectorDNSError,
+            aiohttp.ClientOSError,
+            aiohttp.ServerDisconnectedError,
+        ) as e:
+          await asyncio.sleep(1 + random.randint(0, 9))
+          logger.info('Retrying due to aiohttp error: %s' % e)
+          # Retrieve the SSL context from the session.
+          self._async_client_session_request_args = (
+              self._ensure_aiohttp_ssl_ctx(self._http_options)
           )
-          await errors.APIError.raise_for_async_response(response)
-          return HttpResponse(response.headers, [await response.text()])
+          # Instantiate a new session with the updated SSL context.
+          async with aiohttp.ClientSession(
+              headers=http_request.headers,
+              trust_env=True,
+              read_bufsize=READ_BUFFER_SIZE,
+          ) as session:
+            response = await session.request(
+                method=http_request.method,
+                url=http_request.url,
+                headers=http_request.headers,
+                data=data,
+                timeout=aiohttp.ClientTimeout(connect=http_request.timeout),
+                **self._async_client_session_request_args,
+            )
+            await errors.APIError.raise_for_async_response(response)
+            return HttpResponse(response.headers, [await response.text()])
       else:
         # aiohttp is not available. Fall back to httpx.
         client_response = await self._async_httpx_client.request(
@@ -1051,13 +1139,25 @@ class BaseApiClient:
   async def _async_request(
       self,
       http_request: HttpRequest,
+      http_options: Optional[HttpOptionsOrDict] = None,
       stream: bool = False,
   ) -> HttpResponse:
+    if http_options:
+      parameter_model = (
+          HttpOptions(**http_options)
+          if isinstance(http_options, dict)
+          else http_options
+      )
+      # Support per request retry options.
+      if parameter_model.retry_options:
+        retry_kwargs = _retry_args(parameter_model.retry_options)
+        retry = tenacity.AsyncRetrying(**retry_kwargs)
+        return await retry(self._async_request_once, http_request, stream)  # type: ignore[no-any-return]
     return await self._async_retry(  # type: ignore[no-any-return]
         self._async_request_once, http_request, stream
     )
 
-  def get_read_only_http_options(self) -> dict[str, Any]:
+  def get_read_only_http_options(self) -> _common.StringDict:
     if isinstance(self._http_options, BaseModel):
       copied = self._http_options.model_dump()
     else:
@@ -1074,7 +1174,7 @@ class BaseApiClient:
     http_request = self._build_request(
         http_method, path, request_dict, http_options
     )
-    response = self._request(http_request, stream=False)
+    response = self._request(http_request, http_options, stream=False)
     response_body = (
         response.response_stream[0] if response.response_stream else ''
     )
@@ -1091,7 +1191,7 @@ class BaseApiClient:
         http_method, path, request_dict, http_options
     )
 
-    session_response = self._request(http_request, stream=True)
+    session_response = self._request(http_request, http_options, stream=True)
     for chunk in session_response.segments():
       yield SdkHttpResponse(
           headers=session_response.headers, body=json.dumps(chunk)
@@ -1108,7 +1208,9 @@ class BaseApiClient:
         http_method, path, request_dict, http_options
     )
 
-    result = await self._async_request(http_request=http_request, stream=False)
+    result = await self._async_request(
+        http_request=http_request, http_options=http_options, stream=False
+    )
     response_body = result.response_stream[0] if result.response_stream else ''
     return SdkHttpResponse(headers=result.headers, body=response_body)
 
@@ -1340,6 +1442,7 @@ class BaseApiClient:
       async with aiohttp.ClientSession(
           headers=self._http_options.headers,
           trust_env=True,
+          read_bufsize=READ_BUFFER_SIZE,
       ) as session:
         while True:
           if isinstance(file, io.IOBase):
@@ -1523,6 +1626,7 @@ class BaseApiClient:
       async with aiohttp.ClientSession(
           headers=http_request.headers,
           trust_env=True,
+          read_bufsize=READ_BUFFER_SIZE,
       ) as session:
         response = await session.request(
             method=http_request.method,

{google_genai-1.27.0 → google_genai-1.28.0}/google/genai/_common.py

@@ -22,15 +22,17 @@ import enum
 import functools
 import logging
 import typing
-from typing import Any, Callable, Optional, FrozenSet, Union, get_args, get_origin
+from typing import Any, Callable, FrozenSet, Optional, Union, get_args, get_origin
 import uuid
 import warnings
-
 import pydantic
 from pydantic import alias_generators
+from typing_extensions import TypeAlias
 
 logger = logging.getLogger('google_genai._common')
 
+StringDict: TypeAlias = dict[str, Any]
+
 
 class ExperimentalWarning(Warning):
   """Warning for experimental features."""
@@ -355,7 +357,6 @@ def _pretty_repr(
     return raw_repr.replace('\n', f'\n{next_indent_str}')
 
 
-
 def _format_collection(
     obj: Any,
     *,
@@ -555,7 +556,9 @@ def _normalize_key_for_matching(key_str: str) -> str:
   return key_str.replace("_", "").lower()
 
 
-def align_key_case(target_dict: dict[str, Any], update_dict: dict[str, Any]) -> dict[str, Any]:
+def align_key_case(
+    target_dict: StringDict, update_dict: StringDict
+) -> StringDict:
   """Aligns the keys of update_dict to the case of target_dict keys.
 
   Args:
@@ -565,7 +568,7 @@ def align_key_case(target_dict: dict[str, Any], update_dict: dict[str, Any]) ->
   Returns:
       A new dictionary with keys aligned to target_dict's key casing.
   """
-  aligned_update_dict: dict[str, Any] = {}
+  aligned_update_dict: StringDict = {}
   target_keys_map = {_normalize_key_for_matching(key): key for key in target_dict.keys()}
 
   for key, value in update_dict.items():
@@ -587,7 +590,7 @@ def align_key_case(target_dict: dict[str, Any], update_dict: dict[str, Any]) ->
 
 
 def recursive_dict_update(
-    target_dict: dict[str, Any], update_dict: dict[str, Any]
+    target_dict: StringDict, update_dict: StringDict
 ) -> None:
   """Recursively updates a target dictionary with values from an update dictionary.
 

{google_genai-1.27.0 → google_genai-1.28.0}/google/genai/_extra_utils.py

@@ -155,8 +155,8 @@ def get_function_map(
 
 
 def convert_number_values_for_dict_function_call_args(
-    args: dict[str, Any],
-) -> dict[str, Any]:
+    args: _common.StringDict,
+) -> _common.StringDict:
   """Converts float values in dict with no decimal to integers."""
   return {
       key: convert_number_values_for_function_call_args(value)
@@ -257,8 +257,8 @@ def convert_if_exist_pydantic_model(
 
 
 def convert_argument_from_function(
-    args: dict[str, Any], function: Callable[..., Any]
-) -> dict[str, Any]:
+    args: _common.StringDict, function: Callable[..., Any]
+) -> _common.StringDict:
   signature = inspect.signature(function)
   func_name = function.__name__
   converted_args = {}
@@ -274,7 +274,7 @@ def convert_argument_from_function(
 
 
 def invoke_function_from_dict_args(
-    args: Dict[str, Any], function_to_invoke: Callable[..., Any]
+    args: _common.StringDict, function_to_invoke: Callable[..., Any]
 ) -> Any:
   converted_args = convert_argument_from_function(args, function_to_invoke)
   try:
@@ -288,7 +288,7 @@ def invoke_function_from_dict_args(
 
 
 async def invoke_function_from_dict_args_async(
-    args: Dict[str, Any], function_to_invoke: Callable[..., Any]
+    args: _common.StringDict, function_to_invoke: Callable[..., Any]
 ) -> Any:
   converted_args = convert_argument_from_function(args, function_to_invoke)
   try:
@@ -321,7 +321,7 @@ def get_function_response_parts(
         args = convert_number_values_for_dict_function_call_args(
             part.function_call.args
         )
-        func_response: dict[str, Any]
+        func_response: _common.StringDict
         try:
           if not isinstance(func, McpToGenAiToolAdapter):
             func_response = {
@@ -356,7 +356,7 @@ async def get_function_response_parts_async(
         args = convert_number_values_for_dict_function_call_args(
             part.function_call.args
         )
-        func_response: dict[str, Any]
+        func_response: _common.StringDict
         try:
           if isinstance(func, McpToGenAiToolAdapter):
             mcp_tool_response = await func.call_tool(

{google_genai-1.27.0 → google_genai-1.28.0}/google/genai/_mcp_utils.py

@@ -19,6 +19,7 @@ from importlib.metadata import PackageNotFoundError, version
 import typing
 from typing import Any
 
+from . import _common
 from . import types
 
 if typing.TYPE_CHECKING:
@@ -89,7 +90,9 @@ def set_mcp_usage_header(headers: dict[str, str]) -> None:
   ).lstrip()
 
 
-def _filter_to_supported_schema(schema: dict[str, Any]) -> dict[str, Any]:
+def _filter_to_supported_schema(
+    schema: _common.StringDict,
+) -> _common.StringDict:
   """Filters the schema to only include fields that are supported by JSONSchema."""
   supported_fields: set[str] = set(types.JSONSchema.model_fields.keys())
   schema_field_names: tuple[str] = ("items",)  # 'additional_properties' to come

{google_genai-1.27.0 → google_genai-1.28.0}/google/genai/_replay_api_client.py

@@ -479,13 +479,14 @@ class ReplayApiClient(BaseApiClient):
   def _request(
       self,
       http_request: HttpRequest,
+      http_options: Optional[HttpOptionsOrDict] = None,
       stream: bool = False,
   ) -> HttpResponse:
     self._initialize_replay_session_if_not_loaded()
     if self._should_call_api():
       _debug_print('api mode request: %s' % http_request)
       try:
-        result = super()._request(http_request, stream)
+        result = super()._request(http_request, http_options, stream)
       except errors.APIError as e:
         self._record_interaction(http_request, e)
         raise e
@@ -507,13 +508,16 @@ class ReplayApiClient(BaseApiClient):
   async def _async_request(
       self,
       http_request: HttpRequest,
+      http_options: Optional[HttpOptionsOrDict] = None,
       stream: bool = False,
   ) -> HttpResponse:
     self._initialize_replay_session_if_not_loaded()
     if self._should_call_api():
       _debug_print('api mode request: %s' % http_request)
       try:
-        result = await super()._async_request(http_request, stream)
+        result = await super()._async_request(
+            http_request, http_options, stream
+        )
       except errors.APIError as e:
         self._record_interaction(http_request, e)
         raise e

{google_genai-1.27.0 → google_genai-1.28.0}/google/genai/_transformers.py

@@ -35,6 +35,7 @@ if typing.TYPE_CHECKING:
 import pydantic
 
 from . import _api_client
+from . import _common
 from . import types
 
 logger = logging.getLogger('google_genai._transformers')
@@ -195,20 +196,20 @@ def t_models_url(
 
 
 def t_extract_models(
-    response: dict[str, Any],
-) -> list[dict[str, Any]]:
+    response: _common.StringDict,
+) -> list[_common.StringDict]:
   if not response:
     return []
 
-  models: Optional[list[dict[str, Any]]] = response.get('models')
+  models: Optional[list[_common.StringDict]] = response.get('models')
   if models is not None:
     return models
 
-  tuned_models: Optional[list[dict[str, Any]]] = response.get('tunedModels')
+  tuned_models: Optional[list[_common.StringDict]] = response.get('tunedModels')
   if tuned_models is not None:
     return tuned_models
 
-  publisher_models: Optional[list[dict[str, Any]]] = response.get(
+  publisher_models: Optional[list[_common.StringDict]] = response.get(
       'publisherModels'
   )
   if publisher_models is not None:
@@ -560,7 +561,7 @@ def t_contents(
   return result
 
 
-def handle_null_fields(schema: dict[str, Any]) -> None:
+def handle_null_fields(schema: _common.StringDict) -> None:
   """Process null fields in the schema so it is compatible with OpenAPI.
 
   The OpenAPI spec does not support 'type: 'null' in the schema. This function
@@ -639,9 +640,9 @@ def _raise_for_unsupported_mldev_properties(
 
 
 def process_schema(
-    schema: dict[str, Any],
+    schema: _common.StringDict,
     client: Optional[_api_client.BaseApiClient],
-    defs: Optional[dict[str, Any]] = None,
+    defs: Optional[_common.StringDict] = None,
     *,
     order_properties: bool = True,
 ) -> None:
@@ -740,7 +741,7 @@ def process_schema(
   if (ref := schema.pop('$ref', None)) is not None:
     schema.update(defs[ref.split('defs/')[-1]])
 
-  def _recurse(sub_schema: dict[str, Any]) -> dict[str, Any]:
+  def _recurse(sub_schema: _common.StringDict) -> _common.StringDict:
     """Returns the processed `sub_schema`, resolving its '$ref' if any."""
     if (ref := sub_schema.pop('$ref', None)) is not None:
       sub_schema = defs[ref.split('defs/')[-1]]
@@ -820,7 +821,7 @@ def _process_enum(
 
 def _is_type_dict_str_any(
     origin: Union[types.SchemaUnionDict, Any],
-) -> TypeGuard[dict[str, Any]]:
+) -> TypeGuard[_common.StringDict]:
   """Verifies the schema is of type dict[str, Any] for mypy type checking."""
   return isinstance(origin, dict) and all(
       isinstance(key, str) for key in origin
@@ -1075,10 +1076,10 @@ LRO_POLLING_MULTIPLIER = 1.5
 
 
 def t_resolve_operation(
-    api_client: _api_client.BaseApiClient, struct: dict[str, Any]
+    api_client: _api_client.BaseApiClient, struct: _common.StringDict
 ) -> Any:
   if (name := struct.get('name')) and '/operations/' in name:
-    operation: dict[str, Any] = struct
+    operation: _common.StringDict = struct
     total_seconds = 0.0
     delay_seconds = LRO_POLLING_INITIAL_DELAY_SECONDS
     while operation.get('done') != True:

{google_genai-1.27.0 → google_genai-1.28.0}/google/genai/errors.py

@@ -65,7 +65,7 @@ class APIError(Exception):
         'code', response_json.get('error', {}).get('code', None)
     )
 
-  def _to_replay_record(self) -> dict[str, Any]:
+  def _to_replay_record(self) -> _common.StringDict:
     """Returns a dictionary representation of the error for replay recording.
 
     details is not included since it may expose internal information in the

{google_genai-1.27.0 → google_genai-1.28.0}/google/genai/live.py

@@ -33,7 +33,6 @@ from . import _common
 from . import _live_converters as live_converters
 from . import _mcp_utils
 from . import _transformers as t
-from . import client
 from . import errors
 from . import types
 from ._api_client import BaseApiClient
@@ -288,7 +287,7 @@ class AsyncSession:
           print(f'{msg.text}')
     ```
     """
-    kwargs: dict[str, Any] = {}
+    kwargs: _common.StringDict = {}
     if media is not None:
       kwargs['media'] = media
     if audio is not None:
@@ -639,7 +638,7 @@ class AsyncSession:
     elif isinstance(formatted_input, Sequence) and any(
         isinstance(c, str) for c in formatted_input
     ):
-      to_object: dict[str, Any] = {}
+      to_object: _common.StringDict = {}
       content_input_parts: list[types.PartUnion] = []
       for item in formatted_input:
         if isinstance(item, get_args(types.PartUnion)):