google-genai 1.22.0__tar.gz → 1.24.0__tar.gz

{google_genai-1.22.0/google_genai.egg-info → google_genai-1.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-genai
-Version: 1.22.0
+Version: 1.24.0
 Summary: GenAI Python SDK
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache-2.0
@@ -743,6 +743,53 @@ response = client.models.generate_content(
     ),
 )
 ```
+
+#### Model Context Protocol (MCP) support (experimental)
+
+Built-in [MCP](https://modelcontextprotocol.io/introduction) support is an
+experimental feature. You can pass a local MCP server as a tool directly.
+
+```python
+import os
+import asyncio
+from datetime import datetime
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+from google import genai
+
+client = genai.Client()
+
+# Create server parameters for stdio connection
+server_params = StdioServerParameters(
+    command="npx",  # Executable
+    args=["-y", "@philschmid/weather-mcp"],  # MCP Server
+    env=None,  # Optional environment variables
+)
+
+async def run():
+    async with stdio_client(server_params) as (read, write):
+        async with ClientSession(read, write) as session:
+            # Prompt to get the weather for the current day in London.
+            prompt = f"What is the weather in London in {datetime.now().strftime('%Y-%m-%d')}?"
+
+            # Initialize the connection between client and server
+            await session.initialize()
+
+            # Send request to the model with MCP function declarations
+            response = await client.aio.models.generate_content(
+                model="gemini-2.5-flash",
+                contents=prompt,
+                config=genai.types.GenerateContentConfig(
+                    temperature=0,
+                    tools=[session],  # uses the session, will automatically call the tool using automatic function calling
+                ),
+            )
+            print(response.text)
+
+# Start the asyncio event loop and run the main function
+asyncio.run(run())
+```
+
 ### JSON Response Schema
 
 However you define your schema, don't duplicate it in your input prompt,
@@ -1085,9 +1132,9 @@ response3.generated_images[0].image.show()
 
 ### Veo
 
-#### Generate Videos
+Support for generating videos is considered public preview
 
-Support for generate videos in Vertex and Gemini Developer API is behind an allowlist
+#### Generate Videos (Text to Video)
 
 ```python
 from google.genai import types
