langchain-google-genai 2.0.0.dev1__tar.gz → 2.0.2__tar.gz

{langchain_google_genai-2.0.0.dev1 → langchain_google_genai-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-google-genai
-Version: 2.0.0.dev1
+Version: 2.0.2
 Summary: An integration package connecting Google's genai package and LangChain
 Home-page: https://github.com/langchain-ai/langchain-google
 License: MIT
@@ -12,8 +12,8 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: images
-Requires-Dist: google-generativeai (>=0.7.0,<0.8.0)
-Requires-Dist: langchain-core (>=0.3.0.dev4,<0.4.0)
+Requires-Dist: google-generativeai (>=0.8.0,<0.9.0)
+Requires-Dist: langchain-core (>=0.3.13,<0.4)
 Requires-Dist: pillow (>=10.1.0,<11.0.0) ; extra == "images"
 Requires-Dist: pydantic (>=2,<3)
 Project-URL: Repository, https://github.com/langchain-ai/langchain-google

{langchain_google_genai-2.0.0.dev1 → langchain_google_genai-2.0.2}/langchain_google_genai/_function_utils.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import collections
+import importlib
 import json
 import logging
 from typing import (
@@ -42,9 +43,9 @@ TYPE_ENUM = {
     "boolean": glm.Type.BOOLEAN,
     "array": glm.Type.ARRAY,
     "object": glm.Type.OBJECT,
+    "null": None,
 }
 
-TYPE_ENUM_REVERSE = {v: k for k, v in TYPE_ENUM.items()}
 _ALLOWED_SCHEMA_FIELDS = []
 _ALLOWED_SCHEMA_FIELDS.extend([f.name for f in gapic.Schema()._pb.DESCRIPTOR.fields])
 _ALLOWED_SCHEMA_FIELDS.extend(
@@ -101,12 +102,7 @@ def _format_json_schema_to_gapic(schema: Dict[str, Any]) -> Dict[str, Any]:
         elif key == "items":
             converted_schema["items"] = _format_json_schema_to_gapic(value)
         elif key == "properties":
-            if "properties" not in converted_schema:
-                converted_schema["properties"] = {}
-            for pkey, pvalue in value.items():
-                converted_schema["properties"][pkey] = _format_json_schema_to_gapic(
-                    pvalue
-                )
+            converted_schema["properties"] = _get_properties_from_schema(value)
             continue
         elif key == "allOf":
             if len(value) > 1:
@@ -136,8 +132,9 @@ def _dict_to_gapic_schema(schema: Dict[str, Any]) -> Optional[gapic.Schema]:
 def _format_dict_to_function_declaration(
     tool: Union[FunctionDescription, Dict[str, Any]],
 ) -> gapic.FunctionDeclaration:
+    print(tool)
     return gapic.FunctionDeclaration(
-        name=tool.get("name"),
+        name=tool.get("name") or tool.get("title"),
         description=tool.get("description"),
         parameters=_dict_to_gapic_schema(tool.get("parameters", {})),
     )
@@ -157,13 +154,11 @@ def convert_to_genai_function_declarations(
     for tool in tools:
         if isinstance(tool, gapic.Tool):
             gapic_tool.function_declarations.extend(tool.function_declarations)
+        elif isinstance(tool, dict) and "function_declarations" not in tool:
+            fd = _format_to_gapic_function_declaration(tool)
+            gapic_tool.function_declarations.append(fd)
         elif isinstance(tool, dict):
-            if "function_declarations" not in tool:
-                fd = _format_to_gapic_function_declaration(tool)
-                gapic_tool.function_declarations.append(fd)
-                continue
-            tool = cast(_ToolDictLike, tool)
-            function_declarations = tool["function_declarations"]
+            function_declarations = cast(_ToolDictLike, tool)["function_declarations"]
             if not isinstance(function_declarations, collections.abc.Sequence):
                 raise ValueError(
                     "function_declarations should be a list"
@@ -199,18 +194,26 @@ def _format_to_gapic_function_declaration(
 ) -> gapic.FunctionDeclaration:
     if isinstance(tool, BaseTool):
         return _format_base_tool_to_function_declaration(tool)
-    elif isinstance(tool, type) and issubclass(tool, BaseModel):
+    elif isinstance(tool, type) and is_basemodel_subclass_safe(tool):
         return _convert_pydantic_to_genai_function(tool)
     elif isinstance(tool, dict):
-        if all(k in tool for k in ("name", "description")) and "parameters" not in tool:
+        if all(k in tool for k in ("type", "function")) and tool["type"] == "function":
+            function = tool["function"]
+        elif (
+            all(k in tool for k in ("name", "description")) and "parameters" not in tool
+        ):
             function = cast(dict, tool)
-            function["parameters"] = {}
         else:
-            if "parameters" in tool and tool["parameters"].get("properties"):  # type: ignore[index]
+            if (
+                "parameters" in tool and tool["parameters"].get("properties")  # type: ignore[index]
+            ):
                 function = convert_to_openai_tool(cast(dict, tool))["function"]
             else:
                 function = cast(dict, tool)
-                function["parameters"] = {}
+        function["parameters"] = function.get("parameters") or {}
+        # Empty 'properties' field not supported.
+        if not function["parameters"].get("properties"):
+            function["parameters"] = {}
         return _format_dict_to_function_declaration(cast(FunctionDescription, function))
     elif callable(tool):
         return _format_base_tool_to_function_declaration(callable_as_lc_tool()(tool))
@@ -269,13 +272,12 @@ def _convert_pydantic_to_genai_function(
         name=tool_name if tool_name else schema.get("title"),
         description=tool_description if tool_description else schema.get("description"),
         parameters={
-            "properties": {
-                k: {
-                    "type_": _get_type_from_schema(v),
-                    "description": v.get("description"),
-                }
-                for k, v in schema["properties"].items()
-            },
+            "properties": _get_properties_from_schema_any(
+                schema.get("properties")
+            ),  # TODO: use _dict_to_gapic_schema() if possible
+            # "items": _get_items_from_schema_any(
+            #     schema
+            # ),  # TODO: fix it https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/function-calling?hl#schema
             "required": schema.get("required", []),
             "type_": TYPE_ENUM[schema["type"]],
         },
@@ -283,23 +285,121 @@ def _convert_pydantic_to_genai_function(
     return function_declaration
 
 
+def _get_properties_from_schema_any(schema: Any) -> Dict[str, Any]:
+    if isinstance(schema, Dict):
+        return _get_properties_from_schema(schema)
+    return {}
+
+
+def _get_properties_from_schema(schema: Dict) -> Dict[str, Any]:
+    properties = {}
+    for k, v in schema.items():
+        if not isinstance(k, str):
+            logger.warning(f"Key '{k}' is not supported in schema, type={type(k)}")
+            continue
+        if not isinstance(v, Dict):
+            logger.warning(f"Value '{v}' is not supported in schema, ignoring v={v}")
+            continue
+        properties_item: Dict[str, Union[str, int, Dict, List]] = {}
+        if v.get("type") or v.get("anyOf") or v.get("type_"):
+            properties_item["type_"] = _get_type_from_schema(v)
+            if _is_nullable_schema(v):
+                properties_item["nullable"] = True
+
+        if v.get("enum"):
+            properties_item["enum"] = v["enum"]
+
+        description = v.get("description")
+        if description and isinstance(description, str):
+            properties_item["description"] = description
+
+        if properties_item.get("type_") == glm.Type.ARRAY and v.get("items"):
+            properties_item["items"] = _get_items_from_schema_any(v.get("items"))
+
+        if properties_item.get("type_") == glm.Type.OBJECT and v.get("properties"):
+            properties_item["properties"] = _get_properties_from_schema_any(
+                v.get("properties")
+            )
+        if k == "title" and "description" not in properties_item:
+            properties_item["description"] = k + " is " + str(v)
+
+        properties[k] = properties_item
+
+    return properties
+
+
+def _get_items_from_schema_any(schema: Any) -> Dict[str, Any]:
+    if isinstance(schema, (dict, list, str)):
+        return _get_items_from_schema(schema)
+    return {}
+
+
+def _get_items_from_schema(schema: Union[Dict, List, str]) -> Dict[str, Any]:
+    items: Dict = {}
+    if isinstance(schema, List):
+        for i, v in enumerate(schema):
+            items[f"item{i}"] = _get_properties_from_schema_any(v)
+    elif isinstance(schema, Dict):
+        items["type_"] = _get_type_from_schema(schema)
+        if items["type_"] == glm.Type.OBJECT and "properties" in schema:
+            items["properties"] = _get_properties_from_schema_any(schema["properties"])
+        if "title" in schema:
+            items["title"] = schema
+        if "title" in schema or "description" in schema:
+            items["description"] = (
+                schema.get("description") or schema.get("title") or ""
+            )
+        if _is_nullable_schema(schema):
+            items["nullable"] = True
+    else:
+        # str
+        items["type_"] = _get_type_from_schema({"type": schema})
+        if _is_nullable_schema({"type": schema}):
+            items["nullable"] = True
+
+    return items
+
+
 def _get_type_from_schema(schema: Dict[str, Any]) -> int:
+    return _get_nullable_type_from_schema(schema) or glm.Type.STRING
+
+
+def _get_nullable_type_from_schema(schema: Dict[str, Any]) -> Optional[int]:
     if "anyOf" in schema:
-        types = [_get_type_from_schema(sub_schema) for sub_schema in schema["anyOf"]]
+        types = [
+            _get_nullable_type_from_schema(sub_schema) for sub_schema in schema["anyOf"]
+        ]
         types = [t for t in types if t is not None]  # Remove None values
         if types:
             return types[-1]  # TODO: update FunctionDeclaration and pass all types?
         else:
             pass
-    elif "type" in schema:
-        stype = str(schema["type"])
-        if stype in TYPE_ENUM:
-            return TYPE_ENUM[stype]
-        else:
-            pass
+    elif "type" in schema or "type_" in schema:
+        type_ = schema["type"] if "type" in schema else schema["type_"]
+        if isinstance(type_, int):
+            return type_
+        stype = str(schema["type"]) if "type" in schema else str(schema["type_"])
+        return TYPE_ENUM.get(stype, glm.Type.STRING)
     else:
         pass
-    return TYPE_ENUM["string"]  # Default to string if no valid types found
+    return glm.Type.STRING  # Default to string if no valid types found
+
+
+def _is_nullable_schema(schema: Dict[str, Any]) -> bool:
+    if "anyOf" in schema:
+        types = [
+            _get_nullable_type_from_schema(sub_schema) for sub_schema in schema["anyOf"]
+        ]
+        return any(t is None for t in types)
+    elif "type" in schema or "type_" in schema:
+        type_ = schema["type"] if "type" in schema else schema["type_"]
+        if isinstance(type_, int):
+            return False
+        stype = str(schema["type"]) if "type" in schema else str(schema["type_"])
+        return TYPE_ENUM.get(stype, glm.Type.STRING) is None
+    else:
+        pass
+    return False
 
 
 _ToolChoiceType = Union[
@@ -356,3 +456,24 @@ def _tool_choice_to_tool_config(
             "allowed_function_names": allowed_function_names,
         }
     )
+
+
+def is_basemodel_subclass_safe(tool: Type) -> bool:
+    if safe_import("langchain_core.utils.pydantic", "is_basemodel_subclass"):
+        from langchain_core.utils.pydantic import (
+            is_basemodel_subclass,  # type: ignore[import]
+        )
+
+        return is_basemodel_subclass(tool)
+    else:
+        return issubclass(tool, BaseModel)
+
+
+def safe_import(module_name: str, attribute_name: str = "") -> bool:
+    try:
+        module = importlib.import_module(module_name)
+        if attribute_name:
+            return hasattr(module, attribute_name)
+        return True
+    except ImportError:
+        return False

{langchain_google_genai-2.0.0.dev1 → langchain_google_genai-2.0.2}/langchain_google_genai/_genai_extension.py

@@ -238,7 +238,7 @@ def _prepare_config(
     client_info: Optional[gapic_v1.client_info.ClientInfo] = None,
     transport: Optional[str] = None,
 ) -> Dict[str, Any]:
-    formatted_client_options = {"api_endpoint": _config.api_endpoint}
+    formatted_client_options: dict = {"api_endpoint": _config.api_endpoint}
     if client_options:
         formatted_client_options.update(**client_options)
     if not credentials and api_key:

{langchain_google_genai-2.0.0.dev1 → langchain_google_genai-2.0.2}/langchain_google_genai/chat_models.py

@@ -31,6 +31,9 @@ import google.api_core
 # TODO: remove ignore once the google package is published with types
 import proto  # type: ignore[import]
 import requests
+from google.ai.generativelanguage_v1beta import (
+    GenerativeServiceAsyncClient as v1betaGenerativeServiceAsyncClient,
+)
 from google.ai.generativelanguage_v1beta.types import (
     Blob,
     Candidate,
@@ -46,7 +49,9 @@ from google.ai.generativelanguage_v1beta.types import (
     ToolConfig,
     VideoMetadata,
 )
+from google.generativeai.caching import CachedContent  # type: ignore[import]
 from google.generativeai.types import Tool as GoogleTool  # type: ignore[import]
+from google.generativeai.types import caching_types, content_types
 from google.generativeai.types.content_types import (  # type: ignore[import]
     FunctionDeclarationType,
     ToolDict,
@@ -77,7 +82,7 @@ from langchain_core.output_parsers.openai_tools import (
 from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult
 from langchain_core.runnables import Runnable, RunnablePassthrough
 from langchain_core.utils import secret_from_env
-from langchain_core.utils.pydantic import is_basemodel_subclass
+from langchain_core.utils.function_calling import convert_to_openai_tool
 from pydantic import (
     BaseModel,
     ConfigDict,
@@ -104,6 +109,7 @@ from langchain_google_genai._function_utils import (
     _ToolChoiceType,
     _ToolConfigDict,
     convert_to_genai_function_declarations,
+    is_basemodel_subclass_safe,
     tool_to_dict,
 )
 from langchain_google_genai._image_utils import ImageBytesLoader
@@ -563,20 +569,29 @@ def _parse_response_candidate(
 def _response_to_result(
     response: GenerateContentResponse,
     stream: bool = False,
+    prev_usage: Optional[UsageMetadata] = None,
 ) -> ChatResult:
     """Converts a PaLM API response into a LangChain ChatResult."""
     llm_output = {"prompt_feedback": proto.Message.to_dict(response.prompt_feedback)}
 
+    # previous usage metadata needs to be subtracted because gemini api returns
+    # already-accumulated token counts with each chunk
+    prev_input_tokens = prev_usage["input_tokens"] if prev_usage else 0
+    prev_output_tokens = prev_usage["output_tokens"] if prev_usage else 0
+    prev_total_tokens = prev_usage["total_tokens"] if prev_usage else 0
+
     # Get usage metadata
     try:
         input_tokens = response.usage_metadata.prompt_token_count
         output_tokens = response.usage_metadata.candidates_token_count
         total_tokens = response.usage_metadata.total_token_count
-        if input_tokens + output_tokens + total_tokens > 0:
+        cache_read_tokens = response.usage_metadata.cached_content_token_count
+        if input_tokens + output_tokens + cache_read_tokens + total_tokens > 0:
             lc_usage = UsageMetadata(
-                input_tokens=input_tokens,
-                output_tokens=output_tokens,
-                total_tokens=total_tokens,
+                input_tokens=input_tokens - prev_input_tokens,
+                output_tokens=output_tokens - prev_output_tokens,
+                total_tokens=total_tokens - prev_total_tokens,
+                input_token_details={"cache_read": cache_read_tokens},
             )
         else:
             lc_usage = None
@@ -595,12 +610,17 @@ def _response_to_result(
         ]
         message = _parse_response_candidate(candidate, streaming=stream)
         message.usage_metadata = lc_usage
-        generations.append(
-            (ChatGenerationChunk if stream else ChatGeneration)(
-                message=message,
-                generation_info=generation_info,
+        if stream:
+            generations.append(
+                ChatGenerationChunk(
+                    message=cast(AIMessageChunk, message),
+                    generation_info=generation_info,
+                )
+            )
+        else:
+            generations.append(
+                ChatGeneration(message=message, generation_info=generation_info)
             )
-        )
     if not response.candidates:
         # Likely a "prompt feedback" violation (e.g., toxic input)
         # Raising an error would be different than how OpenAI handles it,
@@ -609,12 +629,14 @@ def _response_to_result(
             "Gemini produced an empty response. Continuing with empty message\n"
             f"Feedback: {response.prompt_feedback}"
         )
-        generations = [
-            (ChatGenerationChunk if stream else ChatGeneration)(
-                message=(AIMessageChunk if stream else AIMessage)(content=""),
-                generation_info={},
-            )
-        ]
+        if stream:
+            generations = [
+                ChatGenerationChunk(
+                    message=AIMessageChunk(content=""), generation_info={}
+                )
+            ]
+        else:
+            generations = [ChatGeneration(message=AIMessage(""), generation_info={})]
     return ChatResult(generations=generations, llm_output=llm_output)
 
 
@@ -703,7 +725,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
     Tool calling:
         .. code-block:: python
 
-            from langchain_core.pydantic_v1 import BaseModel, Field
+            from pydantic import BaseModel, Field
 
 
             class GetWeather(BaseModel):
@@ -748,7 +770,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
             from typing import Optional
 
-            from langchain_core.pydantic_v1 import BaseModel, Field
+            from pydantic import BaseModel, Field
 
 
             class Joke(BaseModel):
@@ -806,7 +828,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             {'input_tokens': 18, 'output_tokens': 5, 'total_tokens': 23}
 
 
-        Response metadata
+    Response metadata
         .. code-block:: python
 
             ai_msg = llm.invoke(messages)
@@ -823,11 +845,11 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
     """  # noqa: E501
 
     client: Any = Field(default=None, exclude=True)  #: :meta private:
-    async_client: Any = Field(default=None, exclude=True)  #: :meta private:
+    async_client_running: Any = Field(default=None, exclude=True)  #: :meta private:
     google_api_key: Optional[SecretStr] = Field(
         alias="api_key", default_factory=secret_from_env("GOOGLE_API_KEY", default=None)
     )
-    """Google AI API key.         
+    """Google AI API key.
     If not specified will be read from env var ``GOOGLE_API_KEY``."""
     default_metadata: Sequence[Tuple[str, str]] = Field(
         default_factory=list
@@ -839,6 +861,14 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
     Gemini does not support system messages; any unsupported messages will
     raise an error."""
 
+    cached_content: Optional[str] = None
+    """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: 
+    ``cachedContents/{cachedContent}``.
+    """
+
     model_config = ConfigDict(
         populate_by_name=True,
     )
@@ -887,24 +917,31 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             client_options=self.client_options,
             transport=transport,
         )
+        self.async_client_running = None
+        return self
 
+    @property
+    def async_client(self) -> v1betaGenerativeServiceAsyncClient:
+        google_api_key = None
+        if not self.credentials:
+            if isinstance(self.google_api_key, SecretStr):
+                google_api_key = self.google_api_key.get_secret_value()
+            else:
+                google_api_key = self.google_api_key
         # NOTE: genaix.build_generative_async_service requires
         # a running event loop, which causes an error
         # when initialized inside a ThreadPoolExecutor.
         # this check ensures that async client is only initialized
         # within an asyncio event loop to avoid the error
-        if _is_event_loop_running():
-            self.async_client = genaix.build_generative_async_service(
+        if not self.async_client_running and _is_event_loop_running():
+            self.async_client_running = genaix.build_generative_async_service(
                 credentials=self.credentials,
                 api_key=google_api_key,
-                client_info=client_info,
+                client_info=get_client_info("ChatGoogleGenerativeAI"),
                 client_options=self.client_options,
-                transport=transport,
+                transport=self.transport,
             )
-        else:
-            self.async_client = None
-
-        return self
+        return self.async_client_running
 
     @property
     def _identifying_params(self) -> Dict[str, Any]:
@@ -966,6 +1003,8 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         safety_settings: Optional[SafetySettingDict] = None,
         tool_config: Optional[Union[Dict, _ToolConfigDict]] = None,
         generation_config: Optional[Dict[str, Any]] = None,
+        cached_content: Optional[str] = None,
+        tool_choice: Optional[Union[_ToolChoiceType, bool]] = None,
         **kwargs: Any,
     ) -> ChatResult:
         request = self._prepare_request(
@@ -976,6 +1015,8 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             safety_settings=safety_settings,
             tool_config=tool_config,
             generation_config=generation_config,
+            cached_content=cached_content or self.cached_content,
+            tool_choice=tool_choice,
         )
         response: GenerateContentResponse = _chat_with_retry(
             request=request,
@@ -996,6 +1037,8 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         safety_settings: Optional[SafetySettingDict] = None,
         tool_config: Optional[Union[Dict, _ToolConfigDict]] = None,
         generation_config: Optional[Dict[str, Any]] = None,
+        cached_content: Optional[str] = None,
+        tool_choice: Optional[Union[_ToolChoiceType, bool]] = None,
         **kwargs: Any,
     ) -> ChatResult:
         if not self.async_client:
@@ -1021,6 +1064,8 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             safety_settings=safety_settings,
             tool_config=tool_config,
             generation_config=generation_config,
+            cached_content=cached_content or self.cached_content,
+            tool_choice=tool_choice,
         )
         response: GenerateContentResponse = await _achat_with_retry(
             request=request,
@@ -1041,6 +1086,8 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         safety_settings: Optional[SafetySettingDict] = None,
         tool_config: Optional[Union[Dict, _ToolConfigDict]] = None,
         generation_config: Optional[Dict[str, Any]] = None,
+        cached_content: Optional[str] = None,
+        tool_choice: Optional[Union[_ToolChoiceType, bool]] = None,
         **kwargs: Any,
     ) -> Iterator[ChatGenerationChunk]:
         request = self._prepare_request(
@@ -1051,6 +1098,8 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             safety_settings=safety_settings,
             tool_config=tool_config,
             generation_config=generation_config,
+            cached_content=cached_content or self.cached_content,
+            tool_choice=tool_choice,
         )
         response: GenerateContentResponse = _chat_with_retry(
             request=request,
@@ -1058,9 +1107,31 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             **kwargs,
             metadata=self.default_metadata,
         )
+
+        prev_usage_metadata: UsageMetadata | None = None
         for chunk in response:
-            _chat_result = _response_to_result(chunk, stream=True)
+            _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)
+
+            curr_usage_metadata: UsageMetadata | dict[str, int] = (
+                message.usage_metadata or {}
+            )
+
+            prev_usage_metadata = (
+                message.usage_metadata
+                if prev_usage_metadata is None
+                else UsageMetadata(
+                    input_tokens=prev_usage_metadata.get("input_tokens", 0)
+                    + curr_usage_metadata.get("input_tokens", 0),
+                    output_tokens=prev_usage_metadata.get("output_tokens", 0)
+                    + curr_usage_metadata.get("output_tokens", 0),
+                    total_tokens=prev_usage_metadata.get("total_tokens", 0)
+                    + curr_usage_metadata.get("total_tokens", 0),
+                )
+            )
 
             if run_manager:
                 run_manager.on_llm_new_token(gen.text)
@@ -1077,6 +1148,8 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         safety_settings: Optional[SafetySettingDict] = None,
         tool_config: Optional[Union[Dict, _ToolConfigDict]] = None,
         generation_config: Optional[Dict[str, Any]] = None,
+        cached_content: Optional[str] = None,
+        tool_choice: Optional[Union[_ToolChoiceType, bool]] = None,
         **kwargs: Any,
     ) -> AsyncIterator[ChatGenerationChunk]:
         if not self.async_client:
@@ -1103,15 +1176,38 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                 safety_settings=safety_settings,
                 tool_config=tool_config,
                 generation_config=generation_config,
+                cached_content=cached_content or self.cached_content,
+                tool_choice=tool_choice,
             )
+            prev_usage_metadata: UsageMetadata | None = None
             async for chunk in await _achat_with_retry(
                 request=request,
                 generation_method=self.async_client.stream_generate_content,
                 **kwargs,
                 metadata=self.default_metadata,
             ):
-                _chat_result = _response_to_result(chunk, stream=True)
+                _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)
+
+                curr_usage_metadata: UsageMetadata | dict[str, int] = (
+                    message.usage_metadata or {}
+                )
+
+                prev_usage_metadata = (
+                    message.usage_metadata
+                    if prev_usage_metadata is None
+                    else UsageMetadata(
+                        input_tokens=prev_usage_metadata.get("input_tokens", 0)
+                        + curr_usage_metadata.get("input_tokens", 0),
+                        output_tokens=prev_usage_metadata.get("output_tokens", 0)
+                        + curr_usage_metadata.get("output_tokens", 0),
+                        total_tokens=prev_usage_metadata.get("total_tokens", 0)
+                        + curr_usage_metadata.get("total_tokens", 0),
+                    )
+                )
 
                 if run_manager:
                     await run_manager.on_llm_new_token(gen.text)
@@ -1126,8 +1222,15 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         functions: Optional[Sequence[FunctionDeclarationType]] = None,
         safety_settings: Optional[SafetySettingDict] = None,
         tool_config: Optional[Union[Dict, _ToolConfigDict]] = None,
+        tool_choice: Optional[Union[_ToolChoiceType, bool]] = None,
         generation_config: Optional[Dict[str, Any]] = None,
+        cached_content: Optional[str] = None,
     ) -> Tuple[GenerateContentRequest, Dict[str, Any]]:
+        if tool_choice and tool_config:
+            raise ValueError(
+                "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:
             formatted_tools = [convert_to_genai_function_declarations(tools)]
@@ -1138,6 +1241,18 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             messages,
             convert_system_message_to_human=self.convert_system_message_to_human,
         )
+        if tool_choice:
+            if not formatted_tools:
+                msg = (
+                    f"Received {tool_choice=} but no {tools=}. 'tool_choice' can only "
+                    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
+            ]
+            tool_config = _tool_choice_to_tool_config(tool_choice, all_names)
+
         formatted_tool_config = None
         if tool_config:
             formatted_tool_config = ToolConfig(
@@ -1158,6 +1273,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             generation_config=self._prepare_params(
                 stop, generation_config=generation_config
             ),
+            cached_content=cached_content,
         )
         if system_instruction:
             request.system_instruction = system_instruction
@@ -1189,7 +1305,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
     ) -> Runnable[LanguageModelInput, Union[Dict, BaseModel]]:
         if kwargs:
             raise ValueError(f"Received unsupported arguments {kwargs}")
-        if isinstance(schema, type) and is_basemodel_subclass(schema):
+        if isinstance(schema, type) and is_basemodel_subclass_safe(schema):
             parser: OutputParserLike = PydanticToolsParser(
                 tools=[schema], first_tool_only=True
             )
@@ -1233,20 +1349,107 @@ 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=}"
             )
-        # Bind dicts for easier serialization/deserialization.
-        genai_tools = [tool_to_dict(convert_to_genai_function_declarations(tools))]
-        if tool_choice:
-            all_names = [
-                f["name"]  # type: ignore[index]
-                for t in genai_tools
-                for f in t["function_declarations"]
+        try:
+            formatted_tools: list = [convert_to_openai_tool(tool) for tool in tools]  # type: ignore[arg-type]
+        except Exception:
+            formatted_tools = [
+                tool_to_dict(convert_to_genai_function_declarations(tools))
             ]
+        if tool_choice:
+            kwargs["tool_choice"] = tool_choice
+        elif tool_config:
+            kwargs["tool_config"] = tool_config
+        else:
+            pass
+        return self.bind(tools=formatted_tools, **kwargs)
+
+    def create_cached_content(
+        self,
+        contents: Union[List[BaseMessage], content_types.ContentsType],
+        *,
+        display_name: str | None = None,
+        tools: Union[ToolDict, GoogleTool, None] = None,
+        tool_choice: Optional[Union[_ToolChoiceType, bool]] = None,
+        ttl: Optional[caching_types.TTLTypes] = None,
+        expire_time: Optional[caching_types.ExpireTimeTypes] = None,
+    ) -> str:
+        """
+
+        Args:
+            display_name: The user-generated meaningful display name
+                of the cached content. `display_name` must be no
+                more than 128 unicode characters.
+            contents: Contents to cache.
+            tools: A list of `Tools` the model may use to generate response.
+            tool_choice: Which tool to require the model to call.
+            ttl: TTL for cached resource (in seconds). Defaults to 1 hour.
+                 `ttl` and `expire_time` are exclusive arguments.
+            expire_time: Expiration time for cached resource.
+                `ttl` and `expire_time` are exclusive arguments.
+        """
+        system: Optional[content_types.ContentType] = None
+        genai_contents: list = []
+        if all(isinstance(c, BaseMessage) for c in contents):
+            system, genai_contents = _parse_chat_history(
+                contents,
+                convert_system_message_to_human=self.convert_system_message_to_human,
+            )
+        elif any(isinstance(c, BaseMessage) for c in contents):
+            raise ValueError(
+                f"'contents' must either be a list of "
+                f"langchain_core.messages.BaseMessage or a list "
+                f"google.generativeai.types.content_types.ContentType, but not a mix "
+                f"of the two. Received {contents}"
+            )
+        else:
+            for content in contents:
+                if hasattr(content, "role") and content.role == "system":
+                    if system is not None:
+                        warnings.warn(
+                            "Received multiple pieces of content with role 'system'. "
+                            "Should only be one set of system instructions. Ignoring "
+                            "all but the first 'system' content."
+                        )
+                    else:
+                        system = content
+                elif isinstance(content, dict) and content.get("role") == "system":
+                    if system is not None:
+                        warnings.warn(
+                            "Received multiple pieces of content with role 'system'. "
+                            "Should only be one set of system instructions. Ignoring "
+                            "all but the first 'system' content."
+                        )
+                    else:
+                        system = content
+                else:
+                    genai_contents.append(content)
+        if tools:
+            genai_tools = [convert_to_genai_function_declarations(tools)]
+        else:
+            genai_tools = None
+        if tool_choice and genai_tools:
+            all_names = [f.name for t in genai_tools for f in t.function_declarations]
             tool_config = _tool_choice_to_tool_config(tool_choice, all_names)
-        return self.bind(tools=genai_tools, tool_config=tool_config, **kwargs)
+            genai_tool_config = ToolConfig(
+                function_calling_config=tool_config["function_calling_config"]
+            )
+        else:
+            genai_tool_config = None
+        cached_content = CachedContent.create(
+            model=self.model,
+            system_instruction=system,
+            contents=genai_contents,
+            display_name=display_name,
+            tools=genai_tools,
+            tool_config=genai_tool_config,
+            ttl=ttl,
+            expire_time=expire_time,
+        )
+        return cached_content.name
 
     @property
     def _supports_tool_choice(self) -> bool:
-        return "gemini-1.5-pro" in self.model
+        return "gemini-1.5-pro" in self.model or "gemini-1.5-flash" in self.model
 
 
 def _get_tool_name(

{langchain_google_genai-2.0.0.dev1 → langchain_google_genai-2.0.2}/langchain_google_genai/genai_aqa.py

@@ -117,7 +117,7 @@ class GenAIAqa(RunnableSerializable[AqaInput, AqaOutput]):
         self._client = _AqaModel(**kwargs)
 
     def invoke(
-        self, input: AqaInput, config: Optional[RunnableConfig] = None
+        self, input: AqaInput, config: Optional[RunnableConfig] = None, **kwargs: Any
     ) -> AqaOutput:
         """Generates a grounded response using the provided passages."""
 

{langchain_google_genai-2.0.0.dev1 → langchain_google_genai-2.0.2}/langchain_google_genai/llms.py

@@ -13,7 +13,7 @@ from langchain_core.language_models import LangSmithParams, LanguageModelInput
 from langchain_core.language_models.llms import BaseLLM, create_base_retry_decorator
 from langchain_core.outputs import Generation, GenerationChunk, LLMResult
 from langchain_core.utils import secret_from_env
-from pydantic import BaseModel, Field, SecretStr, model_validator
+from pydantic import BaseModel, ConfigDict, Field, SecretStr, model_validator
 from typing_extensions import Self
 
 from langchain_google_genai._enums import (
@@ -139,7 +139,7 @@ Supported examples:
     top_k: Optional[int] = None
     """Decode using top-k sampling: consider the set of top_k most probable tokens.
        Must be positive."""
-    max_output_tokens: Optional[int] = None
+    max_output_tokens: Optional[int] = Field(default=None, alias="max_tokens")
     """Maximum number of tokens to include in a candidate. Must be greater than zero.
        If unset, will default to 64."""
     n: int = 1
@@ -216,6 +216,9 @@ class GoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseLLM):
     """
 
     client: Any = None  #: :meta private:
+    model_config = ConfigDict(
+        populate_by_name=True,
+    )
 
     @model_validator(mode="after")
     def validate_environment(self) -> Self:

{langchain_google_genai-2.0.0.dev1 → langchain_google_genai-2.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langchain-google-genai"
-version = "2.0.0.dev1"
+version = "2.0.2"
 description = "An integration package connecting Google's genai package and LangChain"
 authors = []
 readme = "README.md"
@@ -12,8 +12,8 @@ license = "MIT"
 
 [tool.poetry.dependencies]
 python = ">=3.9,<4.0"
-langchain-core = { version = "^0.3.0.dev4", allow-prereleases = true }
-google-generativeai = "^0.7.0"
+langchain-core = ">=0.3.13,<0.4"
+google-generativeai = "^0.8.0"
 pillow = { version = "^10.1.0", optional = true }
 pydantic = ">=2,<3"
 
@@ -31,8 +31,8 @@ syrupy = "^4.0.2"
 pytest-watcher = "^0.3.4"
 pytest-asyncio = "^0.21.1"
 numpy = "^1.26.2"
-langchain-core = { git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/core", branch = "v0.3rc" }
-langchain-standard-tests = { git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/standard-tests", branch = "v0.3rc" }
+langchain-core = { git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/core" }
+langchain-standard-tests = { git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/standard-tests" }
 
 [tool.codespell]
 ignore-words-list = "rouge"
@@ -62,7 +62,7 @@ types-requests = "^2.28.11.5"
 types-google-cloud-ndb = "^2.2.0.1"
 types-pillow = "^10.1.0.2"
 types-protobuf = "^4.24.0.20240302"
-langchain-core = { git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/core", branch = "v0.3rc" }
+langchain-core = { git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/core" }
 numpy = "^1.26.2"
 
 [tool.poetry.group.dev]
@@ -73,7 +73,7 @@ pillow = "^10.1.0"
 types-requests = "^2.31.0.10"
 types-pillow = "^10.1.0.2"
 types-google-cloud-ndb = "^2.2.0.1"
-langchain-core = { git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/core", branch = "v0.3rc" }
+langchain-core = { git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/core" }
 
 [tool.ruff.lint]
 select = [