langchain-google-genai 2.0.1__py3-none-any.whl → 2.0.3__py3-none-any.whl

langchain_google_genai/_function_utils.py

@@ -43,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(
@@ -102,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:
@@ -137,7 +132,6 @@ 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") or tool.get("title"),
         description=tool.get("description"),
@@ -159,13 +153,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"
@@ -204,9 +196,12 @@ def _format_to_gapic_function_declaration(
     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]
@@ -214,7 +209,10 @@ def _format_to_gapic_function_declaration(
                 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))
@@ -302,8 +300,10 @@ def _get_properties_from_schema(schema: Dict) -> Dict[str, Any]:
             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"):
+        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"]
@@ -312,10 +312,10 @@ def _get_properties_from_schema(schema: Dict) -> Dict[str, Any]:
         if description and isinstance(description, str):
             properties_item["description"] = description
 
-        if v.get("type") == "array" and v.get("items"):
+        if properties_item.get("type_") == glm.Type.ARRAY and v.get("items"):
             properties_item["items"] = _get_items_from_schema_any(v.get("items"))
 
-        if v.get("type") == "object" and v.get("properties"):
+        if properties_item.get("type_") == glm.Type.OBJECT and v.get("properties"):
             properties_item["properties"] = _get_properties_from_schema_any(
                 v.get("properties")
             )
@@ -328,11 +328,7 @@ def _get_properties_from_schema(schema: Dict) -> Dict[str, Any]:
 
 
 def _get_items_from_schema_any(schema: Any) -> Dict[str, Any]:
-    if isinstance(schema, Dict):
-        return _get_items_from_schema(schema)
-    if isinstance(schema, List):
-        return _get_items_from_schema(schema)
-    if isinstance(schema, str):
+    if isinstance(schema, (dict, list, str)):
         return _get_items_from_schema(schema)
     return {}
 
@@ -343,41 +339,66 @@ def _get_items_from_schema(schema: Union[Dict, List, str]) -> Dict[str, Any]:
         for i, v in enumerate(schema):
             items[f"item{i}"] = _get_properties_from_schema_any(v)
     elif isinstance(schema, Dict):
-        item: Dict = {}
-        for k, v in schema.items():
-            item["type_"] = _get_type_from_schema(v)
-            if not isinstance(v, Dict):
-                logger.warning(
-                    f"Value '{v}' is not supported in schema, ignoring v={v}"
-                )
-                continue
-            if v.get("type") == "object" and v.get("properties"):
-                item["properties"] = _get_properties_from_schema_any(
-                    v.get("properties")
-                )
-            if k == "title" and "description" not in item:
-                item["description"] = v
-        items = item
+        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_"] = TYPE_ENUM.get(str(schema), glm.Type.STRING)
+        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"])
+    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[

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/chat_models.py

@@ -49,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,
@@ -80,6 +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.function_calling import convert_to_openai_tool
 from pydantic import (
     BaseModel,
     ConfigDict,
@@ -566,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
@@ -598,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,
@@ -612,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)
 
 
@@ -809,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)
@@ -842,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,
     )