@@ -1098,7 +1145,6 @@ operation = client.models.generate_videos(
     prompt='A neon hologram of a cat driving at top speed',
     config=types.GenerateVideosConfig(
         number_of_videos=1,
-        fps=24,
         duration_seconds=5,
         enhance_prompt=True,
     ),
@@ -1109,7 +1155,73 @@ while not operation.done:
     time.sleep(20)
     operation = client.operations.get(operation)
 
-video = operation.result.generated_videos[0].video
+video = operation.response.generated_videos[0].video
+video.show()
+```
+
+#### Generate Videos (Image to Video)
+
+```python
+from google.genai import types
+
+# Read local image (uses mimetypes.guess_type to infer mime type)
+image = types.Image.from_file("local/path/file.png")
+
+# Create operation
+operation = client.models.generate_videos(
+    model='veo-2.0-generate-001',
+    # Prompt is optional if image is provided
+    prompt='Night sky',
+    image=image,
+    config=types.GenerateVideosConfig(
+        number_of_videos=1,
+        duration_seconds=5,
+        enhance_prompt=True,
+        # Can also pass an Image into last_frame for frame interpolation
+    ),
+)
+
+# Poll operation
+while not operation.done:
+    time.sleep(20)
+    operation = client.operations.get(operation)
+
+video = operation.response.generated_videos[0].video
+video.show()
+```
+
+#### Generate Videos (Video to Video)
+
+Currently, only Vertex supports Video to Video generation (Video extension).
+
+```python
+from google.genai import types
+
+# Read local video (uses mimetypes.guess_type to infer mime type)
+video = types.Video.from_file("local/path/video.mp4")
+
+# Create operation
+operation = client.models.generate_videos(
+    model='veo-2.0-generate-001',
+    # Prompt is optional if Video is provided
+    prompt='Night sky',
+    # Input video must be in GCS
+    video=types.Video(
+        uri="gs://bucket-name/inputs/videos/cat_driving.mp4",
+    ),
+    config=types.GenerateVideosConfig(
+        number_of_videos=1,
+        duration_seconds=5,
+        enhance_prompt=True,
+    ),
+)
+
+# Poll operation
+while not operation.done:
+    time.sleep(20)
+    operation = client.operations.get(operation)
+
+video = operation.response.generated_videos[0].video
 video.show()
 ```
 
@@ -1260,7 +1372,7 @@ client.
 
 ### Tune
 
--   Vertex AI supports tuning from GCS source
+-   Vertex AI supports tuning from GCS source or from a Vertex Multimodal Dataset
 -   Gemini Developer API supports tuning from inline examples
 
 ```python
@@ -1269,10 +1381,12 @@ from google.genai import types
 if client.vertexai:
     model = 'gemini-2.0-flash-001'
     training_dataset = types.TuningDataset(
+      # or gcs_uri=my_vertex_multimodal_dataset
         gcs_uri='gs://cloud-samples-data/ai-platform/generative_ai/gemini-1_5/text/sft_train_data.jsonl',
     )
 else:
     model = 'models/gemini-2.0-flash-001'
+    # or gcs_uri=my_vertex_multimodal_dataset.resource_name
     training_dataset = types.TuningDataset(
         examples=[
             types.TuningExample(

{google_genai-1.22.0 → google_genai-1.24.0}/README.md

@@ -709,6 +709,53 @@ response = client.models.generate_content(
     ),
 )
 ```
+
+#### Model Context Protocol (MCP) support (experimental)
+
+Built-in [MCP](https://modelcontextprotocol.io/introduction) support is an
+experimental feature. You can pass a local MCP server as a tool directly.
+
+```python
+import os
+import asyncio
+from datetime import datetime
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+from google import genai
+
+client = genai.Client()
+
+# Create server parameters for stdio connection
+server_params = StdioServerParameters(
+    command="npx",  # Executable
+    args=["-y", "@philschmid/weather-mcp"],  # MCP Server
+    env=None,  # Optional environment variables
+)
+
+async def run():
+    async with stdio_client(server_params) as (read, write):
+        async with ClientSession(read, write) as session:
+            # Prompt to get the weather for the current day in London.
+            prompt = f"What is the weather in London in {datetime.now().strftime('%Y-%m-%d')}?"
+
+            # Initialize the connection between client and server
+            await session.initialize()
+
+            # Send request to the model with MCP function declarations
+            response = await client.aio.models.generate_content(
+                model="gemini-2.5-flash",
+                contents=prompt,
+                config=genai.types.GenerateContentConfig(
+                    temperature=0,
+                    tools=[session],  # uses the session, will automatically call the tool using automatic function calling
+                ),
+            )
+            print(response.text)
+
+# Start the asyncio event loop and run the main function
+asyncio.run(run())
+```
+
 ### JSON Response Schema
 
 However you define your schema, don't duplicate it in your input prompt,
@@ -1051,9 +1098,9 @@ response3.generated_images[0].image.show()
 
 ### Veo
 
-#### Generate Videos
+Support for generating videos is considered public preview
 
-Support for generate videos in Vertex and Gemini Developer API is behind an allowlist
+#### Generate Videos (Text to Video)
 
 ```python
 from google.genai import types
@@ -1064,7 +1111,6 @@ operation = client.models.generate_videos(
     prompt='A neon hologram of a cat driving at top speed',
     config=types.GenerateVideosConfig(
         number_of_videos=1,
-        fps=24,
         duration_seconds=5,
         enhance_prompt=True,
     ),
@@ -1075,7 +1121,73 @@ while not operation.done:
     time.sleep(20)
     operation = client.operations.get(operation)
 
-video = operation.result.generated_videos[0].video
+video = operation.response.generated_videos[0].video
+video.show()
+```
+
+#### Generate Videos (Image to Video)
+
+```python
+from google.genai import types
+
+# Read local image (uses mimetypes.guess_type to infer mime type)
+image = types.Image.from_file("local/path/file.png")
+
+# Create operation
+operation = client.models.generate_videos(
+    model='veo-2.0-generate-001',
+    # Prompt is optional if image is provided
+    prompt='Night sky',
+    image=image,
+    config=types.GenerateVideosConfig(
+        number_of_videos=1,
+        duration_seconds=5,
+        enhance_prompt=True,
+        # Can also pass an Image into last_frame for frame interpolation
+    ),
+)
+
+# Poll operation
+while not operation.done:
+    time.sleep(20)
+    operation = client.operations.get(operation)
+
+video = operation.response.generated_videos[0].video
+video.show()
+```
+
+#### Generate Videos (Video to Video)
+
+Currently, only Vertex supports Video to Video generation (Video extension).
+
+```python
+from google.genai import types
+
+# Read local video (uses mimetypes.guess_type to infer mime type)
+video = types.Video.from_file("local/path/video.mp4")
+
+# Create operation
+operation = client.models.generate_videos(
+    model='veo-2.0-generate-001',
+    # Prompt is optional if Video is provided
+    prompt='Night sky',
+    # Input video must be in GCS
+    video=types.Video(
+        uri="gs://bucket-name/inputs/videos/cat_driving.mp4",
+    ),
+    config=types.GenerateVideosConfig(
+        number_of_videos=1,
+        duration_seconds=5,
+        enhance_prompt=True,
+    ),
+)
+
+# Poll operation
+while not operation.done:
+    time.sleep(20)
+    operation = client.operations.get(operation)
+
+video = operation.response.generated_videos[0].video
 video.show()
 ```
 
@@ -1226,7 +1338,7 @@ client.
 
 ### Tune
 
--   Vertex AI supports tuning from GCS source
+-   Vertex AI supports tuning from GCS source or from a Vertex Multimodal Dataset
 -   Gemini Developer API supports tuning from inline examples
 
 ```python
@@ -1235,10 +1347,12 @@ from google.genai import types
 if client.vertexai:
     model = 'gemini-2.0-flash-001'
     training_dataset = types.TuningDataset(
+      # or gcs_uri=my_vertex_multimodal_dataset
         gcs_uri='gs://cloud-samples-data/ai-platform/generative_ai/gemini-1_5/text/sft_train_data.jsonl',
     )
 else:
     model = 'models/gemini-2.0-flash-001'
+    # or gcs_uri=my_vertex_multimodal_dataset.resource_name
     training_dataset = types.TuningDataset(
         examples=[
             types.TuningExample(

{google_genai-1.22.0 → google_genai-1.24.0}/google/genai/_api_client.py

@@ -60,6 +60,11 @@ from .types import HttpOptionsOrDict
 from .types import HttpResponse as SdkHttpResponse
 from .types import HttpRetryOptions
 
+try:
+  from websockets.asyncio.client import connect as ws_connect
+except ModuleNotFoundError:
+  # This try/except is for TAP, mypy complains about it which is why we have the type: ignore
+  from websockets.client import connect as ws_connect  # type: ignore
 
 has_aiohttp = False
 try:
@@ -69,8 +74,6 @@ try:
 except ImportError:
   pass
 
-# internal comment
-
 
 if TYPE_CHECKING:
   from multidict import CIMultiDictProxy
@@ -227,11 +230,13 @@ class HttpResponse:
       headers: Union[dict[str, str], httpx.Headers, 'CIMultiDictProxy[str]'],
       response_stream: Union[Any, str] = None,
       byte_stream: Union[Any, bytes] = None,
+      session: Optional['aiohttp.ClientSession'] = None,
   ):
     self.status_code: int = 200
     self.headers = headers
     self.response_stream = response_stream
     self.byte_stream = byte_stream
+    self._session = session
 
   # Async iterator for async streaming.
   def __aiter__(self) -> 'HttpResponse':
@@ -291,16 +296,23 @@ class HttpResponse:
               chunk = chunk[len('data: ') :]
             yield json.loads(chunk)
       elif hasattr(self.response_stream, 'content'):
-        async for chunk in self.response_stream.content.iter_any():
-          # This is aiohttp.ClientResponse.
-          if chunk:
+        # This is aiohttp.ClientResponse.
+        try:
+          while True:
+            chunk = await self.response_stream.content.readline()
+            if not chunk:
+              break
             # In async streaming mode, the chunk of JSON is prefixed with
             # "data:" which we must strip before parsing.
-            if not isinstance(chunk, str):
-              chunk = chunk.decode('utf-8')
+            chunk = chunk.decode('utf-8')
             if chunk.startswith('data: '):
               chunk = chunk[len('data: ') :]
-            yield json.loads(chunk)
+            chunk = chunk.strip()
+            if chunk:
+              yield json.loads(chunk)
+        finally:
+          if hasattr(self, '_session') and self._session:
+            await self._session.close()
       else:
         raise ValueError('Error parsing streaming response.')
 
@@ -324,9 +336,11 @@ class HttpResponse:
 
 # Default retry options.
 # The config is based on https://cloud.google.com/storage/docs/retry-strategy.
-_RETRY_ATTEMPTS = 3
+# By default, the client will retry 4 times with approximately 1.0, 2.0, 4.0,
+# 8.0 seconds between each attempt.
+_RETRY_ATTEMPTS = 5  # including the initial call.
 _RETRY_INITIAL_DELAY = 1.0  # seconds
-_RETRY_MAX_DELAY = 120.0  # seconds
+_RETRY_MAX_DELAY = 60.0  # seconds
 _RETRY_EXP_BASE = 2
 _RETRY_JITTER = 1
 _RETRY_HTTP_STATUS_CODES = (
@@ -350,14 +364,13 @@ def _retry_args(options: Optional[HttpRetryOptions]) -> dict[str, Any]:
     The arguments passed to the tenacity.(Async)Retrying constructor.
   """
   if options is None:
-    return {'stop': tenacity.stop_after_attempt(1)}
+    return {'stop': tenacity.stop_after_attempt(1), 'reraise': True}
 
   stop = tenacity.stop_after_attempt(options.attempts or _RETRY_ATTEMPTS)
   retriable_codes = options.http_status_codes or _RETRY_HTTP_STATUS_CODES
-  retry = tenacity.retry_if_result(
-      lambda response: response.status_code in retriable_codes,
+  retry = tenacity.retry_if_exception(
+      lambda e: isinstance(e, errors.APIError) and e.code in retriable_codes,
   )
-  retry_error_callback = lambda retry_state: retry_state.outcome.result()
   wait = tenacity.wait_exponential_jitter(
       initial=options.initial_delay or _RETRY_INITIAL_DELAY,
       max=options.max_delay or _RETRY_MAX_DELAY,
@@ -367,7 +380,7 @@ def _retry_args(options: Optional[HttpRetryOptions]) -> dict[str, Any]:
   return {
       'stop': stop,
       'retry': retry,
-      'retry_error_callback': retry_error_callback,
+      'reraise': True,
       'wait': wait,
   }
 
@@ -538,6 +551,7 @@ class BaseApiClient:
     # Default options for both clients.
     self._http_options.headers = {'Content-Type': 'application/json'}
     if self.api_key:
+      self.api_key = self.api_key.strip()
       if self._http_options.headers is not None:
         self._http_options.headers['x-goog-api-key'] = self.api_key
     # Update the http options with the user provided http options.
@@ -554,15 +568,16 @@ class BaseApiClient:
     )
     self._httpx_client = SyncHttpxClient(**client_args)
     self._async_httpx_client = AsyncHttpxClient(**async_client_args)
-    if has_aiohttp:
+    if self._use_aiohttp():
       # 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
       )
+    self._websocket_ssl_ctx = self._ensure_websocket_ssl_ctx(self._http_options)
 
     retry_kwargs = _retry_args(self._http_options.retry_options)
-    self._retry = tenacity.Retrying(**retry_kwargs, reraise=True)
-    self._async_retry = tenacity.AsyncRetrying(**retry_kwargs, reraise=True)
+    self._retry = tenacity.Retrying(**retry_kwargs)
+    self._async_retry = tenacity.AsyncRetrying(**retry_kwargs)
 
   @staticmethod
   def _ensure_httpx_ssl_ctx(
@@ -688,6 +703,70 @@ class BaseApiClient:
 
     return _maybe_set(async_args, ctx)
 
+  @staticmethod
+  def _ensure_websocket_ssl_ctx(options: HttpOptions) -> dict[str, Any]:
+    """Ensures the SSL context is present in the async client args.
+
+    Creates a default SSL context if one is not provided.
+
+    Args:
+      options: The http options to check for SSL context.
+
+    Returns:
+      An async aiohttp ClientSession._request args.
+    """
+
+    verify = 'ssl'  # keep it consistent with httpx.
+    async_args = options.async_client_args
+    ctx = async_args.get(verify) if async_args else None
+
+    if not ctx:
+      # Initialize the SSL context for the httpx client.
+      # Unlike requests, the aiohttp package does not automatically pull in the
+      # environment variables SSL_CERT_FILE or SSL_CERT_DIR. They need to be
+      # enabled explicitly. Instead of 'verify' at client level in httpx,
+      # aiohttp uses 'ssl' at request level.
+      ctx = ssl.create_default_context(
+          cafile=os.environ.get('SSL_CERT_FILE', certifi.where()),
+          capath=os.environ.get('SSL_CERT_DIR'),
+      )
+
+    def _maybe_set(
+        args: Optional[dict[str, Any]],
+        ctx: ssl.SSLContext,
+    ) -> dict[str, Any]:
+      """Sets the SSL context in the client args if not set.
+
+      Does not override the SSL context if it is already set.
+
+      Args:
+        args: The client args to to check for SSL context.
+        ctx: The SSL context to set.
+
+      Returns:
+        The client args with the SSL context included.
+      """
+      if not args or not args.get(verify):
+        args = (args or {}).copy()
+        args[verify] = ctx
+      # Drop the args that isn't in the aiohttp RequestOptions.
+      copied_args = args.copy()
+      for key in copied_args.copy():
+        if key not in inspect.signature(ws_connect).parameters and key != 'ssl':
+          del copied_args[key]
+      return copied_args
+
+    return _maybe_set(async_args, ctx)
+
+  def _use_aiohttp(self) -> bool:
+    # If the instantiator has passed a custom transport, they want httpx not
+    # aiohttp.
+    return (
+        has_aiohttp
+        and (self._http_options.async_client_args or {}).get('transport')
+        is None
+    )
+
   def _websocket_base_url(self) -> str:
     url_parts = urlparse(self._http_options.base_url)
     return url_parts._replace(scheme='wss').geturl()  # type: ignore[arg-type, return-value]
@@ -882,6 +961,7 @@ class BaseApiClient:
       self, http_request: HttpRequest, stream: bool = False
   ) -> HttpResponse:
     data: Optional[Union[str, bytes]] = None
+
     if self.vertexai and not self.api_key:
       http_request.headers['Authorization'] = (
           f'Bearer {await self._async_access_token()}'
@@ -899,7 +979,7 @@ class BaseApiClient:
           data = http_request.data
 
     if stream:
-      if has_aiohttp:
+      if self._use_aiohttp():
         session = aiohttp.ClientSession(
             headers=http_request.headers,
             trust_env=True,
@@ -912,8 +992,9 @@ class BaseApiClient:
             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)
+        return HttpResponse(response.headers, response, session=session)
       else:
         # aiohttp is not available. Fall back to httpx.
         httpx_request = self._async_httpx_client.build_request(
@@ -930,7 +1011,7 @@ class BaseApiClient:
         await errors.APIError.raise_for_async_response(client_response)
         return HttpResponse(client_response.headers, client_response)
     else:
-      if has_aiohttp:
+      if self._use_aiohttp():
         async with aiohttp.ClientSession(
             headers=http_request.headers,
             trust_env=True,
@@ -984,11 +1065,10 @@ class BaseApiClient:
         http_method, path, request_dict, http_options
     )
     response = self._request(http_request, stream=False)
-    response_body = response.response_stream[0] if response.response_stream else ''
-    return SdkHttpResponse(
-        headers=response.headers, body=response_body
+    response_body = (
+        response.response_stream[0] if response.response_stream else ''
     )
-
+    return SdkHttpResponse(headers=response.headers, body=response_body)
 
   def request_streamed(
       self,
@@ -1003,7 +1083,9 @@ class BaseApiClient:
 
     session_response = self._request(http_request, stream=True)
     for chunk in session_response.segments():
-      yield SdkHttpResponse(headers=session_response.headers, body=json.dumps(chunk))
+      yield SdkHttpResponse(
+          headers=session_response.headers, body=json.dumps(chunk)
+      )
 
   async def async_request(
       self,
@@ -1018,10 +1100,7 @@ class BaseApiClient:
 
     result = await self._async_request(http_request=http_request, stream=False)
     response_body = result.response_stream[0] if result.response_stream else ''
-    return SdkHttpResponse(
-        headers=result.headers, body=response_body
-    )
-
+    return SdkHttpResponse(headers=result.headers, body=response_body)
 
   async def async_request_streamed(
       self,
@@ -1247,7 +1326,7 @@ class BaseApiClient:
     """
     offset = 0
     # Upload the file in chunks
-    if has_aiohttp:  # pylint: disable=g-import-not-at-top
+    if self._use_aiohttp():  # pylint: disable=g-import-not-at-top
       async with aiohttp.ClientSession(
           headers=self._http_options.headers,
           trust_env=True,
@@ -1430,7 +1509,7 @@ class BaseApiClient:
       else:
         data = http_request.data
 
-    if has_aiohttp:
+    if self._use_aiohttp():
       async with aiohttp.ClientSession(
           headers=http_request.headers,
           trust_env=True,