langchain-google-genai 2.1.1__tar.gz → 2.1.3__tar.gz

{langchain_google_genai-2.1.1 → langchain_google_genai-2.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-google-genai
-Version: 2.1.1
+Version: 2.1.3
 Summary: An integration package connecting Google's genai package and LangChain
 Home-page: https://github.com/langchain-ai/langchain-google
 License: MIT
@@ -13,7 +13,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: filetype (>=1.2.0,<2.0.0)
 Requires-Dist: google-ai-generativelanguage (>=0.6.16,<0.7.0)
-Requires-Dist: langchain-core (>=0.3.47,<0.4.0)
+Requires-Dist: langchain-core (>=0.3.52,<0.4.0)
 Requires-Dist: pydantic (>=2,<3)
 Project-URL: Repository, https://github.com/langchain-ai/langchain-google
 Project-URL: Source Code, https://github.com/langchain-ai/langchain-google/tree/main/libs/genai
@@ -98,7 +98,7 @@ meow_str = response.content[1]
 
 #### Multimodal Outputs in Chains
 
-'''
+```
 from langchain_core.runnables import RunnablePassthrough
 from langchain_core.prompts import ChatPromptTemplate
 
@@ -114,7 +114,7 @@ prompt = ChatPromptTemplate(
 )
 chain = {"animal": RunnablePassthrough()} | prompt | llm
 res = chain.invoke("cat")
-'''
+```
 
 ## Embeddings
 

{langchain_google_genai-2.1.1 → langchain_google_genai-2.1.3}/README.md

@@ -77,7 +77,7 @@ meow_str = response.content[1]
 
 #### Multimodal Outputs in Chains
 
-'''
+```
 from langchain_core.runnables import RunnablePassthrough
 from langchain_core.prompts import ChatPromptTemplate
 
@@ -93,7 +93,7 @@ prompt = ChatPromptTemplate(
 )
 chain = {"animal": RunnablePassthrough()} | prompt | llm
 res = chain.invoke("cat")
-'''
+```
 
 ## Embeddings
 

{langchain_google_genai-2.1.1 → langchain_google_genai-2.1.3}/langchain_google_genai/_common.py

@@ -36,7 +36,7 @@ Supported examples:
     "the GOOGLE_API_KEY envvar"
     temperature: float = 0.7
     """Run inference with this temperature. Must by in the closed interval
-       [0.0, 1.0]."""
+       [0.0, 2.0]."""
     top_p: Optional[float] = None
     """Decode using nucleus sampling: consider the smallest set of tokens whose
        probability sum is at least top_p. Must be in the closed interval [0.0, 1.0]."""

{langchain_google_genai-2.1.1 → langchain_google_genai-2.1.3}/langchain_google_genai/_function_utils.py

@@ -61,18 +61,22 @@ _ALLOWED_SCHEMA_FIELDS_SET = set(_ALLOWED_SCHEMA_FIELDS)
 _FunctionDeclarationLike = Union[
     BaseTool, Type[BaseModel], gapic.FunctionDeclaration, Callable, Dict[str, Any]
 ]
+_GoogleSearchRetrievalLike = Union[
+    gapic.GoogleSearchRetrieval,
+    Dict[str, Any],
+]
 
 
 class _ToolDict(TypedDict):
     function_declarations: Sequence[_FunctionDeclarationLike]
+    google_search_retrieval: Optional[_GoogleSearchRetrievalLike]
 
 
 # Info: This means one tool=Sequence of FunctionDeclaration
 # The dict should be gapic.Tool like. {"function_declarations": [ { "name": ...}.
 # OpenAI like dict is not be accepted. {{'type': 'function', 'function': {'name': ...}
-_ToolsType = Union[
-    gapic.Tool, _ToolDict, _FunctionDeclarationLike, Sequence[_FunctionDeclarationLike]
-]
+_ToolType = Union[gapic.Tool, _ToolDict, _FunctionDeclarationLike]
+_ToolsType = Sequence[_ToolType]
 
 
 def _format_json_schema_to_gapic(schema: Dict[str, Any]) -> Dict[str, Any]:
@@ -122,7 +126,7 @@ def _format_dict_to_function_declaration(
 
 # Info: gapic.Tool means function_declarations and proto.Message.
 def convert_to_genai_function_declarations(
-    tools: Sequence[_ToolsType],
+    tools: _ToolsType,
 ) -> gapic.Tool:
     if not isinstance(tools, collections.abc.Sequence):
         logger.warning(
@@ -132,24 +136,54 @@ def convert_to_genai_function_declarations(
         tools = [tools]
     gapic_tool = gapic.Tool()
     for tool in tools:
-        if isinstance(tool, gapic.Tool):
-            gapic_tool.function_declarations.extend(tool.function_declarations)  # type: ignore[union-attr]
-        elif isinstance(tool, dict) and "function_declarations" not in tool:
-            fd = _format_to_gapic_function_declaration(tool)
-            gapic_tool.function_declarations.append(fd)
+        if any(f in gapic_tool for f in ["google_search_retrieval"]):
+            raise ValueError(
+                "Providing multiple google_search_retrieval"
+                " or mixing with function_declarations is not supported"
+            )
+        if isinstance(tool, (gapic.Tool)):
+            rt: gapic.Tool = (
+                tool if isinstance(tool, gapic.Tool) else tool._raw_tool  # type: ignore
+            )
+            if "google_search_retrieval" in rt:
+                gapic_tool.google_search_retrieval = rt.google_search_retrieval
+            if "function_declarations" in rt:
+                gapic_tool.function_declarations.extend(rt.function_declarations)
+            if "google_search" in rt:
+                gapic_tool.google_search = rt.google_search
         elif isinstance(tool, dict):
-            function_declarations = cast(_ToolDict, tool)["function_declarations"]
-            if not isinstance(function_declarations, collections.abc.Sequence):
-                raise ValueError(
-                    "function_declarations should be a list"
-                    f"got '{type(function_declarations)}'"
-                )
-            if function_declarations:
-                fds = [
-                    _format_to_gapic_function_declaration(fd)
-                    for fd in function_declarations
+            # not _ToolDictLike
+            if not any(
+                f in tool
+                for f in [
+                    "function_declarations",
+                    "google_search_retrieval",
                 ]
-                gapic_tool.function_declarations.extend(fds)
+            ):
+                fd = _format_to_gapic_function_declaration(tool)  # type: ignore[arg-type]
+                gapic_tool.function_declarations.append(fd)
+                continue
+            # _ToolDictLike
+            tool = cast(_ToolDict, tool)
+            if "function_declarations" in tool:
+                function_declarations = tool["function_declarations"]
+                if not isinstance(
+                    tool["function_declarations"], collections.abc.Sequence
+                ):
+                    raise ValueError(
+                        "function_declarations should be a list"
+                        f"got '{type(function_declarations)}'"
+                    )
+                if function_declarations:
+                    fds = [
+                        _format_to_gapic_function_declaration(fd)
+                        for fd in function_declarations
+                    ]
+                    gapic_tool.function_declarations.extend(fds)
+            if "google_search_retrieval" in tool:
+                gapic_tool.google_search_retrieval = gapic.GoogleSearchRetrieval(
+                    tool["google_search_retrieval"]
+                )
         else:
             fd = _format_to_gapic_function_declaration(tool)  # type: ignore[arg-type]
             gapic_tool.function_declarations.append(fd)

{langchain_google_genai-2.1.1 → langchain_google_genai-2.1.3}/langchain_google_genai/chat_models.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
 import asyncio
+import base64
 import json
 import logging
+import mimetypes
 import uuid
 import warnings
+from difflib import get_close_matches
 from operator import itemgetter
 from typing import (
     Any,
@@ -22,6 +25,7 @@ from typing import (
     cast,
 )
 
+import filetype  # type: ignore[import]
 import google.api_core
 
 # TODO: remove ignore once the google package is published with types
@@ -32,6 +36,7 @@ from google.ai.generativelanguage_v1beta import (
 from google.ai.generativelanguage_v1beta.types import (
     Blob,
     Candidate,
+    CodeExecution,
     Content,
     FileData,
     FunctionCall,
@@ -45,9 +50,7 @@ from google.ai.generativelanguage_v1beta.types import (
     ToolConfig,
     VideoMetadata,
 )
-from google.ai.generativelanguage_v1beta.types import (
-    Tool as GoogleTool,
-)
+from google.ai.generativelanguage_v1beta.types import Tool as GoogleTool
 from langchain_core.callbacks.manager import (
     AsyncCallbackManagerForLLMRun,
     CallbackManagerForLLMRun,
@@ -62,6 +65,7 @@ from langchain_core.messages import (
     HumanMessage,
     SystemMessage,
     ToolMessage,
+    is_data_content_block,
 )
 from langchain_core.messages.ai import UsageMetadata
 from langchain_core.messages.tool import invalid_tool_call, tool_call, tool_call_chunk
@@ -72,7 +76,7 @@ from langchain_core.output_parsers.openai_tools import (
     parse_tool_calls,
 )
 from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult
-from langchain_core.runnables import Runnable, RunnablePassthrough
+from langchain_core.runnables import Runnable, RunnableConfig, RunnablePassthrough
 from langchain_core.tools import BaseTool
 from langchain_core.utils.function_calling import convert_to_openai_tool
 from pydantic import (
@@ -113,9 +117,6 @@ from langchain_google_genai._image_utils import (
 
 from . import _genai_extension as genaix
 
-WARNED_STRUCTURED_OUTPUT_JSON_MODE = False
-
-
 logger = logging.getLogger(__name__)
 
 
@@ -240,7 +241,7 @@ async def _achat_with_retry(generation_method: Callable, **kwargs: Any) -> Any:
     return await _achat_with_retry(**kwargs)
 
 
-def _is_openai_parts_format(part: dict) -> bool:
+def _is_lc_content_block(part: dict) -> bool:
     return "type" in part
 
 
@@ -255,10 +256,29 @@ def _convert_to_parts(
         if isinstance(part, str):
             parts.append(Part(text=part))
         elif isinstance(part, Mapping):
-            # OpenAI Format
-            if _is_openai_parts_format(part):
+            if _is_lc_content_block(part):
                 if part["type"] == "text":
                     parts.append(Part(text=part["text"]))
+                elif is_data_content_block(part):
+                    if part["source_type"] == "url":
+                        bytes_ = image_loader._bytes_from_url(part["url"])
+                    elif part["source_type"] == "base64":
+                        bytes_ = base64.b64decode(part["data"])
+                    else:
+                        raise ValueError("source_type must be url or base64.")
+                    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"))
+                        mime_type, _ = mimetypes.guess_type(source)
+                        if not mime_type:
+                            kind = filetype.guess(bytes_)
+                            if kind:
+                                mime_type = kind.mime
+                        if mime_type:
+                            inline_data["mime_type"] = mime_type
+                    parts.append(Part(inline_data=inline_data))
                 elif part["type"] == "image_url":
                     img_url = part["image_url"]
                     if isinstance(img_url, dict):
@@ -458,6 +478,41 @@ def _parse_response_candidate(
             elif text:
                 raise Exception("Unexpected content type")
 
+        if hasattr(part, "executable_code") and part.executable_code is not None:
+            if part.executable_code.code and part.executable_code.language:
+                code_message = {
+                    "type": "executable_code",
+                    "executable_code": part.executable_code.code,
+                    "language": part.executable_code.language,
+                }
+                if not content:
+                    content = [code_message]
+                elif isinstance(content, str):
+                    content = [content, code_message]
+                elif isinstance(content, list):
+                    content.append(code_message)
+                else:
+                    raise Exception("Unexpected content type")
+
+        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,
+                }
+
+                if not content:
+                    content = [execution_result]
+                elif isinstance(content, str):
+                    content = [content, execution_result]
+                elif isinstance(content, list):
+                    content.append(execution_result)
+                else:
+                    raise Exception("Unexpected content type")
+
         if part.inline_data.mime_type.startswith("image/"):
             image_format = part.inline_data.mime_type[6:]
             message = {
@@ -521,6 +576,16 @@ def _parse_response_candidate(
                     )
     if content is None:
         content = ""
+    if any(isinstance(item, dict) and "executable_code" in item for item in content):
+        warnings.warn(
+            """
+        ⚠️ 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(
@@ -575,6 +640,8 @@ def _response_to_result(
         generation_info = {}
         if candidate.finish_reason:
             generation_info["finish_reason"] = candidate.finish_reason.name
+            # Add model_name in last chunk
+            generation_info["model_name"] = response.model_version
         generation_info["safety_ratings"] = [
             proto.Message.to_dict(safety_rating, use_integers_for_enums=False)
             for safety_rating in candidate.safety_ratings
@@ -663,7 +730,7 @@ 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="'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
 
@@ -693,6 +760,109 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             # batch:
             # 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`.
+
+        Single File Example:
+        This caches a single file and queries it.
+
+        .. code-block:: python
+
+            from google import genai
+            from google.genai import types
+            import time
+            from langchain_google_genai import ChatGoogleGenerativeAI
+            from langchain_core.messages import HumanMessage
+
+            client = genai.Client()
+
+            # Upload file
+            file = client.files.upload(file="./example_file")
+            while file.state.name == 'PROCESSING':
+                time.sleep(2)
+                file = client.files.get(name=file.name)
+
+            # Create cache
+            model = 'models/gemini-1.5-flash-001'
+            cache = client.caches.create(
+                model=model,
+                config=types.CreateCachedContentConfig(
+                    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.'
+                    ),
+                    contents=[file],
+                    ttl="300s",
+                )
+            )
+
+            # Query with LangChain
+            llm = ChatGoogleGenerativeAI(
+                model=model,
+                cached_content=cache.name,
+            )
+            message = HumanMessage(content="Summarize the main points of the content.")
+            llm.invoke([message])
+
+        Multiple Files Example:
+        This caches two files using `Part` and queries them together.
+
+        .. code-block:: python
+
+            from google import genai
+            from google.genai.types import CreateCachedContentConfig, Content, Part
+            import time
+            from langchain_google_genai import ChatGoogleGenerativeAI
+            from langchain_core.messages import HumanMessage
+
+            client = genai.Client()
+
+            # Upload files
+            file_1 = client.files.upload(file="./file1")
+            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':
+                time.sleep(2)
+                file_2 = client.files.get(name=file_2.name)
+
+            # Create cache with multiple files
+            contents = [
+                Content(
+                    role="user",
+                    parts=[
+                        Part.from_uri(file_uri=file_1.uri, mime_type=file_1.mime_type),
+                        Part.from_uri(file_uri=file_2.uri, mime_type=file_2.mime_type),
+                    ],
+                )
+            ]
+            model = "gemini-1.5-flash-001"
+            cache = client.caches.create(
+                model=model,
+                config=CreateCachedContentConfig(
+                    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.'
+                    ),
+                    contents=contents,
+                    ttl="300s",
+                )
+            )
+
+            # Query with LangChain
+            llm = ChatGoogleGenerativeAI(
+                model=model,
+                cached_content=cache.name,
+            )
+            message = HumanMessage(content="Provide a summary of the key information across both files.")
+            llm.invoke([message])
+
     Tool calling:
         .. code-block:: python
 
@@ -736,6 +906,16 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
               '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.0-flash-exp")
+            resp = llm.invoke(
+                "When is the next total solar eclipse in US?",
+                tools=[GenAITool(google_search={})],
+            )
+
     Structured output:
         .. code-block:: python
 
@@ -786,7 +966,7 @@ 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. \n'
+            '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.'
 
     Token usage:
         .. code-block:: python
@@ -835,6 +1015,28 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
     ``cachedContents/{cachedContent}``.
     """
 
+    def __init__(self, **kwargs: Any) -> None:
+        """Needed for arg validation."""
+        # Get all valid field names, including aliases
+        valid_fields = set()
+        for field_name, field_info in self.model_fields.items():
+            valid_fields.add(field_name)
+            if hasattr(field_info, "alias") and field_info.alias is not None:
+                valid_fields.add(field_info.alias)
+
+        # Check for unrecognized arguments
+        for arg in kwargs:
+            if arg not in valid_fields:
+                suggestions = get_close_matches(arg, valid_fields, n=1)
+                suggestion = (
+                    f" Did you mean: '{suggestions[0]}'?" if suggestions else ""
+                )
+                logger.warning(
+                    f"Unexpected argument '{arg}' "
+                    f"provided to ChatGoogleGenerativeAI.{suggestion}"
+                )
+        super().__init__(**kwargs)
+
     model_config = ConfigDict(
         populate_by_name=True,
     )
@@ -847,6 +1049,14 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
     def _llm_type(self) -> str:
         return "chat-google-generative-ai"
 
+    @property
+    def _supports_code_execution(self) -> bool:
+        return (
+            "gemini-1.5-pro" in self.model
+            or "gemini-1.5-flash" in self.model
+            or "gemini-2" in self.model
+        )
+
     @classmethod
     def is_lc_serializable(self) -> bool:
         return True
@@ -863,7 +1073,9 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         if self.top_k is not None and self.top_k <= 0:
             raise ValueError("top_k must be positive")
 
-        if not self.model.startswith("models/"):
+        if not any(
+            self.model.startswith(prefix) for prefix in ("models/", "tunedModels/")
+        ):
             self.model = f"models/{self.model}"
 
         additional_headers = self.additional_headers or {}
@@ -900,12 +1112,17 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         # this check ensures that async client is only initialized
         # within an asyncio event loop to avoid the error
         if not self.async_client_running and _is_event_loop_running():
+            # async clients don't support "rest" transport
+            # https://github.com/googleapis/gapic-generator-python/issues/1962
+            transport = self.transport
+            if transport == "rest":
+                transport = "grpc_asyncio"
             self.async_client_running = genaix.build_generative_async_service(
                 credentials=self.credentials,
                 api_key=google_api_key,
                 client_info=get_client_info("ChatGoogleGenerativeAI"),
                 client_options=self.client_options,
-                transport=self.transport,
+                transport=transport,
             )
         return self.async_client_running
 
@@ -921,6 +1138,42 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             "response_modalities": self.response_modalities,
         }
 
+    def invoke(
+        self,
+        input: LanguageModelInput,
+        config: Optional[RunnableConfig] = None,
+        *,
+        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.
+        """
+
+        """Override invoke to add code_execution parameter."""
+
+        if code_execution is not None:
+            if not self._supports_code_execution:
+                raise ValueError(
+                    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}"
+                )
+            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"
+                )
+
+        return super().invoke(input, config, stop=stop, **kwargs)
+
     def _get_ls_params(
         self, stop: Optional[List[str]] = None, **kwargs: Any
     ) -> LangSmithParams:
@@ -1199,8 +1452,12 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                 "Must specify at most one of tool_choice and tool_config, received "
                 f"both:\n\n{tool_choice=}\n\n{tool_config=}"
             )
+
         formatted_tools = None
-        if tools:
+        code_execution_tool = GoogleTool(code_execution=CodeExecution())
+        if tools == [code_execution_tool]:
+            formatted_tools = tools
+        elif tools:
             formatted_tools = [convert_to_genai_function_declarations(tools)]
         elif functions:
             formatted_tools = [convert_to_genai_function_declarations(functions)]
@@ -1226,9 +1483,20 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                     f"be specified if 'tools' is specified."
                 )
                 raise ValueError(msg)
-            all_names = [
-                f.name for t in formatted_tools for f in t.function_declarations
-            ]
+            all_names: List[str] = []
+            for t in formatted_tools:
+                if hasattr(t, "function_declarations"):
+                    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"
+                    )
+
             tool_config = _tool_choice_to_tool_config(tool_choice, all_names)
 
         formatted_tool_config = None
@@ -1291,14 +1559,6 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                 tools=[schema], first_tool_only=True
             )
         else:
-            global WARNED_STRUCTURED_OUTPUT_JSON_MODE
-            warnings.warn(
-                "ChatGoogleGenerativeAI.with_structured_output with dict schema has "
-                "changed recently to align with behavior of other LangChain chat "
-                "models. More context: "
-                "https://github.com/langchain-ai/langchain-google/pull/772"
-            )
-            WARNED_STRUCTURED_OUTPUT_JSON_MODE = True
             parser = JsonOutputKeyToolsParser(key_name=tool_name, first_tool_only=True)
         tool_choice = tool_name if self._supports_tool_choice else None
         try:

{langchain_google_genai-2.1.1 → langchain_google_genai-2.1.3}/langchain_google_genai/embeddings.py

@@ -6,6 +6,7 @@ from typing import Any, Dict, List, Optional
 from google.ai.generativelanguage_v1beta.types import (
     BatchEmbedContentsRequest,
     EmbedContentRequest,
+    EmbedContentResponse,
 )
 from langchain_core.embeddings import Embeddings
 from langchain_core.utils import secret_from_env
@@ -239,7 +240,8 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
         title: Optional[str] = None,
         output_dimensionality: Optional[int] = None,
     ) -> List[float]:
-        """Embed a text.
+        """Embed a text, using the non-batch endpoint:
+        https://ai.google.dev/api/rest/v1/models/embedContent#EmbedContentRequest
 
         Args:
             text: The text to embed.
@@ -247,15 +249,19 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
             title: An optional title for the text.
             Only applicable when TaskType is RETRIEVAL_DOCUMENT.
             output_dimensionality: Optional reduced dimension for the output embedding.
-            https://ai.google.dev/api/rest/v1/models/batchEmbedContents#EmbedContentRequest
 
         Returns:
             Embedding for the text.
         """
         task_type = self.task_type or "RETRIEVAL_QUERY"
-        return self.embed_documents(
-            [text],
-            task_type=task_type,
-            titles=[title] if title else None,
-            output_dimensionality=output_dimensionality,
-        )[0]
+        try:
+            request: EmbedContentRequest = self._prepare_request(
+                text=text,
+                task_type=task_type,
+                title=title,
+                output_dimensionality=output_dimensionality,
+            )
+            result: EmbedContentResponse = self.client.embed_content(request)
+        except Exception as e:
+            raise GoogleGenerativeAIError(f"Error embedding content: {e}") from e
+        return list(result.embedding.values)

{langchain_google_genai-2.1.1 → langchain_google_genai-2.1.3}/langchain_google_genai/llms.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import logging
+from difflib import get_close_matches
 from typing import Any, Iterator, List, Optional
 
 from langchain_core.callbacks import (
@@ -17,6 +19,8 @@ from langchain_google_genai._common import (
 )
 from langchain_google_genai.chat_models import ChatGoogleGenerativeAI
 
+logger = logging.getLogger(__name__)
+
 
 class GoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseLLM):
     """Google GenerativeAI models.
@@ -33,6 +37,28 @@ class GoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseLLM):
         populate_by_name=True,
     )
 
+    def __init__(self, **kwargs: Any) -> None:
+        """Needed for arg validation."""
+        # Get all valid field names, including aliases
+        valid_fields = set()
+        for field_name, field_info in self.model_fields.items():
+            valid_fields.add(field_name)
+            if hasattr(field_info, "alias") and field_info.alias is not None:
+                valid_fields.add(field_info.alias)
+
+        # Check for unrecognized arguments
+        for arg in kwargs:
+            if arg not in valid_fields:
+                suggestions = get_close_matches(arg, valid_fields, n=1)
+                suggestion = (
+                    f" Did you mean: '{suggestions[0]}'?" if suggestions else ""
+                )
+                logger.warning(
+                    f"Unexpected argument '{arg}' "
+                    f"provided to GoogleGenerativeAI.{suggestion}"
+                )
+        super().__init__(**kwargs)
+
     @model_validator(mode="after")
     def validate_environment(self) -> Self:
         """Validates params and passes them to google-generativeai package."""

{langchain_google_genai-2.1.1 → langchain_google_genai-2.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langchain-google-genai"
-version = "2.1.1"
+version = "2.1.3"
 description = "An integration package connecting Google's genai package and LangChain"
 authors = []
 readme = "README.md"
@@ -12,7 +12,7 @@ license = "MIT"
 
 [tool.poetry.dependencies]
 python = ">=3.9,<4.0"
-langchain-core = "^0.3.47"
+langchain-core = "^0.3.52"
 google-ai-generativelanguage = "^0.6.16"
 pydantic = ">=2,<3"
 filetype = "^1.2.0"
@@ -27,8 +27,8 @@ pytest-mock = "^3.10.0"
 syrupy = "^4.0.2"
 pytest-watcher = "^0.3.4"
 pytest-asyncio = "^0.21.1"
-numpy = "^1.26.2"
-langchain-tests = "0.3.15"
+numpy = ">=1.26.2"
+langchain-tests = "0.3.18"
 
 [tool.codespell]
 ignore-words-list = "rouge"
@@ -60,7 +60,7 @@ mypy = "^1.10"
 types-requests = "^2.28.11.5"
 types-google-cloud-ndb = "^2.2.0.1"
 types-protobuf = "^4.24.0.20240302"
-numpy = "^1.26.2"
+numpy = ">=1.26.2"
 
 
 [tool.poetry.group.dev]