google-genai 1.56.0__py3-none-any.whl → 1.58.0__py3-none-any.whl

google/genai/_api_client.py

@@ -715,19 +715,23 @@ class BaseApiClient:
       self._async_httpx_client = self._http_options.httpx_async_client
     else:
       self._async_httpx_client = AsyncHttpxClient(**async_client_args)
+
+    # Initialize the aiohttp client session.
+    self._aiohttp_session: Optional[aiohttp.ClientSession] = None
     if self._use_aiohttp():
       try:
         import aiohttp  # pylint: disable=g-import-not-at-top
-        # Do it once at the genai.Client level. Share among all requests.
-        self._async_client_session_request_args = self._ensure_aiohttp_ssl_ctx(
-            self._http_options
-        )
+
+        if self._http_options.aiohttp_client:
+          self._aiohttp_session = self._http_options.aiohttp_client
+        else:
+          # Do it once at the genai.Client level. Share among all requests.
+          self._async_client_session_request_args = (
+              self._ensure_aiohttp_ssl_ctx(self._http_options)
+          )
       except ImportError:
         pass
 
-    # Initialize the aiohttp client session.
-    self._aiohttp_session: Optional[aiohttp.ClientSession] = None
-
     retry_kwargs = retry_args(self._http_options.retry_options)
     self._websocket_ssl_ctx = self._ensure_websocket_ssl_ctx(self._http_options)
     self._retry = tenacity.Retrying(**retry_kwargs)
@@ -984,12 +988,7 @@ class BaseApiClient:
           self.project = project
 
       if self._credentials:
-        if self._credentials.expired or not self._credentials.token:
-          # Only refresh when it needs to. Default expiration is 3600 seconds.
-          refresh_auth(self._credentials)
-        if not self._credentials.token:
-          raise RuntimeError('Could not resolve API token from the environment')
-        return self._credentials.token  # type: ignore[no-any-return]
+        return get_token_from_credentials(self, self._credentials)  # type: ignore[no-any-return]
       else:
         raise RuntimeError('Could not resolve API token from the environment')
 
@@ -1034,18 +1033,10 @@ class BaseApiClient:
             self.project = project
 
     if self._credentials:
-      if self._credentials.expired or not self._credentials.token:
-        # Only refresh when it needs to. Default expiration is 3600 seconds.
-        async_auth_lock = await self._get_async_auth_lock()
-        async with async_auth_lock:
-          if self._credentials.expired or not self._credentials.token:
-            # Double check that the credentials expired before refreshing.
-            await asyncio.to_thread(refresh_auth, self._credentials)
-
-      if not self._credentials.token:
-        raise RuntimeError('Could not resolve API token from the environment')
-
-      return self._credentials.token
+      return await async_get_token_from_credentials(
+          self,
+          self._credentials
+      )  # type: ignore[no-any-return]
     else:
       raise RuntimeError('Could not resolve API token from the environment')
 
@@ -1905,7 +1896,7 @@ class BaseApiClient:
     # close the client when the object is garbage collected.
     if not self._http_options.httpx_async_client:
       await self._async_httpx_client.aclose()
-    if self._aiohttp_session:
+    if self._aiohttp_session and not self._http_options.aiohttp_client:
       await self._aiohttp_session.close()
 
   def __del__(self) -> None:
@@ -1925,3 +1916,35 @@ class BaseApiClient:
       asyncio.get_running_loop().create_task(self.aclose())
     except Exception:  # pylint: disable=broad-except
       pass
+
+def get_token_from_credentials(
+    client: 'BaseApiClient',
+    credentials: google.auth.credentials.Credentials
+) -> str:
+  """Refreshes the authentication token for the given credentials."""
+  if credentials.expired or not credentials.token:
+    # Only refresh when it needs to. Default expiration is 3600 seconds.
+    refresh_auth(credentials)
+  if not credentials.token:
+    raise RuntimeError('Could not resolve API token from the environment')
+  return credentials.token  # type: ignore[no-any-return]
+
+async def async_get_token_from_credentials(
+    client: 'BaseApiClient',
+    credentials: google.auth.credentials.Credentials
+) -> str:
+  """Refreshes the authentication token for the given credentials."""
+  if credentials.expired or not credentials.token:
+    # Only refresh when it needs to. Default expiration is 3600 seconds.
+    async_auth_lock = await client._get_async_auth_lock()
+    async with async_auth_lock:
+      if credentials.expired or not credentials.token:
+        # Double check that the credentials expired before refreshing.
+        await asyncio.to_thread(refresh_auth, credentials)
+
+  if not credentials.token:
+    raise RuntimeError('Could not resolve API token from the environment')
+
+  return credentials.token    # type: ignore[no-any-return]
+
+

