google-genai 1.14.0__py3-none-any.whl → 1.16.0__py3-none-any.whl

google/genai/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2024 Google LLC
+# 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.
@@ -15,9 +15,11 @@
 
 """Google Gen AI SDK"""
 
+from . import version
 from .client import Client
-from . import  version
+from .live import live_ephemeral_connect
+
 
 __version__ = version.__version__
 
-__all__ = ['Client']
+__all__ = ['Client', 'live_ephemeral_connect']

google/genai/_adapters.py

@@ -0,0 +1,55 @@
+# 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.
+#
+
+import typing
+
+from ._mcp_utils import mcp_to_gemini_tools
+from .types import FunctionCall, Tool
+
+if typing.TYPE_CHECKING:
+  from mcp import types as mcp_types
+  from mcp import ClientSession
+
+
+class McpToGenAiToolAdapter:
+  """Adapter for working with MCP tools in a GenAI client."""
+
+  def __init__(
+      self,
+      session: "mcp.ClientSession",  # type: ignore # noqa: F821
+      list_tools_result: "mcp_types.ListToolsResult",  # type: ignore
+  ) -> None:
+    self._mcp_session = session
+    self._list_tools_result = list_tools_result
+
+  async def call_tool(
+      self, function_call: FunctionCall
+  ) -> "mcp_types.CallToolResult":  # type: ignore
+    """Calls a function on the MCP server."""
+    name = function_call.name if function_call.name else ""
+    arguments = dict(function_call.args) if function_call.args else {}
+
+    return typing.cast(
+        "mcp_types.CallToolResult",
+        await self._mcp_session.call_tool(
+            name=name,
+            arguments=arguments,
+        ),
+    )
+
+  @property
+  def tools(self) -> list[Tool]:
+    """Returns a list of Google GenAI tools."""
+    return mcp_to_gemini_tools(self._list_tools_result.tools)

google/genai/_api_client.py

@@ -1,4 +1,4 @@
-# Copyright 2024 Google LLC
+# 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.
@@ -32,6 +32,7 @@ import math
 import os
 import ssl
 import sys
+import threading
 import time
 from typing import Any, AsyncIterator, Optional, Tuple, Union
 from urllib.parse import urlparse
@@ -71,14 +72,14 @@ def _append_library_version_headers(headers: dict[str, str]) -> None:
       'user-agent' in headers
       and version_header_value not in headers['user-agent']
   ):
-    headers['user-agent'] += f' {version_header_value}'
+    headers['user-agent'] = f'{version_header_value} ' + headers['user-agent']
   elif 'user-agent' not in headers:
     headers['user-agent'] = version_header_value
   if (
       'x-goog-api-client' in headers
       and version_header_value not in headers['x-goog-api-client']
   ):
-    headers['x-goog-api-client'] += f' {version_header_value}'
+    headers['x-goog-api-client'] = f'{version_header_value} ' + headers['x-goog-api-client']
   elif 'x-goog-api-client' not in headers:
     headers['x-goog-api-client'] = version_header_value
 
@@ -376,10 +377,12 @@ class BaseApiClient:
     # credentials. This is crucial for thread safety when multiple coroutines
     # might be accessing the credentials at the same time.
     try:
-      self._auth_lock = asyncio.Lock()
+      self._sync_auth_lock = threading.Lock()
+      self._async_auth_lock = asyncio.Lock()
     except RuntimeError:
       asyncio.set_event_loop(asyncio.new_event_loop())
-      self._auth_lock = asyncio.Lock()
+      self._sync_auth_lock = threading.Lock()
+      self._async_auth_lock = asyncio.Lock()
 
     # Handle when to use Vertex AI in express mode (api key).
     # Explicit initializer arguments are already validated above.
@@ -519,25 +522,26 @@ class BaseApiClient:
 
   def _access_token(self) -> str:
     """Retrieves the access token for the credentials."""
-    if not self._credentials:
-      self._credentials, project = _load_auth(project=self.project)
-      if not self.project:
-        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:
+    with self._sync_auth_lock:
+      if not self._credentials:
+        self._credentials, project = _load_auth(project=self.project)
+        if not self.project:
+          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]
+      else:
         raise RuntimeError('Could not resolve API token from the environment')
-      return self._credentials.token  # type: ignore[no-any-return]
-    else:
-      raise RuntimeError('Could not resolve API token from the environment')
 
   async def _async_access_token(self) -> Union[str, Any]:
     """Retrieves the access token for the credentials asynchronously."""
     if not self._credentials:
-      async with self._auth_lock:
+      async with self._async_auth_lock:
         # This ensures that only one coroutine can execute the auth logic at a
         # time for thread safety.
         if not self._credentials:
@@ -551,7 +555,7 @@ class BaseApiClient:
     if self._credentials:
       if self._credentials.expired or not self._credentials.token:
         # Only refresh when it needs to. Default expiration is 3600 seconds.
-        async with self._auth_lock:
+        async with self._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)

google/genai/_api_module.py

@@ -1,4 +1,4 @@
-# Copyright 2024 Google LLC
+# 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.

google/genai/_automatic_function_calling_util.py

@@ -1,4 +1,4 @@
-# Copyright 2024 Google LLC
+# 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.
@@ -269,7 +269,7 @@ def _parse_schema_from_parameter(
   raise ValueError(
       f'Failed to parse the parameter {param} of function {func_name} for'
       ' automatic function calling.Automatic function calling works best with'
-      ' simpler function signature schema,consider manually parse your'
+      ' simpler function signature schema, consider manually parsing your'
       f' function declaration for function {func_name}.'
   )
 

google/genai/_common.py

@@ -1,4 +1,4 @@
-# Copyright 2024 Google LLC
+# 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.

google/genai/_extra_utils.py

@@ -1,4 +1,4 @@
-# Copyright 2024 Google LLC
+# 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.
@@ -24,14 +24,30 @@ from typing import Any, Callable, Dict, Optional, Union, get_args, get_origin
 import pydantic
 
 from . import _common
+from . import _mcp_utils
 from . import errors
 from . import types
+from ._adapters import McpToGenAiToolAdapter
+
 
 if sys.version_info >= (3, 10):
   from types import UnionType
 else:
   UnionType = typing._UnionGenericAlias  # type: ignore[attr-defined]
 
+if typing.TYPE_CHECKING:
+  from mcp import ClientSession as McpClientSession
+  from mcp.types import Tool as McpTool
+else:
+  McpClientSession: typing.Type = Any
+  McpTool: typing.Type = Any
+  try:
+    from mcp import ClientSession as McpClientSession
+    from mcp.types import Tool as McpTool
+  except ImportError:
+    McpClientSession = None
+    McpTool = None
+
 _DEFAULT_MAX_REMOTE_CALLS_AFC = 10
 
 logger = logging.getLogger('google_genai.models')
@@ -78,10 +94,13 @@ def format_destination(
 
 def get_function_map(
     config: Optional[types.GenerateContentConfigOrDict] = None,
+    mcp_to_genai_tool_adapters: Optional[
+        dict[str, McpToGenAiToolAdapter]
+    ] = None,
     is_caller_method_async: bool = False,
-) -> dict[str, Callable[..., Any]]:
+) -> dict[str, Union[Callable[..., Any], McpToGenAiToolAdapter]]:
   """Returns a function map from the config."""
-  function_map: dict[str, Callable[..., Any]] = {}
+  function_map: dict[str, Union[Callable[..., Any], McpToGenAiToolAdapter]] = {}
   if not config:
     return function_map
   config_model = _create_generate_content_config_model(config)
@@ -95,6 +114,17 @@ def get_function_map(
               f' invoke {tool.__name__} to get the function response.'
           )
         function_map[tool.__name__] = tool
+  if mcp_to_genai_tool_adapters:
+    if not is_caller_method_async:
+      raise errors.UnsupportedFunctionError(
+          'MCP tools are not supported in synchronous methods.'
+      )
+    for tool_name, _ in mcp_to_genai_tool_adapters.items():
+      if function_map.get(tool_name):
+        raise ValueError(
+            f'Tool {tool_name} is already defined for the request.'
+        )
+    function_map.update(mcp_to_genai_tool_adapters)
   return function_map
 
 
@@ -247,7 +277,7 @@ async def invoke_function_from_dict_args_async(
 
 def get_function_response_parts(
     response: types.GenerateContentResponse,
-    function_map: dict[str, Callable[..., Any]],
+    function_map: dict[str, Union[Callable[..., Any], McpToGenAiToolAdapter]],
 ) -> list[types.Part]:
   """Returns the function response parts from the response."""
   func_response_parts = []
@@ -267,9 +297,10 @@ def get_function_response_parts(
         )
         func_response: dict[str, Any]
         try:
-          func_response = {
-              'result': invoke_function_from_dict_args(args, func)
-          }
+          if not isinstance(func, McpToGenAiToolAdapter):
+            func_response = {
+                'result': invoke_function_from_dict_args(args, func)
+            }
         except Exception as e:  # pylint: disable=broad-except
           func_response = {'error': str(e)}
         func_response_part = types.Part.from_function_response(
@@ -278,9 +309,10 @@ def get_function_response_parts(
         func_response_parts.append(func_response_part)
   return func_response_parts
 
+
 async def get_function_response_parts_async(
     response: types.GenerateContentResponse,
-    function_map: dict[str, Callable[..., Any]],
+    function_map: dict[str, Union[Callable[..., Any], McpToGenAiToolAdapter]],
 ) -> list[types.Part]:
   """Returns the function response parts from the response."""
   func_response_parts = []
@@ -300,7 +332,15 @@ async def get_function_response_parts_async(
         )
         func_response: dict[str, Any]
         try:
-          if inspect.iscoroutinefunction(func):
+          if isinstance(func, McpToGenAiToolAdapter):
+            mcp_tool_response = await func.call_tool(
+                types.FunctionCall(name=func_name, args=args)
+            )
+            if mcp_tool_response.isError:
+              func_response = {'error': mcp_tool_response}
+            else:
+              func_response = {'result': mcp_tool_response}
+          elif inspect.iscoroutinefunction(func):
             func_response = {
                 'result': await invoke_function_from_dict_args_async(args, func)
             }
@@ -401,3 +441,71 @@ def should_append_afc_history(
   if not config_model.automatic_function_calling:
     return True
   return not config_model.automatic_function_calling.ignore_call_history
+
+
+def parse_config_for_mcp_usage(
+    config: Optional[types.GenerateContentConfigOrDict] = None,
+) -> Optional[types.GenerateContentConfig]:
+  """Returns a parsed config with an appended MCP header if MCP tools or sessions are used."""
+  if not config:
+    return None
+  config_model = _create_generate_content_config_model(config)
+  # Create a copy of the config model with the tools field cleared since some
+  # tools may not be pickleable.
+  config_model_copy = config_model.model_copy(update={'tools': None})
+  config_model_copy.tools = config_model.tools
+  if config_model.tools and _mcp_utils.has_mcp_tool_usage(config_model.tools):
+    if config_model_copy.http_options is None:
+      config_model_copy.http_options = types.HttpOptions(headers={})
+    if config_model_copy.http_options.headers is None:
+      config_model_copy.http_options.headers = {}
+    _mcp_utils.set_mcp_usage_header(config_model_copy.http_options.headers)
+
+  return config_model_copy
+
+
+async def parse_config_for_mcp_sessions(
+    config: Optional[types.GenerateContentConfigOrDict] = None,
+) -> tuple[
+    Optional[types.GenerateContentConfig],
+    dict[str, McpToGenAiToolAdapter],
+]:
+  """Returns a parsed config with MCP sessions converted to GenAI tools.
+
+  Also returns a map of MCP tools to GenAI tool adapters to be used for AFC.
+  """
+  mcp_to_genai_tool_adapters: dict[str, McpToGenAiToolAdapter] = {}
+  parsed_config = parse_config_for_mcp_usage(config)
+  if not parsed_config:
+    return None, mcp_to_genai_tool_adapters
+  # Create a copy of the config model with the tools field cleared as they will
+  # be replaced with the MCP tools converted to GenAI tools.
+  parsed_config_copy = parsed_config.model_copy(update={'tools': None})
+  if parsed_config.tools:
+    parsed_config_copy.tools = []
+    for tool in parsed_config.tools:
+      if McpClientSession is not None and isinstance(tool, McpClientSession):
+        mcp_to_genai_tool_adapter = McpToGenAiToolAdapter(
+            tool, await tool.list_tools()
+        )
+        # Extend the config with the MCP session tools converted to GenAI tools.
+        parsed_config_copy.tools.extend(mcp_to_genai_tool_adapter.tools)
+        for genai_tool in mcp_to_genai_tool_adapter.tools:
+          if genai_tool.function_declarations:
+            for function_declaration in genai_tool.function_declarations:
+              if function_declaration.name:
+                if mcp_to_genai_tool_adapters.get(function_declaration.name):
+                  raise ValueError(
+                      f'Tool {function_declaration.name} is already defined for'
+                      ' the request.'
+                  )
+                mcp_to_genai_tool_adapters[function_declaration.name] = (
+                    mcp_to_genai_tool_adapter
+                )
+    if McpClientSession is not None:
+      parsed_config_copy.tools.extend(
+          tool
+          for tool in parsed_config.tools
+          if not isinstance(tool, McpClientSession)
+      )
+  return parsed_config_copy, mcp_to_genai_tool_adapters