@@ -976,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(
@@ -986,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,
@@ -1006,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:
@@ -1031,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,
@@ -1051,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(
@@ -1061,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,
@@ -1068,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)
@@ -1087,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:
@@ -1113,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)
@@ -1136,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)]
@@ -1148,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(
@@ -1168,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
@@ -1243,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/genai_aqa.py

@@ -116,8 +116,8 @@ class GenAIAqa(RunnableSerializable[AqaInput, AqaOutput]):
         super().__init__(**kwargs)
         self._client = _AqaModel(**kwargs)
 
-    def invoke(  # type: ignore[override]
-        self, input: AqaInput, config: Optional[RunnableConfig] = None
+    def invoke(
+        self, input: AqaInput, config: Optional[RunnableConfig] = None, **kwargs: Any
     ) -> AqaOutput:
         """Generates a grounded response using the provided passages."""
 

{langchain_google_genai-2.0.1.dist-info → langchain_google_genai-2.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-google-genai
-Version: 2.0.1
+Version: 2.0.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
 Provides-Extra: images
 Requires-Dist: google-generativeai (>=0.8.0,<0.9.0)
-Requires-Dist: langchain-core (>=0.3.0,<0.4)
+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.1.dist-info → langchain_google_genai-2.0.3.dist-info}/RECORD

@@ -1,16 +1,16 @@
 langchain_google_genai/__init__.py,sha256=Oji-S2KYWrku1wyQEskY84IOfY8MfRhujjJ4d7hbsk4,2758
 langchain_google_genai/_common.py,sha256=ASlwE8hEbvOm55BVF_D4rf2nl7RYsnpsi5xbM6DW3Cc,1576
 langchain_google_genai/_enums.py,sha256=KLPmxS1K83K4HjBIXFaXoL_sFEOv8Hq-2B2PDMKyDgo,197
-langchain_google_genai/_function_utils.py,sha256=vdfRi38-fwly5UANvtyxxBHLhx4EruaMhySvuHggm8M,15903
-langchain_google_genai/_genai_extension.py,sha256=ZwNwLV22RSf9LB7FOCLsoHzLlQDF-EQmRNYM1an2uSw,20769
+langchain_google_genai/_function_utils.py,sha256=ksKgLoKPhKzd3QLLgYojuq4tOegoEL-oHPncARPds3w,16891
+langchain_google_genai/_genai_extension.py,sha256=81a4ly5ZHlqMf37uJfdB8K41qE6J5ujLnbUypIfFf2o,20775
 langchain_google_genai/_image_utils.py,sha256=-0XgCMdYkvrIktFvUpy-2GPbFgfSVKZICawB2hiJzus,4999
-langchain_google_genai/chat_models.py,sha256=kvJSZTZmTd0UlrlQFyXrDU5xHSHsrLPfITImQLVICAw,47553
+langchain_google_genai/chat_models.py,sha256=pObFpTYKh-of52BrAbpVv1UIDp_qZ8XRTDRhPYgNZ2M,56506
 langchain_google_genai/embeddings.py,sha256=PBJlcRExfegD2V9hnKQHW99fJJGsbPbmMW1TfQtPmqU,10132
-langchain_google_genai/genai_aqa.py,sha256=XQq0ggIteok3WlG0q7tDqnTQFiW_WjUsxuYgkN7U2-g,4311
+langchain_google_genai/genai_aqa.py,sha256=qB6h3-BSXqe0YLR3eeVllYzmNKK6ofI6xJLdBahUVZo,4300
 langchain_google_genai/google_vector_store.py,sha256=4wvhIiOmc3Fo046FyafPmT9NBCLek-9bgluvuTfrbpQ,16148
 langchain_google_genai/llms.py,sha256=lXh0Se-kbBJlHrw0kR1DRsZw_bet1thKZ2HskvT8itU,14221
 langchain_google_genai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langchain_google_genai-2.0.1.dist-info/LICENSE,sha256=DppmdYJVSc1jd0aio6ptnMUn5tIHrdAhQ12SclEBfBg,1072
-langchain_google_genai-2.0.1.dist-info/METADATA,sha256=6Fv6pU7VtOP00J6c1s2E8rqvrWFlltV017lXHGOW8Dg,3850
-langchain_google_genai-2.0.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-langchain_google_genai-2.0.1.dist-info/RECORD,,
+langchain_google_genai-2.0.3.dist-info/LICENSE,sha256=DppmdYJVSc1jd0aio6ptnMUn5tIHrdAhQ12SclEBfBg,1072
+langchain_google_genai-2.0.3.dist-info/METADATA,sha256=OvxxVXvYGo3Qa7L8y1o06VX8JCR31WQSjOmpclTEhKA,3851
+langchain_google_genai-2.0.3.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+langchain_google_genai-2.0.3.dist-info/RECORD,,