google/genai/_interactions/__init__.py

@@ -53,6 +53,7 @@ from ._exceptions import (
 )
 from ._base_client import DefaultHttpxClient, DefaultAioHttpClient, DefaultAsyncHttpxClient
 from ._utils._logs import setup_logging as _setup_logging
+from ._client_adapter import GeminiNextGenAPIClientAdapter, AsyncGeminiNextGenAPIClientAdapter
 
 __all__ = [
     "types",
@@ -96,6 +97,8 @@ __all__ = [
     "DefaultHttpxClient",
     "DefaultAsyncHttpxClient",
     "DefaultAioHttpClient",
+    "AsyncGeminiNextGenAPIClientAdapter",
+    "GeminiNextGenAPIClientAdapter"
 ]
 
 if not _t.TYPE_CHECKING:

google/genai/_interactions/_base_client.py

@@ -1798,7 +1798,7 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         options: RequestOptions = {},
     ) -> ResponseT:
         opts = FinalRequestOptions.construct(
-            method="patch", url=path, json_data=body, files=to_httpx_files(files), **options
+            method="patch", url=path, json_data=body, files=await async_to_httpx_files(files), **options
         )
         return await self.request(cast_to, opts)
 

google/genai/_interactions/_client.py

@@ -37,6 +37,7 @@ from ._types import (
 )
 from ._utils import is_given, get_async_library
 from ._compat import cached_property
+from ._models import FinalRequestOptions
 from ._version import __version__
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import APIStatusError
@@ -45,6 +46,7 @@ from ._base_client import (
     SyncAPIClient,
     AsyncAPIClient,
 )
+from ._client_adapter import GeminiNextGenAPIClientAdapter, AsyncGeminiNextGenAPIClientAdapter
 
 if TYPE_CHECKING:
     from .resources import interactions
@@ -66,6 +68,7 @@ class GeminiNextGenAPIClient(SyncAPIClient):
     # client options
     api_key: str | None
     api_version: str
