langchain-google-genai 2.1.11__py3-none-any.whl → 3.0.0__py3-none-any.whl

langchain_google_genai/chat_models.py

@@ -10,30 +10,24 @@ import time
 import uuid
 import warnings
 import wave
+from collections.abc import AsyncIterator, Iterator, Mapping, Sequence
 from difflib import get_close_matches
 from operator import itemgetter
 from typing import (
     Any,
-    AsyncIterator,
     Callable,
     Dict,
-    Iterator,
     List,
     Literal,
-    Mapping,
     Optional,
-    Sequence,
     Tuple,
     Type,
     Union,
     cast,
 )
 
-import filetype  # type: ignore[import]
-import google.api_core
-
-# TODO: remove ignore once the Google package is published with types
-import proto  # type: ignore[import]
+import filetype  # type: ignore[import-untyped]
+import proto  # type: ignore[import-untyped]
 from google.ai.generativelanguage_v1beta import (
     GenerativeServiceAsyncClient as v1betaGenerativeServiceAsyncClient,
 )
@@ -57,12 +51,24 @@ from google.ai.generativelanguage_v1beta.types import (
     VideoMetadata,
 )
 from google.ai.generativelanguage_v1beta.types import Tool as GoogleTool
+from google.api_core.exceptions import (
+    FailedPrecondition,
+    GoogleAPIError,
+    InvalidArgument,
+    ResourceExhausted,
+    ServiceUnavailable,
+)
+from google.protobuf.json_format import MessageToDict
 from langchain_core.callbacks.manager import (
     AsyncCallbackManagerForLLMRun,
     CallbackManagerForLLMRun,
 )
