langchain-google-genai 1.0.5__tar.gz → 1.0.7__tar.gz

{langchain_google_genai-1.0.5 → langchain_google_genai-1.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-google-genai
-Version: 1.0.5
+Version: 1.0.7
 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.5.2,<0.6.0)
-Requires-Dist: langchain-core (>=0.2.0,<0.3)
+Requires-Dist: google-generativeai (>=0.7.0,<0.8.0)
+Requires-Dist: langchain-core (>=0.2.9,<0.3)
 Requires-Dist: pillow (>=10.1.0,<11.0.0) ; extra == "images"
 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

langchain_google_genai-1.0.7/langchain_google_genai/_function_utils.py

@@ -0,0 +1,340 @@
+from __future__ import annotations
+
+from typing import (
+    Any,
+    Callable,
+    Collection,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Sequence,
+    Type,
+    TypedDict,
+    Union,
+    cast,
+)
+
+import google.ai.generativelanguage as glm
+from google.ai.generativelanguage import FunctionCallingConfig, FunctionDeclaration
+from google.ai.generativelanguage import Tool as GoogleTool
+from google.generativeai.types.content_types import ToolDict  # type: ignore[import]
+from langchain_core.pydantic_v1 import BaseModel
+from langchain_core.tools import BaseTool
+from langchain_core.tools import tool as callable_as_lc_tool
+from langchain_core.utils.json_schema import dereference_refs
+
+TYPE_ENUM = {
+    "string": glm.Type.STRING,
+    "number": glm.Type.NUMBER,
+    "integer": glm.Type.INTEGER,
+    "boolean": glm.Type.BOOLEAN,
+    "array": glm.Type.ARRAY,
+    "object": glm.Type.OBJECT,
+}
+
+TYPE_ENUM_REVERSE = {v: k for k, v in TYPE_ENUM.items()}
+
+
+class _ToolDictLike(TypedDict):
+    function_declarations: _FunctionDeclarationLikeList
+
+
+class _FunctionDeclarationDict(TypedDict):
+    name: str
+    description: str
+    parameters: Dict[str, Collection[str]]
+
+
+class _ToolDict(TypedDict):
+    function_declarations: Sequence[_FunctionDeclarationDict]
+
+
+# Info: This is a FunctionDeclaration(=fc).
+_FunctionDeclarationLike = Union[
+    BaseTool, Type[BaseModel], FunctionDeclaration, Callable, Dict[str, Any]
+]
+
+# Info: This mean one tool.
+_FunctionDeclarationLikeList = Sequence[_FunctionDeclarationLike]
+
+
+# Info: This means one tool=Sequence of FunctionDeclaration
+# The dict should be GoogleTool like. {"function_declarations": [ { "name": ...}.
+# OpenAI like dict is not be accepted. {{'type': 'function', 'function': {'name': ...}
+_ToolsType = Union[
+    GoogleTool,
+    ToolDict,
+    _ToolDictLike,
+    _FunctionDeclarationLikeList,
+    _FunctionDeclarationLike,
+]
+
+
+#
+# Info: GoogleTool means function_declarations and proto.Message.
+def convert_to_genai_function_declarations(
+    tool: _ToolsType,
+) -> GoogleTool:
+    if isinstance(tool, list):
+        # multiple _FunctionDeclarationLike
+        return GoogleTool(
+            function_declarations=_convert_fc_likes_to_genai_function(tool)
+        )
+    elif isinstance(tool, (BaseTool, FunctionDeclaration)):
+        # single _FunctionDeclarationLike
+        return GoogleTool(
+            function_declarations=[_convert_fc_like_to_genai_function(tool)]
+        )
+    elif isinstance(tool, type) and issubclass(tool, BaseModel):
+        # single _FunctionDeclarationLike
+        return GoogleTool(
+            function_declarations=[_convert_fc_like_to_genai_function(tool)]
+        )
+    elif isinstance(tool, GoogleTool):
+        return cast(GoogleTool, tool)
+    elif callable(tool):
+        return GoogleTool(
+            function_declarations=[
+                _convert_tool_to_genai_function(callable_as_lc_tool()(tool))
+            ]
+        )
+    elif isinstance(tool, dict):
+        return GoogleTool(function_declarations=_convert_dict_to_genai_functions(tool))  # type: ignore
+    else:
+        raise ValueError(f"Unsupported tool type {tool}")
+
+
+def tool_to_dict(tool: GoogleTool) -> _ToolDict:
+    function_declarations = []
+    for function_declaration_proto in tool.function_declarations:
+        properties: Dict[str, Any] = {}
+        for property in function_declaration_proto.parameters.properties:
+            property_type = function_declaration_proto.parameters.properties[
+                property
+            ].type
+            property_dict = {"type": TYPE_ENUM_REVERSE[property_type]}
+            property_description = function_declaration_proto.parameters.properties[
+                property
+            ].description
+            if property_description:
+                property_dict["description"] = property_description
+            properties[property] = property_dict
+        name = function_declaration_proto.name
+        description = function_declaration_proto.description
+        parameters = {"type": "object", "properties": properties}
+        if function_declaration_proto.parameters.required:
+            parameters["required"] = function_declaration_proto.parameters.required
+        function_declaration = _FunctionDeclarationDict(
+            name=name, description=description, parameters=parameters
+        )
+        function_declarations.append(function_declaration)
+    return {"function_declarations": function_declarations}
+
+
+def _convert_fc_likes_to_genai_function(
+    fc_likes: _FunctionDeclarationLikeList,
+) -> Sequence[FunctionDeclaration]:
+    if isinstance(fc_likes, list):
+        return [_convert_fc_like_to_genai_function(fc) for fc in fc_likes]
+    raise ValueError(f"Unsupported fc_likes type {fc_likes}")
+
+
+def _convert_fc_like_to_genai_function(
+    fc_like: _FunctionDeclarationLike,
+) -> FunctionDeclaration:
+    if isinstance(fc_like, BaseTool):
+        return _convert_tool_to_genai_function(fc_like)
+    elif isinstance(fc_like, type) and issubclass(fc_like, BaseModel):
+        return _convert_pydantic_to_genai_function(fc_like)
+    elif isinstance(fc_like, dict):
+        # TODO: add declaration_index
+        return _convert_dict_to_genai_function(fc_like)
+    elif callable(fc_like):
+        return _convert_tool_to_genai_function(callable_as_lc_tool()(fc_like))
+    else:
+        raise ValueError(f"Unsupported fc_like type {fc_like}")
+
+
+def _convert_tool_dict_to_genai_functions(
+    tool_dict: _ToolDictLike,
+) -> Sequence[FunctionDeclaration]:
+    if "function_declarations" in tool_dict:
+        return _convert_dicts_to_genai_functions(tool_dict["function_declarations"])  # type: ignore
+    else:
+        raise ValueError(f"Unsupported function tool_dict type {tool_dict}")
+
+
+def _convert_dict_to_genai_functions(
+    function_declarations_dict: Dict[str, Any],
+) -> Sequence[FunctionDeclaration]:
+    if "function_declarations" in function_declarations_dict:
+        # GoogleTool like
+        return [
+            _convert_dict_to_genai_function(fc, i)
+            for i, fc in enumerate(function_declarations_dict["function_declarations"])
+        ]
+    d = function_declarations_dict
+    if "name" in d and "description" in d and "parameters" in d:
+        # _FunctionDeclarationDict
+        return [_convert_dict_to_genai_function(d)]
+    else:
+        # OpenAI like?
+        raise ValueError(f"Unsupported function call type {function_declarations_dict}")
+
+
+def _convert_dicts_to_genai_functions(
+    function_declaration_dicts: Sequence[Dict[str, Any]],
+) -> Sequence[FunctionDeclaration]:
+    return [
+        _convert_dict_to_genai_function(function_declaration_dict, i)
+        for i, function_declaration_dict in enumerate(function_declaration_dicts)
+    ]
+
+
+def _convert_dict_to_genai_function(
+    function_declaration_dict: Dict[str, Any], declaration_index: int = 0
+) -> FunctionDeclaration:
+    formatted_fc = {
+        "name": function_declaration_dict.get("name", f"unknown-{declaration_index}"),
+        "description": function_declaration_dict.get("description", "no-description"),
+    }
+    if "parameters" in function_declaration_dict:
+        formatted_fc["parameters"] = {
+            "properties": {
+                k: {
+                    "type_": TYPE_ENUM[v["type"]],
+                    "description": v.get("description"),
+                }
+                for k, v in function_declaration_dict["parameters"][
+                    "properties"
+                ].items()
+            },
+            "required": function_declaration_dict.get("parameters", []).get(
+                "required", []
+            ),
+            "type_": TYPE_ENUM[function_declaration_dict["parameters"]["type"]],
+        }
+    return FunctionDeclaration(**formatted_fc)
+
+
+def _convert_tool_to_genai_function(tool: BaseTool) -> FunctionDeclaration:
+    if tool.args_schema:
+        fc = tool.args_schema
+        if isinstance(fc, type) and issubclass(fc, BaseModel):
+            return _convert_pydantic_to_genai_function(
+                fc, tool_name=tool.name, tool_description=tool.description
+            )
+        raise ValueError(f"Unsupported function call type {fc}")
+    else:
+        return FunctionDeclaration(
+            name=tool.name,
+            description=tool.description,
+            parameters={
+                "properties": {
+                    "__arg1": {"type_": TYPE_ENUM["string"]},
+                },
+                "required": ["__arg1"],
+                "type_": TYPE_ENUM["object"],
+            },
+        )
+
+
+def _convert_pydantic_to_genai_function(
+    pydantic_model: Type[BaseModel],
+    tool_name: Optional[str] = None,
+    tool_description: Optional[str] = None,
+) -> FunctionDeclaration:
+    schema = dereference_refs(pydantic_model.schema())
+    schema.pop("definitions", None)
+    function_declaration = FunctionDeclaration(
+        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()
+            },
+            "required": schema.get("required", []),
+            "type_": TYPE_ENUM[schema["type"]],
+        },
+    )
+    return function_declaration
+
+
+def _get_type_from_schema(schema: Dict[str, Any]) -> int:
+    if "anyOf" in schema:
+        types = [_get_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
+    else:
+        pass
+    return TYPE_ENUM["string"]  # Default to string if no valid types found
+
+
+_ToolChoiceType = Union[
+    dict, List[str], str, Literal["auto", "none", "any"], Literal[True]
+]
+
+
+class _FunctionCallingConfigDict(TypedDict):
+    mode: Union[FunctionCallingConfig.Mode, str]
+    allowed_function_names: Optional[List[str]]
+
+
+class _ToolConfigDict(TypedDict):
+    function_calling_config: _FunctionCallingConfigDict
+
+
+def _tool_choice_to_tool_config(
+    tool_choice: _ToolChoiceType,
+    all_names: List[str],
+) -> _ToolConfigDict:
+    allowed_function_names: Optional[List[str]] = None
+    if tool_choice is True or tool_choice == "any":
+        mode = "any"
+        allowed_function_names = all_names
+    elif tool_choice == "auto":
+        mode = "auto"
+    elif tool_choice == "none":
+        mode = "none"
+    elif isinstance(tool_choice, str):
+        mode = "any"
+        allowed_function_names = [tool_choice]
+    elif isinstance(tool_choice, list):
+        mode = "any"
+        allowed_function_names = tool_choice
+    elif isinstance(tool_choice, dict):
+        if "mode" in tool_choice:
+            mode = tool_choice["mode"]
+            allowed_function_names = tool_choice.get("allowed_function_names")
+        elif "function_calling_config" in tool_choice:
+            mode = tool_choice["function_calling_config"]["mode"]
+            allowed_function_names = tool_choice["function_calling_config"].get(
+                "allowed_function_names"
+            )
+        else:
+            raise ValueError(
+                f"Unrecognized tool choice format:\n\n{tool_choice=}\n\nShould match "
+                f"Google GenerativeAI ToolConfig or FunctionCallingConfig format."
+            )
+    else:
+        raise ValueError(f"Unrecognized tool choice format:\n\n{tool_choice=}")
+    return _ToolConfigDict(
+        function_calling_config={
+            "mode": mode,
+            "allowed_function_names": allowed_function_names,
+        }
+    )

{langchain_google_genai-1.0.5 → langchain_google_genai-1.0.7}/langchain_google_genai/chat_models.py

@@ -8,6 +8,7 @@ import os
 import uuid
 import warnings
 from io import BytesIO
+from operator import itemgetter
 from typing import (
     Any,
     AsyncIterator,
@@ -19,6 +20,7 @@ from typing import (
     Optional,
     Sequence,
     Tuple,
+    Type,
     Union,
     cast,
 )
@@ -51,7 +53,7 @@ from langchain_core.callbacks.manager import (
     CallbackManagerForLLMRun,
 )
 from langchain_core.language_models import LanguageModelInput
-from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.language_models.chat_models import BaseChatModel, LangSmithParams
 from langchain_core.messages import (
     AIMessage,
     AIMessageChunk,
@@ -64,10 +66,16 @@ from langchain_core.messages import (
     ToolCallChunk,
     ToolMessage,
 )
-from langchain_core.output_parsers.openai_tools import parse_tool_calls
+from langchain_core.messages.ai import UsageMetadata
+from langchain_core.output_parsers.base import OutputParserLike
+from langchain_core.output_parsers.openai_tools import (
+    JsonOutputToolsParser,
+    PydanticToolsParser,
+    parse_tool_calls,
+)
 from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult
-from langchain_core.pydantic_v1 import Field, SecretStr, root_validator
-from langchain_core.runnables import Runnable
+from langchain_core.pydantic_v1 import BaseModel, Field, SecretStr, root_validator
+from langchain_core.runnables import Runnable, RunnablePassthrough
 from langchain_core.utils import get_from_dict_or_env
 from tenacity import (
     before_sleep_log,
@@ -526,6 +534,22 @@ def _response_to_result(
     """Converts a PaLM API response into a LangChain ChatResult."""
     llm_output = {"prompt_feedback": proto.Message.to_dict(response.prompt_feedback)}
 
+    # 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:
+            lc_usage = UsageMetadata(
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                total_tokens=total_tokens,
+            )
+        else:
+            lc_usage = None
+    except AttributeError:
+        lc_usage = None
+
     generations: List[ChatGeneration] = []
 
     for candidate in response.candidates:
@@ -536,9 +560,11 @@ def _response_to_result(
             proto.Message.to_dict(safety_rating, use_integers_for_enums=False)
             for safety_rating in candidate.safety_ratings
         ]
+        message = _parse_response_candidate(candidate, streaming=stream)
+        message.usage_metadata = lc_usage
         generations.append(
             (ChatGenerationChunk if stream else ChatGeneration)(
-                message=_parse_response_candidate(candidate, streaming=stream),
+                message=message,
                 generation_info=generation_info,
             )
         )
@@ -593,8 +619,8 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
     convert_system_message_to_human: bool = False
     """Whether to merge any leading SystemMessage into the following HumanMessage.
-    
-    Gemini does not support system messages; any unsupported messages will 
+
+    Gemini does not support system messages; any unsupported messages will
     raise an error."""
 
     class Config:
@@ -678,6 +704,23 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             "safety_settings": self.safety_settings,
         }
 
+    def _get_ls_params(
+        self, stop: Optional[List[str]] = None, **kwargs: Any
+    ) -> LangSmithParams:
+        """Get standard params for tracing."""
+        params = self._get_invocation_params(stop=stop, **kwargs)
+        ls_params = LangSmithParams(
+            ls_provider="google_genai",
+            ls_model_name=self.model,
+            ls_model_type="chat",
+            ls_temperature=params.get("temperature", self.temperature),
+        )
+        if ls_max_tokens := params.get("max_output_tokens", self.max_output_tokens):
+            ls_params["ls_max_tokens"] = ls_max_tokens
+        if ls_stop := stop or params.get("stop", None):
+            ls_params["ls_stop"] = ls_stop
+        return ls_params
+
     def _prepare_params(
         self,
         stop: Optional[List[str]],
@@ -901,6 +944,33 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         )
         return result.total_tokens
 
+    def with_structured_output(
+        self,
+        schema: Union[Dict, Type[BaseModel]],
+        *,
+        include_raw: bool = False,
+        **kwargs: Any,
+    ) -> Runnable[LanguageModelInput, Union[Dict, BaseModel]]:
+        if kwargs:
+            raise ValueError(f"Received unsupported arguments {kwargs}")
+        if isinstance(schema, type) and issubclass(schema, BaseModel):
+            parser: OutputParserLike = PydanticToolsParser(
+                tools=[schema], first_tool_only=True
+            )
+        else:
+            parser = JsonOutputToolsParser()
+        llm = self.bind_tools([schema], tool_choice=False)
+        if include_raw:
+            parser_with_fallback = RunnablePassthrough.assign(
+                parsed=itemgetter("raw") | parser, parsing_error=lambda _: None
+            ).with_fallbacks(
+                [RunnablePassthrough.assign(parsed=lambda _: None)],
+                exception_key="parsing_error",
+            )
+            return {"raw": llm} | parser_with_fallback
+        else:
+            return llm | parser
+
     def bind_tools(
         self,
         tools: Sequence[Union[ToolDict, GoogleTool]],
@@ -927,7 +997,9 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                 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))]
+        genai_tools = [
+            tool_to_dict(convert_to_genai_function_declarations(tool)) for tool in tools
+        ]
         if tool_choice:
             all_names = [
                 f["name"]  # type: ignore[index]
@@ -935,4 +1007,5 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                 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)

{langchain_google_genai-1.0.5 → langchain_google_genai-1.0.7}/langchain_google_genai/embeddings.py

@@ -1,3 +1,5 @@
+import re
+import string
 from typing import Any, Dict, List, Optional
 
 # TODO: remove ignore once the google package is published with types
@@ -15,6 +17,9 @@ from langchain_google_genai._common import (
 )
 from langchain_google_genai._genai_extension import build_generative_service
 
+_MAX_TOKENS_PER_BATCH = 20000
+_DEFAULT_BATCH_SIZE = 100
+
 
 class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
     """`Google Generative AI Embeddings`.
@@ -81,6 +86,8 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
         google_api_key = get_from_dict_or_env(
             values, "google_api_key", "GOOGLE_API_KEY"
         )
+        if isinstance(google_api_key, SecretStr):
+            google_api_key = google_api_key.get_secret_value()
         client_info = get_client_info("GoogleGenerativeAIEmbeddings")
 
         values["client"] = build_generative_service(
@@ -91,6 +98,67 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
         )
         return values
 
+    @staticmethod
+    def _split_by_punctuation(text: str) -> List[str]:
+        """Splits a string by punctuation and whitespace characters."""
+        split_by = string.punctuation + "\t\n "
+        pattern = f"([{split_by}])"
+        # Using re.split to split the text based on the pattern
+        return [segment for segment in re.split(pattern, text) if segment]
+
+    @staticmethod
+    def _prepare_batches(texts: List[str], batch_size: int) -> List[List[str]]:
+        """Splits texts in batches based on current maximum batch size
+        and maximum tokens per request.
+        """
+        text_index = 0
+        texts_len = len(texts)
+        batch_token_len = 0
+        batches: List[List[str]] = []
+        current_batch: List[str] = []
+        if texts_len == 0:
+            return []
+        while text_index < texts_len:
+            current_text = texts[text_index]
+            # Number of tokens per a text is conservatively estimated
+            # as 2 times number of words, punctuation and whitespace characters.
+            # Using `count_tokens` API will make batching too expensive.
+            # Utilizing a tokenizer, would add a dependency that would not
+            # necessarily be reused by the application using this class.
+            current_text_token_cnt = (
+                len(GoogleGenerativeAIEmbeddings._split_by_punctuation(current_text))
+                * 2
+            )
+            end_of_batch = False
+            if current_text_token_cnt > _MAX_TOKENS_PER_BATCH:
+                # Current text is too big even for a single batch.
+                # Such request will fail, but we still make a batch
+                # so that the app can get the error from the API.
+                if len(current_batch) > 0:
+                    # Adding current batch if not empty.
+                    batches.append(current_batch)
+                current_batch = [current_text]
+                text_index += 1
+                end_of_batch = True
+            elif (
+                batch_token_len + current_text_token_cnt > _MAX_TOKENS_PER_BATCH
+                or len(current_batch) == batch_size
+            ):
+                end_of_batch = True
+            else:
+                if text_index == texts_len - 1:
+                    # Last element - even though the batch may be not big,
+                    # we still need to make it.
+                    end_of_batch = True
+                batch_token_len += current_text_token_cnt
+                current_batch.append(current_text)
+                text_index += 1
+            if end_of_batch:
+                batches.append(current_batch)
+                current_batch = []
+                batch_token_len = 0
+        return batches
+
     def _prepare_request(
         self,
         text: str,
@@ -112,12 +180,14 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
     def embed_documents(
         self,
         texts: List[str],
+        *,
+        batch_size: int = _DEFAULT_BATCH_SIZE,
         task_type: Optional[str] = None,
         titles: Optional[List[str]] = None,
         output_dimensionality: Optional[int] = None,
     ) -> List[List[float]]:
-        """Embed a list of strings. Vertex AI currently
-        sets a max batch size of 5 strings.
+        """Embed a list of strings. Google Generative AI currently
+        sets a max batch size of 100 strings.
 
         Args:
             texts: List[str] The list of strings to embed.
@@ -127,28 +197,38 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
             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:
             List of embeddings, one for each text.
         """
-        titles = titles if titles else [None] * len(texts)  # type: ignore[list-item]
-        requests = [
-            self._prepare_request(
-                text=text,
-                task_type=task_type,
-                title=title,
-                output_dimensionality=output_dimensionality,
-            )
-            for text, title in zip(texts, titles)
-        ]
+        embeddings: List[List[float]] = []
+        batch_start_index = 0
+        for batch in GoogleGenerativeAIEmbeddings._prepare_batches(texts, batch_size):
+            if titles:
+                titles_batch = titles[
+                    batch_start_index : batch_start_index + len(batch)
+                ]
+                batch_start_index += len(batch)
+            else:
+                titles_batch = [None] * len(batch)  # type: ignore[list-item]
 
-        try:
-            result = self.client.batch_embed_contents(
-                BatchEmbedContentsRequest(requests=requests, model=self.model)
-            )
-        except Exception as e:
-            raise GoogleGenerativeAIError(f"Error embedding content: {e}") from e
-        return [e.values for e in result.embeddings]
+            requests = [
+                self._prepare_request(
+                    text=text,
+                    task_type=task_type,
+                    title=title,
+                    output_dimensionality=output_dimensionality,
+                )
+                for text, title in zip(batch, titles_batch)
+            ]
+
+            try:
+                result = self.client.batch_embed_contents(
+                    BatchEmbedContentsRequest(requests=requests, model=self.model)
+                )
+            except Exception as e:
+                raise GoogleGenerativeAIError(f"Error embedding content: {e}") from e
+            embeddings.extend([list(e.values) for e in result.embeddings])
+        return embeddings
 
     def embed_query(
         self,

{langchain_google_genai-1.0.5 → langchain_google_genai-1.0.7}/langchain_google_genai/llms.py

@@ -325,9 +325,16 @@ class GoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseLLM):
         run_manager: Optional[CallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> Iterator[GenerationChunk]:
-        generation_config = kwargs.get("generation_config", {})
-        if stop:
-            generation_config["stop_sequences"] = stop
+        generation_config = {
+            "stop_sequences": stop,
+            "temperature": self.temperature,
+            "top_p": self.top_p,
+            "top_k": self.top_k,
+            "max_output_tokens": self.max_output_tokens,
+            "candidate_count": self.n,
+        }
+        generation_config = generation_config | kwargs.get("generation_config", {})
+
         for stream_resp in _completion_with_retry(
             self,
             prompt,

{langchain_google_genai-1.0.5 → langchain_google_genai-1.0.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langchain-google-genai"
-version = "1.0.5"
+version = "1.0.7"
 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 = ">=0.2.0,<0.3"
-google-generativeai = "^0.5.2"
+langchain-core = ">=0.2.9,<0.3"
+google-generativeai = "^0.7.0"
 pillow = { version = "^10.1.0", optional = true }
 
 [tool.poetry.extras]
@@ -32,6 +32,9 @@ pytest-asyncio = "^0.21.1"
 numpy = "^1.26.2"
 langchain-core = { git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/core" }
 
+[tool.codespell]
+ignore-words-list = "rouge"
+
 [tool.poetry.group.codespell]
 optional = true
 
@@ -58,6 +61,7 @@ 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" }
+numpy = "^1.26.2"
 
 [tool.poetry.group.dev]
 optional = true
@@ -69,7 +73,7 @@ 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" }
 
-[tool.ruff]
+[tool.ruff.lint]
 select = [
   "E", # pycodestyle
   "F", # pyflakes

langchain_google_genai-1.0.5/langchain_google_genai/_function_utils.py

@@ -1,237 +0,0 @@
-from __future__ import annotations
-
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    List,
-    Literal,
-    Optional,
-    Sequence,
-    Type,
-    TypedDict,
-    Union,
-    cast,
-)
-
-import google.ai.generativelanguage as glm
-from google.ai.generativelanguage import (
-    FunctionCallingConfig,
-    FunctionDeclaration,
-)
-from google.ai.generativelanguage import (
-    Tool as GoogleTool,
-)
-from langchain_core.pydantic_v1 import BaseModel
-from langchain_core.tools import BaseTool
-from langchain_core.tools import tool as callable_as_lc_tool
-from langchain_core.utils.json_schema import dereference_refs
-
-TYPE_ENUM = {
-    "string": glm.Type.STRING,
-    "number": glm.Type.NUMBER,
-    "integer": glm.Type.INTEGER,
-    "boolean": glm.Type.BOOLEAN,
-    "array": glm.Type.ARRAY,
-    "object": glm.Type.OBJECT,
-}
-
-TYPE_ENUM_REVERSE = {v: k for k, v in TYPE_ENUM.items()}
-
-_FunctionDeclarationLike = Union[
-    BaseTool, Type[BaseModel], dict, Callable, FunctionDeclaration
-]
-
-
-class _ToolDict(TypedDict):
-    function_declarations: Sequence[_FunctionDeclarationLike]
-
-
-def convert_to_genai_function_declarations(
-    tool: Union[
-        GoogleTool,
-        _ToolDict,
-        _FunctionDeclarationLike,
-        Sequence[_FunctionDeclarationLike],
-    ],
-) -> GoogleTool:
-    if isinstance(tool, GoogleTool):
-        return cast(GoogleTool, tool)
-    if isinstance(tool, type) and issubclass(tool, BaseModel):
-        return GoogleTool(function_declarations=[_convert_to_genai_function(tool)])
-    if callable(tool):
-        return _convert_tool_to_genai_function(callable_as_lc_tool()(tool))
-    if isinstance(tool, list):
-        return convert_to_genai_function_declarations({"function_declarations": tool})
-    if isinstance(tool, dict) and "function_declarations" in tool:
-        return GoogleTool(
-            function_declarations=[
-                _convert_to_genai_function(fc) for fc in tool["function_declarations"]
-            ],
-        )
-    return GoogleTool(function_declarations=[_convert_to_genai_function(tool)])  # type: ignore[arg-type]
-
-
-def tool_to_dict(tool: GoogleTool) -> _ToolDict:
-    function_declarations = []
-    for function_declaration_proto in tool.function_declarations:
-        properties: Dict[str, Any] = {}
-        for property in function_declaration_proto.parameters.properties:
-            property_type = function_declaration_proto.parameters.properties[
-                property
-            ].type
-            property_dict = {"type": TYPE_ENUM_REVERSE[property_type]}
-            property_description = function_declaration_proto.parameters.properties[
-                property
-            ].description
-            if property_description:
-                property_dict["description"] = property_description
-            properties[property] = property_dict
-        function_declaration = {
-            "name": function_declaration_proto.name,
-            "description": function_declaration_proto.description,
-            "parameters": {"type": "object", "properties": properties},
-        }
-        if function_declaration_proto.parameters.required:
-            function_declaration["parameters"][  # type: ignore[index]
-                "required"
-            ] = function_declaration_proto.parameters.required
-        function_declarations.append(function_declaration)
-    return {"function_declarations": function_declarations}
-
-
-def _convert_to_genai_function(fc: _FunctionDeclarationLike) -> FunctionDeclaration:
-    if isinstance(fc, BaseTool):
-        return _convert_tool_to_genai_function(fc)
-    elif isinstance(fc, type) and issubclass(fc, BaseModel):
-        return _convert_pydantic_to_genai_function(fc)
-    elif callable(fc):
-        return _convert_tool_to_genai_function(callable_as_lc_tool()(fc))
-    elif isinstance(fc, dict):
-        formatted_fc = {"name": fc["name"], "description": fc.get("description")}
-        if "parameters" in fc:
-            formatted_fc["parameters"] = {
-                "properties": {
-                    k: {
-                        "type_": TYPE_ENUM[v["type"]],
-                        "description": v.get("description"),
-                    }
-                    for k, v in fc["parameters"]["properties"].items()
-                },
-                "required": fc.get("parameters", []).get("required", []),
-                "type_": TYPE_ENUM[fc["parameters"]["type"]],
-            }
-        return FunctionDeclaration(**formatted_fc)
-    else:
-        raise ValueError(f"Unsupported function call type {fc}")
-
-
-def _convert_tool_to_genai_function(tool: BaseTool) -> FunctionDeclaration:
-    if tool.args_schema:
-        schema = dereference_refs(tool.args_schema.schema())
-        schema.pop("definitions", None)
-        return FunctionDeclaration(
-            name=tool.name or schema["title"],
-            description=tool.description or schema["description"],
-            parameters={
-                "properties": {
-                    k: {
-                        "type_": TYPE_ENUM[v["type"]],
-                        "description": v.get("description"),
-                    }
-                    for k, v in schema["properties"].items()
-                },
-                "required": schema.get("required", []),
-                "type_": TYPE_ENUM[schema["type"]],
-            },
-        )
-    else:
-        return FunctionDeclaration(
-            name=tool.name,
-            description=tool.description,
-            parameters={
-                "properties": {
-                    "__arg1": {"type_": TYPE_ENUM["string"]},
-                },
-                "required": ["__arg1"],
-                "type_": TYPE_ENUM["object"],
-            },
-        )
-
-
-def _convert_pydantic_to_genai_function(
-    pydantic_model: Type[BaseModel],
-) -> FunctionDeclaration:
-    schema = dereference_refs(pydantic_model.schema())
-    schema.pop("definitions", None)
-    return FunctionDeclaration(
-        name=schema["title"],
-        description=schema.get("description", ""),
-        parameters={
-            "properties": {
-                k: {
-                    "type_": TYPE_ENUM[v["type"]],
-                    "description": v.get("description"),
-                }
-                for k, v in schema["properties"].items()
-            },
-            "required": schema["required"],
-            "type_": TYPE_ENUM[schema["type"]],
-        },
-    )
-
-
-_ToolChoiceType = Union[
-    dict, List[str], str, Literal["auto", "none", "any"], Literal[True]
-]
-
-
-class _FunctionCallingConfigDict(TypedDict):
-    mode: Union[FunctionCallingConfig.Mode, str]
-    allowed_function_names: Optional[List[str]]
-
-
-class _ToolConfigDict(TypedDict):
-    function_calling_config: _FunctionCallingConfigDict
-
-
-def _tool_choice_to_tool_config(
-    tool_choice: _ToolChoiceType,
-    all_names: List[str],
-) -> _ToolConfigDict:
-    allowed_function_names: Optional[List[str]] = None
-    if tool_choice is True or tool_choice == "any":
-        mode = "any"
-        allowed_function_names = all_names
-    elif tool_choice == "auto":
-        mode = "auto"
-    elif tool_choice == "none":
-        mode = "none"
-    elif isinstance(tool_choice, str):
-        mode = "any"
-        allowed_function_names = [tool_choice]
-    elif isinstance(tool_choice, list):
-        mode = "any"
-        allowed_function_names = tool_choice
-    elif isinstance(tool_choice, dict):
-        if "mode" in tool_choice:
-            mode = tool_choice["mode"]
-            allowed_function_names = tool_choice.get("allowed_function_names")
-        elif "function_calling_config" in tool_choice:
-            mode = tool_choice["function_calling_config"]["mode"]
-            allowed_function_names = tool_choice["function_calling_config"].get(
-                "allowed_function_names"
-            )
-        else:
-            raise ValueError(
-                f"Unrecognized tool choice format:\n\n{tool_choice=}\n\nShould match "
-                f"Google GenerativeAI ToolConfig or FunctionCallingConfig format."
-            )
-    else:
-        raise ValueError(f"Unrecognized tool choice format:\n\n{tool_choice=}")
-    return _ToolConfigDict(
-        function_calling_config={
-            "mode": mode,
-            "allowed_function_names": allowed_function_names,
-        }
-    )