+    client_adapter: GeminiNextGenAPIClientAdapter | None
 
     def __init__(
         self,
@@ -81,6 +84,7 @@ class GeminiNextGenAPIClient(SyncAPIClient):
         # We provide a `DefaultHttpxClient` class that you can pass to retain the default values we use for `limits`, `timeout` & `follow_redirects`.
         # See the [httpx documentation](https://www.python-httpx.org/api/#client) for more details.
         http_client: httpx.Client | None = None,
+        client_adapter: GeminiNextGenAPIClientAdapter | None = None,
         # Enable or disable schema validation for data returned by the API.
         # When enabled an error APIResponseValidationError is raised
         # if the API responds with invalid data for the expected schema.
@@ -108,6 +112,8 @@ class GeminiNextGenAPIClient(SyncAPIClient):
         if base_url is None:
             base_url = f"https://generativelanguage.googleapis.com"
 
+        self.client_adapter = client_adapter
+
         super().__init__(
             version=__version__,
             base_url=base_url,
@@ -159,15 +165,35 @@ class GeminiNextGenAPIClient(SyncAPIClient):
 
     @override
     def _validate_headers(self, headers: Headers, custom_headers: Headers) -> None:
+        if headers.get("Authorization") or custom_headers.get("Authorization") or isinstance(custom_headers.get("Authorization"), Omit):
+            return
         if self.api_key and headers.get("x-goog-api-key"):
             return
-        if isinstance(custom_headers.get("x-goog-api-key"), Omit):
+        if custom_headers.get("x-goog-api-key") or isinstance(custom_headers.get("x-goog-api-key"), Omit):
             return
 
         raise TypeError(
             '"Could not resolve authentication method. Expected the api_key to be set. Or for the `x-goog-api-key` headers to be explicitly omitted"'
         )
-
+    
+    @override
+    def _prepare_options(self, options: FinalRequestOptions) -> FinalRequestOptions:
+        if not self.client_adapter or not self.client_adapter.is_vertex_ai():
+            return options
+
+        headers = options.headers or {}
+        has_auth = headers.get("Authorization") or headers.get("x-goog-api-key")   # pytype: disable=attribute-error
+        if has_auth:
+            return options
+
+        adapted_headers = self.client_adapter.get_auth_headers()
+        if adapted_headers:
+            options.headers = {
+                **adapted_headers,
+                **headers
+            }
+        return options
+    
     def copy(
         self,
         *,
@@ -181,6 +207,7 @@ class GeminiNextGenAPIClient(SyncAPIClient):
         set_default_headers: Mapping[str, str] | None = None,
         default_query: Mapping[str, object] | None = None,
         set_default_query: Mapping[str, object] | None = None,
+        client_adapter: GeminiNextGenAPIClientAdapter | None = None,
         _extra_kwargs: Mapping[str, Any] = {},
     ) -> Self:
         """
@@ -214,6 +241,7 @@ class GeminiNextGenAPIClient(SyncAPIClient):
             max_retries=max_retries if is_given(max_retries) else self.max_retries,
             default_headers=headers,
             default_query=params,
+            client_adapter=self.client_adapter or client_adapter,
             **_extra_kwargs,
         )
 
@@ -262,6 +290,7 @@ class AsyncGeminiNextGenAPIClient(AsyncAPIClient):
     # client options
     api_key: str | None
     api_version: str
+    client_adapter: AsyncGeminiNextGenAPIClientAdapter | None
 
     def __init__(
         self,
@@ -277,6 +306,7 @@ class AsyncGeminiNextGenAPIClient(AsyncAPIClient):
         # We provide a `DefaultAsyncHttpxClient` class that you can pass to retain the default values we use for `limits`, `timeout` & `follow_redirects`.
         # See the [httpx documentation](https://www.python-httpx.org/api/#asyncclient) for more details.
         http_client: httpx.AsyncClient | None = None,
+        client_adapter: AsyncGeminiNextGenAPIClientAdapter | None = None,
         # Enable or disable schema validation for data returned by the API.
         # When enabled an error APIResponseValidationError is raised
         # if the API responds with invalid data for the expected schema.
@@ -304,6 +334,8 @@ class AsyncGeminiNextGenAPIClient(AsyncAPIClient):
         if base_url is None:
             base_url = f"https://generativelanguage.googleapis.com"
 
+        self.client_adapter = client_adapter
+
         super().__init__(
             version=__version__,
             base_url=base_url,
@@ -355,14 +387,34 @@ class AsyncGeminiNextGenAPIClient(AsyncAPIClient):
 
     @override
     def _validate_headers(self, headers: Headers, custom_headers: Headers) -> None:
+        if headers.get("Authorization") or custom_headers.get("Authorization") or isinstance(custom_headers.get("Authorization"), Omit):
+            return
         if self.api_key and headers.get("x-goog-api-key"):
             return
-        if isinstance(custom_headers.get("x-goog-api-key"), Omit):
+        if custom_headers.get("x-goog-api-key") or isinstance(custom_headers.get("x-goog-api-key"), Omit):
             return
 
         raise TypeError(
             '"Could not resolve authentication method. Expected the api_key to be set. Or for the `x-goog-api-key` headers to be explicitly omitted"'
         )
+    
+    @override
+    async def _prepare_options(self, options: FinalRequestOptions) -> FinalRequestOptions:
+        if not self.client_adapter or not self.client_adapter.is_vertex_ai():
+            return options
+
+        headers = options.headers or {}
+        has_auth = headers.get("Authorization") or headers.get("x-goog-api-key")     # pytype: disable=attribute-error
+        if has_auth:
+            return options
+
+        adapted_headers = await self.client_adapter.async_get_auth_headers()
+        if adapted_headers:
+            options.headers = {
+                **adapted_headers,
+                **headers
+            }
+        return options
 
     def copy(
         self,
@@ -377,6 +429,7 @@ class AsyncGeminiNextGenAPIClient(AsyncAPIClient):
         set_default_headers: Mapping[str, str] | None = None,
         default_query: Mapping[str, object] | None = None,
         set_default_query: Mapping[str, object] | None = None,
+        client_adapter: AsyncGeminiNextGenAPIClientAdapter | None = None,
         _extra_kwargs: Mapping[str, Any] = {},
     ) -> Self:
         """
@@ -410,6 +463,7 @@ class AsyncGeminiNextGenAPIClient(AsyncAPIClient):
             max_retries=max_retries if is_given(max_retries) else self.max_retries,
             default_headers=headers,
             default_query=params,
+            client_adapter=self.client_adapter or client_adapter,
             **_extra_kwargs,
         )
 

google/genai/_interactions/_client_adapter.py

@@ -0,0 +1,48 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+__all__ = [
+    "GeminiNextGenAPIClientAdapter",
+    "AsyncGeminiNextGenAPIClientAdapter"
+]
+
+class BaseGeminiNextGenAPIClientAdapter(ABC):
+    @abstractmethod
+    def is_vertex_ai(self) -> bool:
+        ...
+
+    @abstractmethod
+    def get_project(self) -> str | None:
+        ...
+
+    @abstractmethod
+    def get_location(self) -> str | None:
+        ...
+
+
+class AsyncGeminiNextGenAPIClientAdapter(BaseGeminiNextGenAPIClientAdapter):
+    @abstractmethod
+    async def async_get_auth_headers(self) -> dict[str, str] | None:
+        ...
+
+
+class GeminiNextGenAPIClientAdapter(BaseGeminiNextGenAPIClientAdapter):
+    @abstractmethod
+    def get_auth_headers(self) -> dict[str, str] | None:
+        ...

google/genai/_interactions/types/__init__.py

@@ -21,6 +21,7 @@ from .tool import Tool as Tool
 from .turn import Turn as Turn
 from .model import Model as Model
 from .usage import Usage as Usage
+from .content import Content as Content
 from .function import Function as Function
 from .annotation import Annotation as Annotation
 from .tool_param import ToolParam as ToolParam
@@ -31,10 +32,12 @@ from .model_param import ModelParam as ModelParam
 from .tool_choice import ToolChoice as ToolChoice
 from .usage_param import UsageParam as UsageParam
 from .content_stop import ContentStop as ContentStop
+from .image_config import ImageConfig as ImageConfig
 from .text_content import TextContent as TextContent
 from .allowed_tools import AllowedTools as AllowedTools
 from .audio_content import AudioContent as AudioContent
 from .content_delta import ContentDelta as ContentDelta
+from .content_param import ContentParam as ContentParam
 from .content_start import ContentStart as ContentStart
 from .image_content import ImageContent as ImageContent
 from .speech_config import SpeechConfig as SpeechConfig
@@ -52,6 +55,7 @@ from .generation_config import GenerationConfig as GenerationConfig
 from .interaction_event import InteractionEvent as InteractionEvent
 from .tool_choice_param import ToolChoiceParam as ToolChoiceParam
 from .document_mime_type import DocumentMimeType as DocumentMimeType
+from .image_config_param import ImageConfigParam as ImageConfigParam
 from .text_content_param import TextContentParam as TextContentParam
 from .tool_choice_config import ToolChoiceConfig as ToolChoiceConfig
 from .url_context_result import URLContextResult as URLContextResult
@@ -73,6 +77,7 @@ from .interaction_get_params import InteractionGetParams as InteractionGetParams
 from .function_result_content import FunctionResultContent as FunctionResultContent
 from .generation_config_param import GenerationConfigParam as GenerationConfigParam
 from .document_mime_type_param import DocumentMimeTypeParam as DocumentMimeTypeParam
+from .file_search_call_content import FileSearchCallContent as FileSearchCallContent
 from .tool_choice_config_param import ToolChoiceConfigParam as ToolChoiceConfigParam
 from .url_context_call_content import URLContextCallContent as URLContextCallContent
 from .url_context_result_param import URLContextResultParam as URLContextResultParam
@@ -93,6 +98,7 @@ from .mcp_server_tool_call_content import MCPServerToolCallContent as MCPServerT
 from .code_execution_call_arguments import CodeExecutionCallArguments as CodeExecutionCallArguments
 from .code_execution_result_content import CodeExecutionResultContent as CodeExecutionResultContent
 from .function_result_content_param import FunctionResultContentParam as FunctionResultContentParam
+from .file_search_call_content_param import FileSearchCallContentParam as FileSearchCallContentParam
 from .mcp_server_tool_result_content import MCPServerToolResultContent as MCPServerToolResultContent
 from .url_context_call_content_param import URLContextCallContentParam as URLContextCallContentParam
 from .deep_research_agent_config_param import DeepResearchAgentConfigParam as DeepResearchAgentConfigParam

google/genai/_interactions/types/audio_content.py

@@ -30,8 +30,10 @@ class AudioContent(BaseModel):
     type: Literal["audio"]
 
     data: Optional[str] = None
+    """The audio content."""
 
     mime_type: Optional[AudioMimeType] = None
     """The mime type of the audio."""
 
     uri: Optional[str] = None
+    """The URI of the audio."""

google/genai/_interactions/types/audio_content_param.py

@@ -34,11 +34,13 @@ class AudioContentParam(TypedDict, total=False):
     type: Required[Literal["audio"]]
 
     data: Annotated[Union[str, Base64FileInput], PropertyInfo(format="base64")]
+    """The audio content."""
 
     mime_type: AudioMimeTypeParam
     """The mime type of the audio."""
 
     uri: str
+    """The URI of the audio."""
 
 
 set_pydantic_config(AudioContentParam, {"arbitrary_types_allowed": True})

google/genai/_interactions/types/content.py

@@ -0,0 +1,65 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from .._utils import PropertyInfo
+from .text_content import TextContent
+from .audio_content import AudioContent
+from .image_content import ImageContent
+from .video_content import VideoContent
+from .thought_content import ThoughtContent
+from .document_content import DocumentContent
+from .function_call_content import FunctionCallContent
+from .function_result_content import FunctionResultContent
+from .file_search_call_content import FileSearchCallContent
+from .url_context_call_content import URLContextCallContent
+from .file_search_result_content import FileSearchResultContent
+from .google_search_call_content import GoogleSearchCallContent
+from .url_context_result_content import URLContextResultContent
+from .code_execution_call_content import CodeExecutionCallContent
+from .google_search_result_content import GoogleSearchResultContent
+from .mcp_server_tool_call_content import MCPServerToolCallContent
+from .code_execution_result_content import CodeExecutionResultContent
+from .mcp_server_tool_result_content import MCPServerToolResultContent
+
+__all__ = ["Content"]
+
+Content: TypeAlias = Annotated[
+    Union[
+        TextContent,
+        ImageContent,
+        AudioContent,
+        DocumentContent,
+        VideoContent,
+        ThoughtContent,
+        FunctionCallContent,
+        FunctionResultContent,
+        CodeExecutionCallContent,
+        CodeExecutionResultContent,
+        URLContextCallContent,
+        URLContextResultContent,
+        GoogleSearchCallContent,
+        GoogleSearchResultContent,
+        MCPServerToolCallContent,
+        MCPServerToolResultContent,
+        FileSearchCallContent,
+        FileSearchResultContent,
+    ],
+    PropertyInfo(discriminator="type"),
+]

google/genai/_interactions/types/content_delta.py

@@ -60,6 +60,7 @@ __all__ = [
     "DeltaMCPServerToolResultDeltaResult",
     "DeltaMCPServerToolResultDeltaResultItems",
     "DeltaMCPServerToolResultDeltaResultItemsItem",
+    "DeltaFileSearchCallDelta",
     "DeltaFileSearchResultDelta",
     "DeltaFileSearchResultDeltaResult",
 ]
@@ -284,6 +285,13 @@ class DeltaMCPServerToolResultDelta(BaseModel):
     server_name: Optional[str] = None
 
 
+class DeltaFileSearchCallDelta(BaseModel):
+    type: Literal["file_search_call"]
+
+    id: Optional[str] = None
+    """A unique ID for this specific tool call."""
+
+
 class DeltaFileSearchResultDeltaResult(BaseModel):
     """The result of the File Search."""
 
@@ -322,6 +330,7 @@ Delta: TypeAlias = Annotated[
         DeltaGoogleSearchResultDelta,
         DeltaMCPServerToolCallDelta,
         DeltaMCPServerToolResultDelta,
+        DeltaFileSearchCallDelta,
         DeltaFileSearchResultDelta,
     ],
     PropertyInfo(discriminator="type"),
@@ -333,8 +342,7 @@ class ContentDelta(BaseModel):
 
     event_id: Optional[str] = None
     """
-    The event_id token to be used to resume the interaction stream, from
-    this event.
+    The event_id token to be used to resume the interaction stream, from this event.
     """
 
     event_type: Optional[Literal["content.delta"]] = None

google/genai/_interactions/types/content_param.py

@@ -0,0 +1,63 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import TypeAlias
+
+from .text_content_param import TextContentParam
+from .audio_content_param import AudioContentParam
+from .image_content_param import ImageContentParam
+from .video_content_param import VideoContentParam
+from .thought_content_param import ThoughtContentParam
+from .document_content_param import DocumentContentParam
+from .function_call_content_param import FunctionCallContentParam
+from .function_result_content_param import FunctionResultContentParam
+from .file_search_call_content_param import FileSearchCallContentParam
+from .url_context_call_content_param import URLContextCallContentParam
+from .file_search_result_content_param import FileSearchResultContentParam
+from .google_search_call_content_param import GoogleSearchCallContentParam
+from .url_context_result_content_param import URLContextResultContentParam
+from .code_execution_call_content_param import CodeExecutionCallContentParam
+from .google_search_result_content_param import GoogleSearchResultContentParam
+from .mcp_server_tool_call_content_param import MCPServerToolCallContentParam
+from .code_execution_result_content_param import CodeExecutionResultContentParam
+from .mcp_server_tool_result_content_param import MCPServerToolResultContentParam
+
+__all__ = ["ContentParam"]
+
+ContentParam: TypeAlias = Union[
+    TextContentParam,
+    ImageContentParam,
+    AudioContentParam,
+    DocumentContentParam,
+    VideoContentParam,
+    ThoughtContentParam,
+    FunctionCallContentParam,
+    FunctionResultContentParam,
+    CodeExecutionCallContentParam,
+    CodeExecutionResultContentParam,
+    URLContextCallContentParam,
+    URLContextResultContentParam,
+    GoogleSearchCallContentParam,
+    GoogleSearchResultContentParam,
+    MCPServerToolCallContentParam,
+    MCPServerToolResultContentParam,
+    FileSearchCallContentParam,
+    FileSearchResultContentParam,
+]

google/genai/_interactions/types/content_start.py

@@ -15,53 +15,13 @@
 
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import Union, Optional
-from typing_extensions import Literal, Annotated, TypeAlias
+from typing import Optional
+from typing_extensions import Literal
 
-from .._utils import PropertyInfo
+from .content import Content
 from .._models import BaseModel
-from .text_content import TextContent
-from .audio_content import AudioContent
-from .image_content import ImageContent
-from .video_content import VideoContent
-from .thought_content import ThoughtContent
-from .document_content import DocumentContent
-from .function_call_content import FunctionCallContent
-from .function_result_content import FunctionResultContent
-from .url_context_call_content import URLContextCallContent
-from .file_search_result_content import FileSearchResultContent
-from .google_search_call_content import GoogleSearchCallContent
-from .url_context_result_content import URLContextResultContent
-from .code_execution_call_content import CodeExecutionCallContent
-from .google_search_result_content import GoogleSearchResultContent
-from .mcp_server_tool_call_content import MCPServerToolCallContent
-from .code_execution_result_content import CodeExecutionResultContent
-from .mcp_server_tool_result_content import MCPServerToolResultContent
 
-__all__ = ["ContentStart", "Content"]
-
-Content: TypeAlias = Annotated[
-    Union[
-        TextContent,
-        ImageContent,
-        AudioContent,
-        DocumentContent,
-        VideoContent,
-        ThoughtContent,
-        FunctionCallContent,
-        FunctionResultContent,
-        CodeExecutionCallContent,
-        CodeExecutionResultContent,
-        URLContextCallContent,
-        URLContextResultContent,
-        GoogleSearchCallContent,
-        GoogleSearchResultContent,
-        MCPServerToolCallContent,
-        MCPServerToolResultContent,
-        FileSearchResultContent,
-    ],
-    PropertyInfo(discriminator="type"),
-]
+__all__ = ["ContentStart"]
 
 
 class ContentStart(BaseModel):
@@ -70,8 +30,7 @@ class ContentStart(BaseModel):
 
     event_id: Optional[str] = None
     """
-    The event_id token to be used to resume the interaction stream, from
-    this event.
+    The event_id token to be used to resume the interaction stream, from this event.
     """
 
     event_type: Optional[Literal["content.start"]] = None

google/genai/_interactions/types/content_stop.py

@@ -26,8 +26,7 @@ __all__ = ["ContentStop"]
 class ContentStop(BaseModel):
     event_id: Optional[str] = None
     """
-    The event_id token to be used to resume the interaction stream, from
-    this event.
+    The event_id token to be used to resume the interaction stream, from this event.
     """
 
     event_type: Optional[Literal["content.stop"]] = None