-from langchain_core.language_models import LanguageModelInput
-from langchain_core.language_models.chat_models import BaseChatModel, LangSmithParams
+from langchain_core.language_models import (
+    LangSmithParams,
+    LanguageModelInput,
+    is_openai_data_block,
+)
+from langchain_core.language_models.chat_models import BaseChatModel
 from langchain_core.messages import (
     AIMessage,
     AIMessageChunk,
@@ -73,6 +79,7 @@ from langchain_core.messages import (
     ToolMessage,
     is_data_content_block,
 )
+from langchain_core.messages import content as types
 from langchain_core.messages.ai import UsageMetadata, add_usage, subtract_usage
 from langchain_core.messages.tool import invalid_tool_call, tool_call, tool_call_chunk
 from langchain_core.output_parsers import JsonOutputParser, PydanticOutputParser
@@ -109,6 +116,9 @@ from langchain_google_genai._common import (
     _BaseGoogleGenerativeAI,
     get_client_info,
 )
+from langchain_google_genai._compat import (
+    _convert_from_v1_to_generativelanguage_v1beta,
+)
 from langchain_google_genai._function_utils import (
     _dict_to_gapic_schema,
     _tool_choice_to_tool_config,
@@ -139,12 +149,11 @@ _FunctionDeclarationType = Union[
 
 
 class ChatGoogleGenerativeAIError(GoogleGenerativeAIError):
-    """
-    Custom exception class for errors associated with the `Google GenAI` API.
+    """Custom exception class for errors associated with the `Google GenAI` API.
 
-    This exception is raised when there are specific issues related to the
-    Google genai API usage in the ChatGoogleGenerativeAI class, such as unsupported
-    message types or roles.
+    This exception is raised when there are specific issues related to the Google genai
+    API usage in the ChatGoogleGenerativeAI class, such as unsupported message types or
+    roles.
     """
 
 
@@ -154,12 +163,11 @@ def _create_retry_decorator(
     wait_exponential_min: float = 1.0,
     wait_exponential_max: float = 60.0,
 ) -> Callable[[Any], Any]:
-    """
-    Creates and returns a preconfigured tenacity retry decorator.
+    """Creates and returns a preconfigured tenacity retry decorator.
 
-    The retry decorator is configured to handle specific Google API exceptions
-    such as ResourceExhausted and ServiceUnavailable. It uses an exponential
-    backoff strategy for retries.
+    The retry decorator is configured to handle specific Google API exceptions such as
+    ResourceExhausted and ServiceUnavailable. It uses an exponential backoff strategy
+    for retries.
 
     Returns:
         Callable[[Any], Any]: A retry decorator configured for handling specific
@@ -174,21 +182,20 @@ def _create_retry_decorator(
             max=wait_exponential_max,
         ),
         retry=(
-            retry_if_exception_type(google.api_core.exceptions.ResourceExhausted)
-            | retry_if_exception_type(google.api_core.exceptions.ServiceUnavailable)
-            | retry_if_exception_type(google.api_core.exceptions.GoogleAPIError)
+            retry_if_exception_type(ResourceExhausted)
+            | retry_if_exception_type(ServiceUnavailable)
+            | retry_if_exception_type(GoogleAPIError)
         ),
         before_sleep=before_sleep_log(logger, logging.WARNING),
     )
 
 
 def _chat_with_retry(generation_method: Callable, **kwargs: Any) -> Any:
-    """
-    Executes a chat generation method with retry logic using tenacity.
+    """Executes a chat generation method with retry logic using tenacity.
 
-    This function is a wrapper that applies a retry mechanism to a provided
-    chat generation function. It is useful for handling intermittent issues
-    like network errors or temporary service unavailability.
+    This function is a wrapper that applies a retry mechanism to a provided chat
+    generation function. It is useful for handling intermittent issues like network
+    errors or temporary service unavailability.
 
     Args:
         generation_method (Callable): The chat generation method to be executed.
@@ -208,7 +215,7 @@ def _chat_with_retry(generation_method: Callable, **kwargs: Any) -> Any:
     def _chat_with_retry(**kwargs: Any) -> Any:
         try:
             return generation_method(**kwargs)
-        except google.api_core.exceptions.FailedPrecondition as exc:
+        except FailedPrecondition as exc:
             if "location is not supported" in exc.message:
                 error_msg = (
                     "Your location is not supported by google-generativeai "
@@ -217,19 +224,18 @@ def _chat_with_retry(generation_method: Callable, **kwargs: Any) -> Any:
                 )
                 raise ValueError(error_msg)
 
-        except google.api_core.exceptions.InvalidArgument as e:
-            raise ChatGoogleGenerativeAIError(
-                f"Invalid argument provided to Gemini: {e}"
-            ) from e
-        except google.api_core.exceptions.ResourceExhausted as e:
+        except InvalidArgument as e:
+            msg = f"Invalid argument provided to Gemini: {e}"
+            raise ChatGoogleGenerativeAIError(msg) from e
+        except ResourceExhausted as e:
             # Handle quota-exceeded error with recommended retry delay
-            if hasattr(e, "retry_after") and e.retry_after < kwargs.get(
+            if hasattr(e, "retry_after") and getattr(e, "retry_after", 0) < kwargs.get(
                 "wait_exponential_max", 60.0
             ):
-                time.sleep(e.retry_after)
-            raise e
-        except Exception as e:
-            raise e
+                time.sleep(getattr(e, "retry_after"))
+            raise
+        except Exception:
+            raise
 
     params = (
         {k: v for k, v in kwargs.items() if k in _allowed_params_prediction_service}
@@ -242,12 +248,11 @@ def _chat_with_retry(generation_method: Callable, **kwargs: Any) -> Any:
 
 
 async def _achat_with_retry(generation_method: Callable, **kwargs: Any) -> Any:
-    """
-    Executes a chat generation method with retry logic using tenacity.
+    """Executes a chat generation method with retry logic using tenacity.
 
-    This function is a wrapper that applies a retry mechanism to a provided
-    chat generation function. It is useful for handling intermittent issues
-    like network errors or temporary service unavailability.
+    This function is a wrapper that applies a retry mechanism to a provided chat
+    generation function. It is useful for handling intermittent issues like network
+    errors or temporary service unavailability.
 
     Args:
         generation_method (Callable): The chat generation method to be executed.
@@ -256,8 +261,12 @@ async def _achat_with_retry(generation_method: Callable, **kwargs: Any) -> Any:
     Returns:
         Any: The result from the chat generation method.
     """
-    retry_decorator = _create_retry_decorator()
-    from google.api_core.exceptions import InvalidArgument  # type: ignore
+    retry_decorator = _create_retry_decorator(
+        max_retries=kwargs.get("max_retries", 6),
+        wait_exponential_multiplier=kwargs.get("wait_exponential_multiplier", 2.0),
+        wait_exponential_min=kwargs.get("wait_exponential_min", 1.0),
+        wait_exponential_max=kwargs.get("wait_exponential_max", 60.0),
+    )
 
     @retry_decorator
     async def _achat_with_retry(**kwargs: Any) -> Any:
@@ -265,11 +274,17 @@ async def _achat_with_retry(generation_method: Callable, **kwargs: Any) -> Any:
             return await generation_method(**kwargs)
         except InvalidArgument as e:
             # Do not retry for these errors.
-            raise ChatGoogleGenerativeAIError(
-                f"Invalid argument provided to Gemini: {e}"
-            ) from e
-        except Exception as e:
-            raise e
+            msg = f"Invalid argument provided to Gemini: {e}"
+            raise ChatGoogleGenerativeAIError(msg) from e
+        except ResourceExhausted as e:
+            # Handle quota-exceeded error with recommended retry delay
+            if hasattr(e, "retry_after") and getattr(e, "retry_after", 0) < kwargs.get(
+                "wait_exponential_max", 60.0
+            ):
+                time.sleep(getattr(e, "retry_after"))
+            raise
+        except Exception:
+            raise
 
     params = (
         {k: v for k, v in kwargs.items() if k in _allowed_params_prediction_service}
@@ -281,55 +296,78 @@ async def _achat_with_retry(generation_method: Callable, **kwargs: Any) -> Any:
     return await _achat_with_retry(**params)
 
 
-def _is_lc_content_block(part: dict) -> bool:
-    return "type" in part
-
-
-def _is_openai_image_block(block: dict) -> bool:
-    """Check if the block contains image data in OpenAI Chat Completions format."""
-    if block.get("type") == "image_url":
-        if (
-            (set(block.keys()) <= {"type", "image_url", "detail"})
-            and (image_url := block.get("image_url"))
-            and isinstance(image_url, dict)
-        ):
-            url = image_url.get("url")
-            if isinstance(url, str):
-                return True
-    else:
-        return False
-
-    return False
-
-
 def _convert_to_parts(
     raw_content: Union[str, Sequence[Union[str, dict]]],
 ) -> List[Part]:
-    """Converts a list of LangChain messages into a Google parts."""
-    parts = []
+    """Converts LangChain message content into generativelanguage_v1beta parts.
+
+    Used when preparing Human, System and AI messages for sending to the API.
+
+    Handles both legacy (pre-v1) dict-based content blocks and v1 ContentBlock objects.
+    """
     content = [raw_content] if isinstance(raw_content, str) else raw_content
     image_loader = ImageBytesLoader()
+
+    parts = []
+    # Iterate over each item in the content list, constructing a list of Parts
     for part in content:
         if isinstance(part, str):
             parts.append(Part(text=part))
         elif isinstance(part, Mapping):
-            if _is_lc_content_block(part):
+            if "type" in part:
                 if part["type"] == "text":
-                    parts.append(Part(text=part["text"]))
+                    # Either old dict-style CC text block or new TextContentBlock
+                    # Check if there's a signature attached to this text block
+                    thought_sig = None
+                    if "extras" in part and isinstance(part["extras"], dict):
+                        sig = part["extras"].get("signature")
+                        if sig and isinstance(sig, str):
+                            # Decode base64-encoded signature back to bytes
+                            thought_sig = base64.b64decode(sig)
+                    if thought_sig:
+                        parts.append(
+                            Part(text=part["text"], thought_signature=thought_sig)
+                        )
+                    else:
+                        parts.append(Part(text=part["text"]))
                 elif is_data_content_block(part):
-                    if part["source_type"] == "url":
+                    # Handle both legacy LC blocks (with `source_type`) and blocks >= v1
+
+                    if "source_type" in part:
+                        # Catch legacy v0 formats
+                        # Safe since v1 content blocks don't have `source_type` key
+                        if part["source_type"] == "url":
+                            bytes_ = image_loader._bytes_from_url(part["url"])
+                        elif part["source_type"] == "base64":
+                            bytes_ = base64.b64decode(part["data"])
+                        else:
+                            # Unable to support IDContentBlock
+                            msg = "source_type must be url or base64."
+                            raise ValueError(msg)
+                    elif "url" in part:
+                        # v1 multimodal block w/ URL
                         bytes_ = image_loader._bytes_from_url(part["url"])
-                    elif part["source_type"] == "base64":
-                        bytes_ = base64.b64decode(part["data"])
+                    elif "base64" in part:
+                        # v1 multimodal block w/ base64
+                        bytes_ = base64.b64decode(part["base64"])
                     else:
-                        raise ValueError("source_type must be url or base64.")
+                        msg = (
+                            "Data content block must contain 'url', 'base64', or "
+                            "'data' field."
+                        )
+                        raise ValueError(msg)
                     inline_data: dict = {"data": bytes_}
                     if "mime_type" in part:
                         inline_data["mime_type"] = part["mime_type"]
                     else:
-                        source = cast(str, part.get("url") or part.get("data"))
+                        # Guess mime type based on data field if not provided
+                        source = cast(
+                            "str",
+                            part.get("url") or part.get("base64") or part.get("data"),
+                        )
                         mime_type, _ = mimetypes.guess_type(source)
                         if not mime_type:
+                            # Last resort - try to guess based on file bytes
                             kind = filetype.guess(bytes_)
                             if kind:
                                 mime_type = kind.mime
@@ -337,56 +375,127 @@ def _convert_to_parts(
                             inline_data["mime_type"] = mime_type
                     parts.append(Part(inline_data=inline_data))
                 elif part["type"] == "image_url":
+                    # Chat Completions image format
                     img_url = part["image_url"]
                     if isinstance(img_url, dict):
                         if "url" not in img_url:
-                            raise ValueError(
-                                f"Unrecognized message image format: {img_url}"
-                            )
+                            msg = f"Unrecognized message image format: {img_url}"
+                            raise ValueError(msg)
                         img_url = img_url["url"]
                     parts.append(image_loader.load_part(img_url))
-                # Handle media type like LangChain.js
-                # https://github.com/langchain-ai/langchainjs/blob/e536593e2585f1dd7b0afc187de4d07cb40689ba/libs/langchain-google-common/src/utils/gemini.ts#L93-L106
                 elif part["type"] == "media":
+                    # Handle `media` following pattern established in LangChain.js
+                    # https://github.com/langchain-ai/langchainjs/blob/e536593e2585f1dd7b0afc187de4d07cb40689ba/libs/langchain-google-common/src/utils/gemini.ts#L93-L106
                     if "mime_type" not in part:
-                        raise ValueError(f"Missing mime_type in media part: {part}")
+                        msg = f"Missing mime_type in media part: {part}"
+                        raise ValueError(msg)
                     mime_type = part["mime_type"]
                     media_part = Part()
 
                     if "data" in part:
+                        # Embedded media
                         media_part.inline_data = Blob(
                             data=part["data"], mime_type=mime_type
                         )
                     elif "file_uri" in part:
+                        # Referenced files (e.g. stored in GCS)
                         media_part.file_data = FileData(
                             file_uri=part["file_uri"], mime_type=mime_type
                         )
                     else:
-                        raise ValueError(
-                            f"Media part must have either data or file_uri: {part}"
-                        )
+                        msg = f"Media part must have either data or file_uri: {part}"
+                        raise ValueError(msg)
                     if "video_metadata" in part:
                         metadata = VideoMetadata(part["video_metadata"])
                         media_part.video_metadata = metadata
                     parts.append(media_part)
+                elif part["type"] == "function_call_signature":
+                    # Signature for function_call Part - skip it here as it should be
+                    # attached to the actual function_call Part
+                    # This is handled separately in the history parsing logic
+                    pass
+                elif part["type"] == "thinking":
+                    # Pre-existing thinking block format that we continue to store as
+                    thought_sig = None
+                    if "signature" in part:
+                        sig = part["signature"]
+                        if sig and isinstance(sig, str):
+                            # Decode base64-encoded signature back to bytes
+                            thought_sig = base64.b64decode(sig)
+                    parts.append(
+                        Part(
+                            text=part["thinking"],
+                            thought=True,
+                            thought_signature=thought_sig,
+                        )
+                    )
+                elif part["type"] == "reasoning":
+                    # ReasoningContentBlock (when output_version = "v1")
+                    extras = part.get("extras", {}) or {}
+                    sig = extras.get("signature")
+                    thought_sig = None
+                    if sig and isinstance(sig, str):
+                        # Decode base64-encoded signature back to bytes
+                        thought_sig = base64.b64decode(sig)
+                    parts.append(
+                        Part(
+                            text=part["reasoning"],
+                            thought=True,
+                            thought_signature=thought_sig,
+                        )
+                    )
+                elif part["type"] == "server_tool_call":
+                    if part.get("name") == "code_interpreter":
+                        args = part.get("args", {})
+                        code = args.get("code", "")
+                        language = args.get("language", "python")
+                        executable_code_part = Part(
+                            executable_code=ExecutableCode(language=language, code=code)
+                        )
+                        parts.append(executable_code_part)
+                    else:
+                        warnings.warn(
+                            f"Server tool call with name '{part.get('name')}' is not "
+                            "currently supported by Google GenAI. Only "
+                            "'code_interpreter' is supported.",
+                            stacklevel=2,
+                        )
                 elif part["type"] == "executable_code":
+                    # Legacy executable_code format (backward compat)
                     if "executable_code" not in part or "language" not in part:
-                        raise ValueError(
+                        msg = (
                             "Executable code part must have 'code' and 'language' "
                             f"keys, got {part}"
                         )
+                        raise ValueError(msg)
                     executable_code_part = Part(
                         executable_code=ExecutableCode(
                             language=part["language"], code=part["executable_code"]
                         )
                     )
                     parts.append(executable_code_part)
+                elif part["type"] == "server_tool_result":
+                    output = part.get("output", "")
+                    status = part.get("status", "success")
+                    # Map status to outcome: success → 1 (OUTCOME_OK), error → 2
+                    outcome = 1 if status == "success" else 2
+                    # Check extras for original outcome if available
+                    if "extras" in part and "outcome" in part["extras"]:
+                        outcome = part["extras"]["outcome"]
+                    code_execution_result_part = Part(
+                        code_execution_result=CodeExecutionResult(
+                            output=str(output), outcome=outcome
+                        )
+                    )
+                    parts.append(code_execution_result_part)
                 elif part["type"] == "code_execution_result":
+                    # Legacy code_execution_result format (backward compat)
                     if "code_execution_result" not in part:
-                        raise ValueError(
+                        msg = (
                             "Code execution result part must have "
                             f"'code_execution_result', got {part}"
                         )
+                        raise ValueError(msg)
                     if "outcome" in part:
                         outcome = part["outcome"]
                     else:
@@ -398,25 +507,18 @@ def _convert_to_parts(
                         )
                     )
                     parts.append(code_execution_result_part)
-                elif part["type"] == "thinking":
-                    parts.append(Part(text=part["thinking"], thought=True))
                 else:
-                    raise ValueError(
-                        f"Unrecognized message part type: {part['type']}. Only text, "
-                        f"image_url, and media types are supported."
-                    )
+                    msg = f"Unrecognized message part type: {part['type']}."
+                    raise ValueError(msg)
             else:
-                # Yolo
+                # Yolo. The input message content doesn't have a `type` key
                 logger.warning(
                     "Unrecognized message part format. Assuming it's a text part."
                 )
                 parts.append(Part(text=str(part)))
         else:
-            # TODO: Maybe some of Google's native stuff
-            # would hit this branch.
-            raise ChatGoogleGenerativeAIError(
-                "Gemini only supports text and inline_data parts."
-            )
+            msg = "Unknown error occurred while converting LC message content to parts."
+            raise ChatGoogleGenerativeAIError(msg)
     return parts
 
 
@@ -433,7 +535,7 @@ def _convert_tool_message_to_parts(
         other_blocks = []
         for block in message.content:
             if isinstance(block, dict) and (
-                is_data_content_block(block) or _is_openai_image_block(block)
+                is_data_content_block(block) or is_openai_data_block(block)
             ):
                 media_blocks.append(block)
             else:
@@ -463,14 +565,15 @@ def _convert_tool_message_to_parts(
 def _get_ai_message_tool_messages_parts(
     tool_messages: Sequence[ToolMessage], ai_message: AIMessage
 ) -> list[Part]:
-    """
-    Finds relevant tool messages for the AI message and converts them to a single
-    list of Parts.
+    """Conversion.
+
+    Finds relevant tool messages for the AI message and converts them to a single list
+    of Parts.
     """
     # We are interested only in the tool messages that are part of the AI message
     tool_calls_ids = {tool_call["id"]: tool_call for tool_call in ai_message.tool_calls}
     parts = []
-    for i, message in enumerate(tool_messages):
+    for _i, message in enumerate(tool_messages):
         if not tool_calls_ids:
             break
         if message.tool_call_id in tool_calls_ids:
@@ -487,7 +590,20 @@ def _get_ai_message_tool_messages_parts(
 def _parse_chat_history(
     input_messages: Sequence[BaseMessage], convert_system_message_to_human: bool = False
 ) -> Tuple[Optional[Content], List[Content]]:
-    messages: List[Content] = []
+    """Parses sequence of `BaseMessage` into system instruction and formatted messages.
+
+    Args:
+        input_messages: Sequence of `BaseMessage` objects representing the chat history.
+        convert_system_message_to_human: Whether to convert the first system message
+            into a human message. Deprecated, use system instructions instead.
+
+    Returns:
+        A tuple containing:
+        - An optional `google.ai.generativelanguage_v1beta.types.Content` representing
+            the system instruction (if any).
+        - A list of `google.ai.generativelanguage_v1beta.types.Content` representing the
+            formatted messages.
+    """
 
     if convert_system_message_to_human:
         warnings.warn(
@@ -496,6 +612,28 @@ def _parse_chat_history(
             DeprecationWarning,
             stacklevel=2,
         )
+    input_messages = list(input_messages)  # Make a mutable copy
+
+    # Case where content was serialized to v1 format
+    for idx, message in enumerate(input_messages):
+        if (
+            isinstance(message, AIMessage)
+            and message.response_metadata.get("output_version") == "v1"
+        ):
+            # Unpack known v1 content to v1beta format for the request
+            #
+            # Old content types and any previously serialized messages passed back in to
+            # history will skip this, but hit and processed in `_convert_to_parts`
+            input_messages[idx] = message.model_copy(
+                update={
+                    "content": _convert_from_v1_to_generativelanguage_v1beta(
+                        cast(list[types.ContentBlock], message.content),
+                        message.response_metadata.get("model_provider"),
+                    )
+                }
+            )
+
+    formatted_messages: List[Content] = []
 
     system_instruction: Optional[Content] = None
     messages_without_tool_messages = [
@@ -514,25 +652,49 @@ def _parse_chat_history(
             else:
                 pass
             continue
-        elif isinstance(message, AIMessage):
+        if isinstance(message, AIMessage):
             role = "model"
             if message.tool_calls:
                 ai_message_parts = []
-                for tool_call in message.tool_calls:
+                # Extract any function_call_signature blocks from content
+                function_call_sigs: dict[int, bytes] = {}
+                if isinstance(message.content, list):
+                    for idx, item in enumerate(message.content):
+                        if (
+                            isinstance(item, dict)
+                            and item.get("type") == "function_call_signature"
+                        ):
+                            sig_str = item.get("signature", "")
+                            if sig_str and isinstance(sig_str, str):
+                                # Decode base64-encoded signature back to bytes
+                                sig_bytes = base64.b64decode(sig_str)
+                                function_call_sigs[idx] = sig_bytes
+
+                for tool_call_idx, tool_call in enumerate(message.tool_calls):
                     function_call = FunctionCall(
                         {
                             "name": tool_call["name"],
                             "args": tool_call["args"],
                         }
                     )
-                    ai_message_parts.append(Part(function_call=function_call))
+                    # Check if there's a signature for this function call
+                    # (We use the index to match signature to function call)
+                    sig = function_call_sigs.get(tool_call_idx)
+                    if sig:
+                        ai_message_parts.append(
+                            Part(function_call=function_call, thought_signature=sig)
+                        )
+                    else:
+                        ai_message_parts.append(Part(function_call=function_call))
                 tool_messages_parts = _get_ai_message_tool_messages_parts(
                     tool_messages=tool_messages, ai_message=message
                 )
-                messages.append(Content(role=role, parts=ai_message_parts))
-                messages.append(Content(role="user", parts=tool_messages_parts))
+                formatted_messages.append(Content(role=role, parts=ai_message_parts))
+                formatted_messages.append(
+                    Content(role="user", parts=tool_messages_parts)
+                )
                 continue
-            elif raw_function_call := message.additional_kwargs.get("function_call"):
+            if raw_function_call := message.additional_kwargs.get("function_call"):
                 function_call = FunctionCall(
                     {
                         "name": raw_function_call["name"],
@@ -541,23 +703,30 @@ def _parse_chat_history(
                 )
                 parts = [Part(function_call=function_call)]
             else:
-                parts = _convert_to_parts(message.content)
+                if message.response_metadata.get("output_version") == "v1":
+                    # Already converted to v1beta format above
+                    parts = message.content  # type: ignore[assignment]
+                else:
+                    # Prepare request content parts from message.content field
+                    parts = _convert_to_parts(message.content)
         elif isinstance(message, HumanMessage):
             role = "user"
             parts = _convert_to_parts(message.content)
             if i == 1 and convert_system_message_to_human and system_instruction:
-                parts = [p for p in system_instruction.parts] + parts
+                parts = list(system_instruction.parts) + parts
                 system_instruction = None
         elif isinstance(message, FunctionMessage):
             role = "user"
             parts = _convert_tool_message_to_parts(message)
         else:
-            raise ValueError(
-                f"Unexpected message with type {type(message)} at the position {i}."
-            )
+            msg = f"Unexpected message with type {type(message)} at the position {i}."
+            raise ValueError(msg)
 
-        messages.append(Content(role=role, parts=parts))
-    return system_instruction, messages
+        # Final step; assemble the Content object to pass to the API
+        # If version = "v1", the parts are already in v1beta format and will be
+        # automatically converted using protobuf's auto-conversion
+        formatted_messages.append(Content(role=role, parts=parts))
+    return system_instruction, formatted_messages
 
 
 # Helper function to append content consistently
@@ -567,27 +736,34 @@ def _append_to_content(
     """Appends a new item to the content, handling different initial content types."""
     if current_content is None and isinstance(new_item, str):
         return new_item
-    elif current_content is None:
+    if current_content is None:
         return [new_item]
-    elif isinstance(current_content, str):
+    if isinstance(current_content, str):
         return [current_content, new_item]
-    elif isinstance(current_content, list):
+    if isinstance(current_content, list):
         current_content.append(new_item)
         return current_content
-    else:
-        # This case should ideally not be reached with proper type checking,
-        # but it catches any unexpected types that might slip through.
-        raise TypeError(f"Unexpected content type: {type(current_content)}")
+    # This case should ideally not be reached with proper type checking,
+    # but it catches any unexpected types that might slip through.
+    msg = f"Unexpected content type: {type(current_content)}"
+    raise TypeError(msg)
 
 
 def _parse_response_candidate(
-    response_candidate: Candidate, streaming: bool = False
+    response_candidate: Candidate,
+    streaming: bool = False,
+    model_name: Optional[str] = None,
 ) -> AIMessage:
     content: Union[None, str, List[Union[str, dict]]] = None
     additional_kwargs: Dict[str, Any] = {}
+    response_metadata: Dict[str, Any] = {"model_provider": "google_genai"}
+    if model_name:
+        response_metadata["model_name"] = model_name
     tool_calls = []
     invalid_tool_calls = []
     tool_call_chunks = []
+    # Track function call signatures separately to handle them conditionally
+    function_call_signatures: List[dict] = []
 
     for part in response_candidate.content.parts:
         text: Optional[str] = None
@@ -600,37 +776,71 @@ def _parse_response_candidate(
         except AttributeError:
             pass
 
+        # Extract thought signature if present (can be on any Part type)
+        # Signatures are binary data, encode to base64 string for JSON serialization
+        thought_sig: Optional[str] = None
+        if hasattr(part, "thought_signature") and part.thought_signature:
+            try:
+                # Encode binary signature to base64 string
+                thought_sig = base64.b64encode(part.thought_signature).decode("ascii")
+                if not thought_sig:  # Empty string
+                    thought_sig = None
+            except (AttributeError, TypeError):
+                thought_sig = None
+
         if hasattr(part, "thought") and part.thought:
             thinking_message = {
                 "type": "thinking",
                 "thinking": part.text,
             }
+            # Include signature if present
+            if thought_sig:
+                thinking_message["signature"] = thought_sig
             content = _append_to_content(content, thinking_message)
         elif text is not None and text:
-            content = _append_to_content(content, text)
+            # Check if this text Part has a signature attached
+            if thought_sig:
+                # Text with signature needs structured block to preserve signature
+                # We use a v1 TextContentBlock
+                text_with_sig = {
+                    "type": "text",
+                    "text": text,
+                    "extras": {"signature": thought_sig},
+                }
+                content = _append_to_content(content, text_with_sig)
+            else:
+                content = _append_to_content(content, text)
 
         if hasattr(part, "executable_code") and part.executable_code is not None:
             if part.executable_code.code and part.executable_code.language:
+                code_id = str(uuid.uuid4())  # Generate ID if not present, needed later
                 code_message = {
                     "type": "executable_code",
                     "executable_code": part.executable_code.code,
                     "language": part.executable_code.language,
+                    "id": code_id,
                 }
                 content = _append_to_content(content, code_message)
 
         if (
             hasattr(part, "code_execution_result")
             and part.code_execution_result is not None
-        ):
-            if part.code_execution_result.output:
-                execution_result = {
-                    "type": "code_execution_result",
-                    "code_execution_result": part.code_execution_result.output,
-                    "outcome": part.code_execution_result.outcome,
-                }
-                content = _append_to_content(content, execution_result)
+        ) and part.code_execution_result.output:
+            # outcome: 1 = OUTCOME_OK (success), else = error
+            outcome = part.code_execution_result.outcome
+            execution_result = {
+                "type": "code_execution_result",
+                "code_execution_result": part.code_execution_result.output,
+                "outcome": outcome,
+                "tool_call_id": "",  # Linked via block translator
+            }
+            content = _append_to_content(content, execution_result)
 
-        if part.inline_data.mime_type.startswith("audio/"):
+        if (
+            hasattr(part, "inline_data")
+            and part.inline_data
+            and part.inline_data.mime_type.startswith("audio/")
+        ):
             buffer = io.BytesIO()
 
             with wave.open(buffer, "wb") as wf:
@@ -640,9 +850,17 @@ def _parse_response_candidate(
                 wf.setframerate(24000)
                 wf.writeframes(part.inline_data.data)
 
-            additional_kwargs["audio"] = buffer.getvalue()
+            audio_data = buffer.getvalue()
+            additional_kwargs["audio"] = audio_data
+
+            # For backwards compatibility, audio stays in additional_kwargs by default
+            # and is accessible via .content_blocks property
 
-        if part.inline_data.mime_type.startswith("image/"):
+        if (
+            hasattr(part, "inline_data")
+            and part.inline_data
+            and part.inline_data.mime_type.startswith("image/")
+        ):
             image_format = part.inline_data.mime_type[6:]
             image_message = {
                 "type": "image_url",
@@ -701,6 +919,23 @@ def _parse_response_candidate(
                             id=tool_call_dict.get("id", str(uuid.uuid4())),
                         )
                     )
+
+            # If this function_call Part has a signature, track it separately
+            # We'll add it to content only if there's other content present
+            if thought_sig:
+                sig_block = {
+                    "type": "function_call_signature",
+                    "signature": thought_sig,
+                }
+                function_call_signatures.append(sig_block)
+
+    # Add function call signatures to content only if there's already other content
+    # This preserves backward compatibility where content is "" for
+    # function-only responses
+    if function_call_signatures and content is not None:
+        for sig_block in function_call_signatures:
+            content = _append_to_content(content, sig_block)
+
     if content is None:
         content = ""
     if isinstance(content, list) and any(
@@ -708,29 +943,107 @@ def _parse_response_candidate(
     ):
         warnings.warn(
             """
-        ⚠️ Warning: Output may vary each run.  
-        - 'executable_code': Always present.  
-        - 'execution_result' & 'image_url': May be absent for some queries.  
+        Warning: Output may vary each run.
+        - 'executable_code': Always present.
+        - 'execution_result' & 'image_url': May be absent for some queries.
 
         Validate before using in production.
 """
         )
-
     if streaming:
         return AIMessageChunk(
-            content=cast(Union[str, List[Union[str, Dict[Any, Any]]]], content),
+            content=content,
             additional_kwargs=additional_kwargs,
+            response_metadata=response_metadata,
             tool_call_chunks=tool_call_chunks,
         )
 
     return AIMessage(
-        content=cast(Union[str, List[Union[str, Dict[Any, Any]]]], content),
+        content=content,
         additional_kwargs=additional_kwargs,
+        response_metadata=response_metadata,
         tool_calls=tool_calls,
         invalid_tool_calls=invalid_tool_calls,
     )
 
 
+def _extract_grounding_metadata(candidate: Any) -> Dict[str, Any]:
+    """Extract grounding metadata from candidate.
+
+    core's block translator converts this metadata into citation annotations.
+
+    Uses `MessageToDict` for complete unfiltered extraction.
+
+    Falls back to custom field extraction in cases of failure for robustness.
+    """
+    if not hasattr(candidate, "grounding_metadata") or not candidate.grounding_metadata:
+        return {}
+
+    grounding_metadata = candidate.grounding_metadata
+
+    try:
+        # proto-plus wraps protobuf messages - access ._pb to get the raw protobuf
+        # message that MessageToDict expects
+        pb_message = (
+            grounding_metadata._pb
+            if hasattr(grounding_metadata, "_pb")
+            else grounding_metadata
+        )
+
+        return MessageToDict(  # type: ignore[call-arg]
+            pb_message,
+            preserving_proto_field_name=True,
+            always_print_fields_with_no_presence=True,
+            # type stub issue - ensures that protobuf fields with default values
+            # (like start_index=0) are included in the output
+        )
+    except (AttributeError, TypeError, ImportError):
+        # Attempt manual extraction of known fields
+        result: Dict[str, Any] = {}
+
+        # Grounding chunks
+        if hasattr(grounding_metadata, "grounding_chunks"):
+            grounding_chunks = []
+            for chunk in grounding_metadata.grounding_chunks:
+                chunk_data: Dict[str, Any] = {}
+                if hasattr(chunk, "web") and chunk.web:
+                    chunk_data["web"] = {
+                        "uri": chunk.web.uri if hasattr(chunk.web, "uri") else "",
+                        "title": chunk.web.title if hasattr(chunk.web, "title") else "",
+                    }
+                grounding_chunks.append(chunk_data)
+            result["grounding_chunks"] = grounding_chunks
+
+        # Grounding supports
+        if hasattr(grounding_metadata, "grounding_supports"):
+            grounding_supports = []
+            for support in grounding_metadata.grounding_supports:
+                support_data: Dict[str, Any] = {}
+                if hasattr(support, "segment") and support.segment:
+                    support_data["segment"] = {
+                        "start_index": getattr(support.segment, "start_index", 0),
+                        "end_index": getattr(support.segment, "end_index", 0),
+                        "text": getattr(support.segment, "text", ""),
+                        "part_index": getattr(support.segment, "part_index", 0),
+                    }
+                if hasattr(support, "grounding_chunk_indices"):
+                    support_data["grounding_chunk_indices"] = list(
+                        support.grounding_chunk_indices
+                    )
+                if hasattr(support, "confidence_scores"):
+                    support_data["confidence_scores"] = [
+                        round(score, 6) for score in support.confidence_scores
+                    ]
+                grounding_supports.append(support_data)
+            result["grounding_supports"] = grounding_supports
+
+        # Web search queries
+        if hasattr(grounding_metadata, "web_search_queries"):
+            result["web_search_queries"] = list(grounding_metadata.web_search_queries)
+
+        return result
+
+
 def _response_to_result(
     response: GenerateContentResponse,
     stream: bool = False,
@@ -793,19 +1106,20 @@ def _response_to_result(
             proto.Message.to_dict(safety_rating, use_integers_for_enums=False)
             for safety_rating in candidate.safety_ratings
         ]
-        try:
-            if candidate.grounding_metadata:
-                generation_info["grounding_metadata"] = proto.Message.to_dict(
-                    candidate.grounding_metadata
-                )
-        except AttributeError:
-            pass
+        grounding_metadata = _extract_grounding_metadata(candidate)
+        generation_info["grounding_metadata"] = grounding_metadata
         message = _parse_response_candidate(candidate, streaming=stream)
+
         message.usage_metadata = lc_usage
+
+        if not hasattr(message, "response_metadata"):
+            message.response_metadata = {}
+        message.response_metadata["grounding_metadata"] = grounding_metadata
+
         if stream:
             generations.append(
                 ChatGenerationChunk(
-                    message=cast(AIMessageChunk, message),
+                    message=cast("AIMessageChunk", message),
                     generation_info=generation_info,
                 )
             )
@@ -849,13 +1163,14 @@ def _is_event_loop_running() -> bool:
 
 
 class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
-    """`Google AI` chat models integration.
+    r"""`Google AI` chat models integration.
 
     Instantiation:
         To use, you must have either:
 
             1. The ``GOOGLE_API_KEY`` environment variable set with your API key, or
-            2. Pass your API key using the ``google_api_key`` kwarg to the ChatGoogleGenerativeAI constructor.
+            2. Pass your API key using the ``google_api_key`` kwarg to the
+            ChatGoogleGenerativeAI constructor.
 
         .. code-block:: python
 
@@ -877,9 +1192,38 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
             AIMessage(
                 content="J'adore programmer. \\n",
-                response_metadata={'prompt_feedback': {'block_reason': 0, 'safety_ratings': []}, 'finish_reason': 'STOP', 'safety_ratings': [{'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HATE_SPEECH', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HARASSMENT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT', 'probability': 'NEGLIGIBLE', 'blocked': False}]},
-                id='run-56cecc34-2e54-4b52-a974-337e47008ad2-0',
-                usage_metadata={'input_tokens': 18, 'output_tokens': 5, 'total_tokens': 23}
+                response_metadata={
+                    "prompt_feedback": {"block_reason": 0, "safety_ratings": []},
+                    "finish_reason": "STOP",
+                    "safety_ratings": [
+                        {
+                            "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+                            "probability": "NEGLIGIBLE",
+                            "blocked": False,
+                        },
+                        {
+                            "category": "HARM_CATEGORY_HATE_SPEECH",
+                            "probability": "NEGLIGIBLE",
+                            "blocked": False,
+                        },
+                        {
+                            "category": "HARM_CATEGORY_HARASSMENT",
+                            "probability": "NEGLIGIBLE",
+                            "blocked": False,
+                        },
+                        {
+                            "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+                            "probability": "NEGLIGIBLE",
+                            "blocked": False,
+                        },
+                    ],
+                },
+                id="run-56cecc34-2e54-4b52-a974-337e47008ad2-0",
+                usage_metadata={
+                    "input_tokens": 18,
+                    "output_tokens": 5,
+                    "total_tokens": 23,
+                },
             )
 
     Stream:
@@ -890,8 +1234,50 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
         .. code-block:: python
 
-            AIMessageChunk(content='J', response_metadata={'finish_reason': 'STOP', 'safety_ratings': []}, id='run-e905f4f4-58cb-4a10-a960-448a2bb649e3', usage_metadata={'input_tokens': 18, 'output_tokens': 1, 'total_tokens': 19})
-            AIMessageChunk(content="'adore programmer. \\n", response_metadata={'finish_reason': 'STOP', 'safety_ratings': [{'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HATE_SPEECH', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HARASSMENT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT', 'probability': 'NEGLIGIBLE', 'blocked': False}]}, id='run-e905f4f4-58cb-4a10-a960-448a2bb649e3', usage_metadata={'input_tokens': 18, 'output_tokens': 5, 'total_tokens': 23})
+            AIMessageChunk(
+                content="J",
+                response_metadata={"finish_reason": "STOP", "safety_ratings": []},
+                id="run-e905f4f4-58cb-4a10-a960-448a2bb649e3",
+                usage_metadata={
+                    "input_tokens": 18,
+                    "output_tokens": 1,
+                    "total_tokens": 19,
+                },
+            )
+            AIMessageChunk(
+                content="'adore programmer. \\n",
+                response_metadata={
+                    "finish_reason": "STOP",
+                    "safety_ratings": [
+                        {
+                            "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+                            "probability": "NEGLIGIBLE",
+                            "blocked": False,
+                        },
+                        {
+                            "category": "HARM_CATEGORY_HATE_SPEECH",
+                            "probability": "NEGLIGIBLE",
+                            "blocked": False,
+                        },
+                        {
+                            "category": "HARM_CATEGORY_HARASSMENT",
+                            "probability": "NEGLIGIBLE",
+                            "blocked": False,
+                        },
+                        {
+                            "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+                            "probability": "NEGLIGIBLE",
+                            "blocked": False,
+                        },
+                    ],
+                },
+                id="run-e905f4f4-58cb-4a10-a960-448a2bb649e3",
+                usage_metadata={
+                    "input_tokens": 18,
+                    "output_tokens": 5,
+                    "total_tokens": 23,
+                },
+            )
 
         .. code-block:: python
 
@@ -905,9 +1291,37 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
             AIMessageChunk(
                 content="J'adore programmer. \\n",
-                response_metadata={'finish_reason': 'STOPSTOP', 'safety_ratings': [{'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HATE_SPEECH', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HARASSMENT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT', 'probability': 'NEGLIGIBLE', 'blocked': False}]},
-                id='run-3ce13a42-cd30-4ad7-a684-f1f0b37cdeec',
-                usage_metadata={'input_tokens': 36, 'output_tokens': 6, 'total_tokens': 42}
+                response_metadata={
+                    "finish_reason": "STOPSTOP",
+                    "safety_ratings": [
+                        {
+                            "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+                            "probability": "NEGLIGIBLE",
+                            "blocked": False,
+                        },
+                        {
+                            "category": "HARM_CATEGORY_HATE_SPEECH",
+                            "probability": "NEGLIGIBLE",
+                            "blocked": False,
+                        },
+                        {
+                            "category": "HARM_CATEGORY_HARASSMENT",
+                            "probability": "NEGLIGIBLE",
+                            "blocked": False,
+                        },
+                        {
+                            "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+                            "probability": "NEGLIGIBLE",
+                            "blocked": False,
+                        },
+                    ],
+                },
+                id="run-3ce13a42-cd30-4ad7-a684-f1f0b37cdeec",
+                usage_metadata={
+                    "input_tokens": 36,
+                    "output_tokens": 6,
+                    "total_tokens": 42,
+                },
             )
 
     Async:
@@ -922,9 +1336,10 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             # await llm.abatch([messages])
 
     Context Caching:
-        Context caching allows you to store and reuse content (e.g., PDFs, images) for faster processing.
-        The ``cached_content`` parameter accepts a cache name created via the Google Generative AI API.
-        Below are two examples: caching a single file directly and caching multiple files using ``Part``.
+        Context caching allows you to store and reuse content (e.g., PDFs, images) for
+        faster processing. The ``cached_content`` parameter accepts a cache name created
+        via the Google Generative AI API. Below are two examples: caching a single file
+        directly and caching multiple files using ``Part``.
 
         Single File Example:
         This caches a single file and queries it.
@@ -941,23 +1356,23 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
             # Upload file
             file = client.files.upload(file="./example_file")
-            while file.state.name == 'PROCESSING':
+            while file.state.name == "PROCESSING":
                 time.sleep(2)
                 file = client.files.get(name=file.name)
 
             # Create cache
-            model = 'models/gemini-1.5-flash-latest'
+            model = "models/gemini-2.5-flash"
             cache = client.caches.create(
                 model=model,
                 config=types.CreateCachedContentConfig(
-                    display_name='Cached Content',
+                    display_name="Cached Content",
                     system_instruction=(
-                        'You are an expert content analyzer, and your job is to answer '
-                        'the user\'s query based on the file you have access to.'
+                        "You are an expert content analyzer, and your job is to answer "
+                        "the user's query based on the file you have access to."
                     ),
                     contents=[file],
                     ttl="300s",
-                )
+                ),
             )
 
             # Query with LangChain
@@ -983,12 +1398,12 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
             # Upload files
             file_1 = client.files.upload(file="./file1")
-            while file_1.state.name == 'PROCESSING':
+            while file_1.state.name == "PROCESSING":
                 time.sleep(2)
                 file_1 = client.files.get(name=file_1.name)
 
             file_2 = client.files.upload(file="./file2")
-            while file_2.state.name == 'PROCESSING':
+            while file_2.state.name == "PROCESSING":
                 time.sleep(2)
                 file_2 = client.files.get(name=file_2.name)
 
@@ -1002,18 +1417,18 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                     ],
                 )
             ]
-            model = "gemini-1.5-flash-latest"
+            model = "gemini-2.5-flash"
             cache = client.caches.create(
                 model=model,
                 config=CreateCachedContentConfig(
-                    display_name='Cached Contents',
+                    display_name="Cached Contents",
                     system_instruction=(
-                        'You are an expert content analyzer, and your job is to answer '
-                        'the user\'s query based on the files you have access to.'
+                        "You are an expert content analyzer, and your job is to answer "
+                        "the user's query based on the files you have access to."
                     ),
                     contents=contents,
                     ttl="300s",
-                )
+                ),
             )
 
             # Query with LangChain
@@ -1021,7 +1436,9 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                 model=model,
                 cached_content=cache.name,
             )
-            message = HumanMessage(content="Provide a summary of the key information across both files.")
+            message = HumanMessage(
+                content="Provide a summary of the key information across both files."
+            )
             llm.invoke([message])
 
     Tool calling:
@@ -1054,23 +1471,34 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
         .. code-block:: python
 
-            [{'name': 'GetWeather',
-              'args': {'location': 'Los Angeles, CA'},
-              'id': 'c186c99f-f137-4d52-947f-9e3deabba6f6'},
-             {'name': 'GetWeather',
-              'args': {'location': 'New York City, NY'},
-              'id': 'cebd4a5d-e800-4fa5-babd-4aa286af4f31'},
-             {'name': 'GetPopulation',
-              'args': {'location': 'Los Angeles, CA'},
-              'id': '4f92d897-f5e4-4d34-a3bc-93062c92591e'},
-             {'name': 'GetPopulation',
-              'args': {'location': 'New York City, NY'},
-              'id': '634582de-5186-4e4b-968b-f192f0a93678'}]
+            [
+                {
+                    "name": "GetWeather",
+                    "args": {"location": "Los Angeles, CA"},
+                    "id": "c186c99f-f137-4d52-947f-9e3deabba6f6",
+                },
+                {
+                    "name": "GetWeather",
+                    "args": {"location": "New York City, NY"},
+                    "id": "cebd4a5d-e800-4fa5-babd-4aa286af4f31",
+                },
+                {
+                    "name": "GetPopulation",
+                    "args": {"location": "Los Angeles, CA"},
+                    "id": "4f92d897-f5e4-4d34-a3bc-93062c92591e",
+                },
+                {
+                    "name": "GetPopulation",
+                    "args": {"location": "New York City, NY"},
+                    "id": "634582de-5186-4e4b-968b-f192f0a93678",
+                },
+            ]
 
     Use Search with Gemini 2:
         .. code-block:: python
 
             from google.ai.generativelanguage_v1beta.types import Tool as GenAITool
+
             llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash")
             resp = llm.invoke(
                 "When is the next total solar eclipse in US?",
@@ -1090,20 +1518,38 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
                 setup: str = Field(description="The setup of the joke")
                 punchline: str = Field(description="The punchline to the joke")
-                rating: Optional[int] = Field(description="How funny the joke is, from 1 to 10")
+                rating: Optional[int] = Field(
+                    description="How funny the joke is, from 1 to 10"
+                )
 
 
+            # Default method uses function calling
             structured_llm = llm.with_structured_output(Joke)
-            structured_llm.invoke("Tell me a joke about cats")
+
+            # For more reliable output, use json_schema with native responseSchema
+            structured_llm_json = llm.with_structured_output(Joke, method="json_schema")
+            structured_llm_json.invoke("Tell me a joke about cats")
 
         .. code-block:: python
 
             Joke(
-                setup='Why are cats so good at video games?',
-                punchline='They have nine lives on the internet',
-                rating=None
+                setup="Why are cats so good at video games?",
+                punchline="They have nine lives on the internet",
+                rating=None,
             )
 
+        Two methods are supported for structured output:
+
+        * ``method="function_calling"`` (default): Uses tool calling to extract
+        structured data. Compatible with all models.
+        * ``method="json_schema"``: Uses Gemini's native structured output with
+        responseSchema. More reliable but requires Gemini 1.5+ models.
+        ``method="json_mode"`` also works for backwards compatibility but is a misnomer.
+
+        The ``json_schema`` method is recommended for better reliability as it
+        constrains the model's generation process directly rather than relying on
+        post-processing tool calls.
+
     Image input:
         .. code-block:: python
 
@@ -1127,7 +1573,10 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
         .. code-block:: python
 
-            'The weather in this image appears to be sunny and pleasant. The sky is a bright blue with scattered white clouds, suggesting fair weather. The lush green grass and trees indicate a warm and possibly slightly breezy day. There are no signs of rain or storms.'
+            "The weather in this image appears to be sunny and pleasant. The sky is a
+            bright blue with scattered white clouds, suggesting fair weather. The lush
+            green grass and trees indicate a warm and possibly slightly breezy day.
+            There are no signs of rain or storms."
 
     PDF input:
         .. code-block:: python
@@ -1135,8 +1584,8 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             import base64
             from langchain_core.messages import HumanMessage
 
-            pdf_bytes = open("/path/to/your/test.pdf", 'rb').read()
-            pdf_base64 = base64.b64encode(pdf_bytes).decode('utf-8')
+            pdf_bytes = open("/path/to/your/test.pdf", "rb").read()
+            pdf_base64 = base64.b64encode(pdf_bytes).decode("utf-8")
 
             message = HumanMessage(
                 content=[
@@ -1144,9 +1593,9 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                     {
                         "type": "file",
                         "source_type": "base64",
-                        "mime_type":"application/pdf",
-                        "data": pdf_base64
-                    }
+                        "mime_type": "application/pdf",
+                        "data": pdf_base64,
+                    },
                 ]
             )
             ai_msg = llm.invoke([message])
@@ -1154,7 +1603,11 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
         .. code-block:: python
 
-            'This research paper describes a system developed for SemEval-2025 Task 9, which aims to automate the detection of food hazards from recall reports, addressing the class imbalance problem by leveraging LLM-based data augmentation techniques and transformer-based models to improve performance.'
+            "This research paper describes a system developed for SemEval-2025 Task 9,
+            which aims to automate the detection of food hazards from recall reports,
+            addressing the class imbalance problem by leveraging LLM-based data
+            augmentation techniques and transformer-based models to improve
+            performance."
 
     Video input:
         .. code-block:: python
@@ -1162,18 +1615,21 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             import base64
             from langchain_core.messages import HumanMessage
 
-            video_bytes = open("/path/to/your/video.mp4", 'rb').read()
-            video_base64 = base64.b64encode(video_bytes).decode('utf-8')
+            video_bytes = open("/path/to/your/video.mp4", "rb").read()
+            video_base64 = base64.b64encode(video_bytes).decode("utf-8")
 
             message = HumanMessage(
                 content=[
-                    {"type": "text", "text": "describe what's in this video in a sentence"},
+                    {
+                        "type": "text",
+                        "text": "describe what's in this video in a sentence",
+                    },
                     {
                         "type": "file",
                         "source_type": "base64",
                         "mime_type": "video/mp4",
-                        "data": video_base64
-                    }
+                        "data": video_base64,
+                    },
                 ]
             )
             ai_msg = llm.invoke([message])
@@ -1181,7 +1637,9 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
         .. code-block:: python
 
-            'Tom and Jerry, along with a turkey, engage in a chaotic Thanksgiving-themed adventure involving a corn-on-the-cob chase, maze antics, and a disastrous attempt to prepare a turkey dinner.'
+            "Tom and Jerry, along with a turkey, engage in a chaotic Thanksgiving-themed
+            adventure involving a corn-on-the-cob chase, maze antics, and a disastrous
+            attempt to prepare a turkey dinner."
 
         You can also pass YouTube URLs directly:
 
@@ -1196,7 +1654,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                         "type": "media",
                         "file_uri": "https://www.youtube.com/watch?v=9hE5-98ZeCg",
                         "mime_type": "video/mp4",
-                    }
+                    },
                 ]
             )
             ai_msg = llm.invoke([message])
@@ -1204,7 +1662,10 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
         .. code-block:: python
 
-            'The video is a demo of multimodal live streaming in Gemini 2.0. The narrator is sharing his screen in AI Studio and asks if the AI can see it. The AI then reads text that is highlighted on the screen, defines the word “multimodal,” and summarizes everything that was seen and heard.'
+            "The video is a demo of multimodal live streaming in Gemini 2.0. The
+            narrator is sharing his screen in AI Studio and asks if the AI can see it.
+            The AI then reads text that is highlighted on the screen, defines the word
+            “multimodal,” and summarizes everything that was seen and heard."
 
     Audio input:
         .. code-block:: python
@@ -1212,8 +1673,8 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             import base64
             from langchain_core.messages import HumanMessage
 
-            audio_bytes = open("/path/to/your/audio.mp3", 'rb').read()
-            audio_base64 = base64.b64encode(audio_bytes).decode('utf-8')
+            audio_bytes = open("/path/to/your/audio.mp3", "rb").read()
+            audio_base64 = base64.b64encode(audio_bytes).decode("utf-8")
 
             message = HumanMessage(
                 content=[
@@ -1221,9 +1682,9 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                     {
                         "type": "file",
                         "source_type": "base64",
-                        "mime_type":"audio/mp3",
-                        "data": audio_base64
-                    }
+                        "mime_type": "audio/mp3",
+                        "data": audio_base64,
+                    },
                 ]
             )
             ai_msg = llm.invoke([message])
@@ -1231,7 +1692,11 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
         .. code-block:: python
 
-            "In this episode of the Made by Google podcast, Stephen Johnson and Simon Tokumine discuss NotebookLM, a tool designed to help users understand complex material in various modalities, with a focus on its unexpected uses, the development of audio overviews, and the implementation of new features like mind maps and source discovery."
+            "In this episode of the Made by Google podcast, Stephen Johnson and Simon
+            Tokumine discuss NotebookLM, a tool designed to help users understand
+            complex material in various modalities, with a focus on its unexpected uses,
+            the development of audio overviews, and the implementation of new features
+            like mind maps and source discovery."
 
     File upload (URI-based):
         You can also upload files to Google's servers and reference them by URI.
@@ -1265,7 +1730,10 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
         .. code-block:: python
 
-            "This research paper assesses and mitigates multi-turn jailbreak vulnerabilities in large language models using the Crescendo attack study, evaluating attack success rates and mitigation strategies like prompt hardening and LLM-as-guardrail."
+            "This research paper assesses and mitigates multi-turn jailbreak
+            vulnerabilities in large language models using the Crescendo attack study,
+            evaluating attack success rates and mitigation strategies like prompt
+            hardening and LLM-as-guardrail."
 
     Token usage:
         .. code-block:: python
@@ -1275,7 +1743,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
         .. code-block:: python
 
-            {'input_tokens': 18, 'output_tokens': 5, 'total_tokens': 23}
+            {"input_tokens": 18, "output_tokens": 5, "total_tokens": 23}
 
 
     Response metadata
@@ -1287,9 +1755,30 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         .. code-block:: python
 
             {
-                'prompt_feedback': {'block_reason': 0, 'safety_ratings': []},
-                'finish_reason': 'STOP',
-                'safety_ratings': [{'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HATE_SPEECH', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HARASSMENT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT', 'probability': 'NEGLIGIBLE', 'blocked': False}]
+                "prompt_feedback": {"block_reason": 0, "safety_ratings": []},
+                "finish_reason": "STOP",
+                "safety_ratings": [
+                    {
+                        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+                        "probability": "NEGLIGIBLE",
+                        "blocked": False,
+                    },
+                    {
+                        "category": "HARM_CATEGORY_HATE_SPEECH",
+                        "probability": "NEGLIGIBLE",
+                        "blocked": False,
+                    },
+                    {
+                        "category": "HARM_CATEGORY_HARASSMENT",
+                        "probability": "NEGLIGIBLE",
+                        "blocked": False,
+                    },
+                    {
+                        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+                        "probability": "NEGLIGIBLE",
+                        "blocked": False,
+                    },
+                ],
             }
 
     """  # noqa: E501
@@ -1303,32 +1792,33 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
     convert_system_message_to_human: bool = False
     """Whether to merge any leading SystemMessage into the following HumanMessage.
 
-    Gemini does not support system messages; any unsupported messages will
-    raise an error."""
+    Gemini does not support system messages; any unsupported messages will raise an
+    error.
+    """
 
     response_mime_type: Optional[str] = None
     """Optional. Output response mimetype of the generated candidate text. Only
     supported in Gemini 1.5 and later models.
-    
+
     Supported mimetype:
         * ``'text/plain'``: (default) Text output.
         * ``'application/json'``: JSON response in the candidates.
         * ``'text/x.enum'``: Enum in plain text.
-    
+
     The model also needs to be prompted to output the appropriate response
     type, otherwise the behavior is undefined. This is a preview feature.
     """
 
     response_schema: Optional[Dict[str, Any]] = None
-    """ Optional. Enforce an schema to the output.
-        The format of the dictionary should follow Open API schema.
+    """ Optional. Enforce an schema to the output. The format of the dictionary should
+    follow Open API schema.
     """
 
     cached_content: Optional[str] = None
-    """The name of the cached content used as context to serve the prediction. 
+    """The name of the cached content used as context to serve the prediction.
 
-    Note: only used in explicit caching, where users can have control over caching 
-    (e.g. what content to cache) and enjoy guaranteed cost savings. Format: 
+    Note: only used in explicit caching, where users can have control over caching
+    (e.g. what content to cache) and enjoy guaranteed cost savings. Format:
     ``cachedContents/{cachedContent}``.
     """
 
@@ -1384,7 +1874,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         )
 
     @classmethod
-    def is_lc_serializable(self) -> bool:
+    def is_lc_serializable(cls) -> bool:
         return True
 
     @model_validator(mode="before")
@@ -1392,20 +1882,22 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
     def build_extra(cls, values: dict[str, Any]) -> Any:
         """Build extra kwargs from additional params that were passed in."""
         all_required_field_names = get_pydantic_field_names(cls)
-        values = _build_model_kwargs(values, all_required_field_names)
-        return values
+        return _build_model_kwargs(values, all_required_field_names)
 
     @model_validator(mode="after")
     def validate_environment(self) -> Self:
         """Validates params and passes them to google-generativeai package."""
         if self.temperature is not None and not 0 <= self.temperature <= 2.0:
-            raise ValueError("temperature must be in the range [0.0, 2.0]")
+            msg = "temperature must be in the range [0.0, 2.0]"
+            raise ValueError(msg)
 
         if self.top_p is not None and not 0 <= self.top_p <= 1:
-            raise ValueError("top_p must be in the range [0.0, 1.0]")
+            msg = "top_p must be in the range [0.0, 1.0]"
+            raise ValueError(msg)
 
         if self.top_k is not None and self.top_k <= 0:
-            raise ValueError("top_k must be positive")
+            msg = "top_k must be positive"
+            raise ValueError(msg)
 
         if not any(self.model.startswith(prefix) for prefix in ("models/",)):
             self.model = f"models/{self.model}"
@@ -1480,31 +1972,29 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         code_execution: Optional[bool] = None,
         stop: Optional[list[str]] = None,
         **kwargs: Any,
-    ) -> BaseMessage:
-        """
-        Enable code execution. Supported on: gemini-1.5-pro, gemini-1.5-flash,
-        gemini-2.0-flash, and gemini-2.0-pro. When enabled, the model can execute
-        code to solve problems.
-        """
+    ) -> AIMessage:
+        """Override invoke to add code_execution parameter.
 
-        """Override invoke to add code_execution parameter."""
+        Supported on: gemini-1.5-pro, gemini-1.5-flash, gemini-2.0-flash, and
+        gemini-2.0-pro. When enabled, the model can execute code to solve problems.
+        """
 
         if code_execution is not None:
             if not self._supports_code_execution:
-                raise ValueError(
+                msg = (
                     f"Code execution is only supported on Gemini 1.5 Pro, \
                     Gemini 1.5 Flash, "
                     f"Gemini 2.0 Flash, and Gemini 2.0 Pro models. \
                     Current model: {self.model}"
                 )
+                raise ValueError(msg)
             if "tools" not in kwargs:
                 code_execution_tool = GoogleTool(code_execution=CodeExecution())
                 kwargs["tools"] = [code_execution_tool]
 
             else:
-                raise ValueError(
-                    "Tools are already defined.code_execution tool can't be defined"
-                )
+                msg = "Tools are already defined.code_execution tool can't be defined"
+                raise ValueError(msg)
 
         return super().invoke(input, config, stop=stop, **kwargs)
 
@@ -1616,6 +2106,10 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             tool_choice=tool_choice,
             **kwargs,
         )
+        if self.timeout is not None and "timeout" not in kwargs:
+            kwargs["timeout"] = self.timeout
+        if "max_retries" not in kwargs:
+            kwargs["max_retries"] = self.max_retries
         response: GenerateContentResponse = _chat_with_retry(
             request=request,
             **kwargs,
@@ -1642,13 +2136,11 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         if not self.async_client:
             updated_kwargs = {
                 **kwargs,
-                **{
-                    "tools": tools,
-                    "functions": functions,
-                    "safety_settings": safety_settings,
-                    "tool_config": tool_config,
-                    "generation_config": generation_config,
-                },
+                "tools": tools,
+                "functions": functions,
+                "safety_settings": safety_settings,
+                "tool_config": tool_config,
+                "generation_config": generation_config,
             }
             return await super()._agenerate(
                 messages, stop, run_manager, **updated_kwargs
@@ -1666,6 +2158,10 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             tool_choice=tool_choice,
             **kwargs,
         )
+        if self.timeout is not None and "timeout" not in kwargs:
+            kwargs["timeout"] = self.timeout
+        if "max_retries" not in kwargs:
+            kwargs["max_retries"] = self.max_retries
         response: GenerateContentResponse = await _achat_with_retry(
             request=request,
             **kwargs,
@@ -1701,6 +2197,10 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             tool_choice=tool_choice,
             **kwargs,
         )
+        if self.timeout is not None and "timeout" not in kwargs:
+            kwargs["timeout"] = self.timeout
+        if "max_retries" not in kwargs:
+            kwargs["max_retries"] = self.max_retries
         response: GenerateContentResponse = _chat_with_retry(
             request=request,
             generation_method=self.client.stream_generate_content,
@@ -1713,8 +2213,8 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             _chat_result = _response_to_result(
                 chunk, stream=True, prev_usage=prev_usage_metadata
             )
-            gen = cast(ChatGenerationChunk, _chat_result.generations[0])
-            message = cast(AIMessageChunk, gen.message)
+            gen = cast("ChatGenerationChunk", _chat_result.generations[0])
+            message = cast("AIMessageChunk", gen.message)
 
             prev_usage_metadata = (
                 message.usage_metadata
@@ -1744,13 +2244,11 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         if not self.async_client:
             updated_kwargs = {
                 **kwargs,
-                **{
-                    "tools": tools,
-                    "functions": functions,
-                    "safety_settings": safety_settings,
-                    "tool_config": tool_config,
-                    "generation_config": generation_config,
-                },
+                "tools": tools,
+                "functions": functions,
+                "safety_settings": safety_settings,
+                "tool_config": tool_config,
+                "generation_config": generation_config,
             }
             async for value in super()._astream(
                 messages, stop, run_manager, **updated_kwargs
@@ -1769,6 +2267,10 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                 tool_choice=tool_choice,
                 **kwargs,
             )
+            if self.timeout is not None and "timeout" not in kwargs:
+                kwargs["timeout"] = self.timeout
+            if "max_retries" not in kwargs:
+                kwargs["max_retries"] = self.max_retries
             prev_usage_metadata: UsageMetadata | None = None  # cumulative usage
             async for chunk in await _achat_with_retry(
                 request=request,
@@ -1779,8 +2281,8 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                 _chat_result = _response_to_result(
                     chunk, stream=True, prev_usage=prev_usage_metadata
                 )
-                gen = cast(ChatGenerationChunk, _chat_result.generations[0])
-                message = cast(AIMessageChunk, gen.message)
+                gen = cast("ChatGenerationChunk", _chat_result.generations[0])
+                message = cast("AIMessageChunk", gen.message)
 
                 prev_usage_metadata = (
                     message.usage_metadata
@@ -1807,10 +2309,11 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         **kwargs: Any,
     ) -> GenerateContentRequest:
         if tool_choice and tool_config:
-            raise ValueError(
+            msg = (
                 "Must specify at most one of tool_choice and tool_config, received "
                 f"both:\n\n{tool_choice=}\n\n{tool_config=}"
             )
+            raise ValueError(msg)
 
         formatted_tools = None
         code_execution_tool = GoogleTool(code_execution=CodeExecution())
@@ -1848,16 +2351,15 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             all_names: List[str] = []
             for t in formatted_tools:
                 if hasattr(t, "function_declarations"):
-                    t_with_declarations = cast(Any, t)
+                    t_with_declarations = cast("Any", t)
                     all_names.extend(
                         f.name for f in t_with_declarations.function_declarations
                     )
                 elif isinstance(t, GoogleTool) and hasattr(t, "code_execution"):
                     continue
                 else:
-                    raise TypeError(
-                        f"Tool {t} doesn't have function_declarations attribute"
-                    )
+                    msg = f"Tool {t} doesn't have function_declarations attribute"
+                    raise TypeError(msg)
 
             tool_config = _tool_choice_to_tool_config(tool_choice, all_names)
 
@@ -1874,7 +2376,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             ]
         request = GenerateContentRequest(
             model=self.model,
-            contents=history,
+            contents=history,  # google.ai.generativelanguage_v1beta.types.Content
             tools=formatted_tools,
             tool_config=formatted_tool_config,
             safety_settings=formatted_safety_settings,
@@ -1891,7 +2393,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         return request
 
     def get_num_tokens(self, text: str) -> int:
-        """Get the number of tokens present in the text.
+        """Get the number of tokens present in the text. Uses the model's tokenizer.
 
         Useful for checking if an input will fit in a model's context window.
 
@@ -1909,18 +2411,22 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
     def with_structured_output(
         self,
         schema: Union[Dict, Type[BaseModel]],
-        method: Optional[Literal["function_calling", "json_mode"]] = "function_calling",
+        method: Optional[
+            Literal["function_calling", "json_mode", "json_schema"]
+        ] = "function_calling",
         *,
         include_raw: bool = False,
         **kwargs: Any,
     ) -> Runnable[LanguageModelInput, Union[Dict, BaseModel]]:
         _ = kwargs.pop("strict", None)
         if kwargs:
-            raise ValueError(f"Received unsupported arguments {kwargs}")
+            msg = f"Received unsupported arguments {kwargs}"
+            raise ValueError(msg)
 
         parser: OutputParserLike
 
-        if method == "json_mode":
+        # `json_schema` preferred, but `json_mode` kept for backwards compatibility
+        if method in ("json_mode", "json_schema"):
             if isinstance(schema, type) and is_basemodel_subclass(schema):
                 if issubclass(schema, BaseModelV1):
                     schema_json = schema.schema()
@@ -1933,7 +2439,8 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                 elif isinstance(schema, dict):
                     schema_json = schema
                 else:
-                    raise ValueError(f"Unsupported schema type {type(schema)}")
+                    msg = f"Unsupported schema type {type(schema)}"
+                    raise ValueError(msg)
                 parser = JsonOutputParser()
 
             # Resolve refs in schema because they are not supported
@@ -1976,8 +2483,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                 exception_key="parsing_error",
             )
             return {"raw": llm} | parser_with_fallback
-        else:
-            return llm | parser
+        return llm | parser
 
     def bind_tools(
         self,
@@ -1988,27 +2494,28 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         *,
         tool_choice: Optional[Union[_ToolChoiceType, bool]] = None,
         **kwargs: Any,
-    ) -> Runnable[LanguageModelInput, BaseMessage]:
+    ) -> Runnable[LanguageModelInput, AIMessage]:
         """Bind tool-like objects to this chat model.
 
         Assumes model is compatible with google-generativeAI tool-calling API.
 
         Args:
             tools: A list of tool definitions to bind to this chat model.
-                Can be a pydantic model, callable, or BaseTool. Pydantic
-                models, callables, and BaseTools will be automatically converted to
-                their schema dictionary representation. Tools with Union types in
-                their arguments are now supported and converted to `anyOf` schemas.
+                Can be a pydantic model, callable, or BaseTool. Pydantic models,
+                callables, and BaseTools will be automatically converted to their schema
+                dictionary representation. Tools with Union types in their arguments are
+                now supported and converted to `anyOf` schemas.
             **kwargs: Any additional parameters to pass to the
                 :class:`~langchain.runnable.Runnable` constructor.
         """
         if tool_choice and tool_config:
-            raise ValueError(
+            msg = (
                 "Must specify at most one of tool_choice and tool_config, received "
                 f"both:\n\n{tool_choice=}\n\n{tool_config=}"
             )
+            raise ValueError(msg)
         try:
-            formatted_tools: list = [convert_to_openai_tool(tool) for tool in tools]  # type: ignore[arg-type]
+            formatted_tools: list = [convert_to_openai_tool(tool) for tool in tools]
         except Exception:
             formatted_tools = [
                 tool_to_dict(convert_to_genai_function_declarations(tools))
@@ -2035,9 +2542,8 @@ def _get_tool_name(
 ) -> str:
     try:
         genai_tool = tool_to_dict(convert_to_genai_function_declarations([tool]))
-        return [f["name"] for f in genai_tool["function_declarations"]][0]  # type: ignore[index]
-    except ValueError as e:  # other TypedDict
+        return next(f["name"] for f in genai_tool["function_declarations"])  # type: ignore[index]
+    except ValueError:  # other TypedDict
         if is_typeddict(tool):
-            return convert_to_openai_tool(cast(Dict, tool))["function"]["name"]
-        else:
-            raise e
+            return convert_to_openai_tool(cast("Dict", tool))["function"]["name"]
+        raise