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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-google-genai
-Version: 1.0.7
+Version: 1.0.8
 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.7.0,<0.8.0)
-Requires-Dist: langchain-core (>=0.2.9,<0.3)
+Requires-Dist: langchain-core (>=0.2.17,<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.8/langchain_google_genai/_function_utils.py

@@ -0,0 +1,329 @@
+from __future__ import annotations
+
+import collections
+import json
+import logging
+from typing import (
+    Any,
+    Callable,
+    Collection,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Sequence,
+    Type,
+    TypedDict,
+    Union,
+    cast,
+)
+
+import google.ai.generativelanguage as glm
+import google.ai.generativelanguage_v1beta.types as gapic
+import proto  # type: ignore[import]
+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.function_calling import (
+    FunctionDescription,
+    convert_to_openai_tool,
+)
+from langchain_core.utils.json_schema import dereference_refs
+
+logger = logging.getLogger(__name__)
+
+
+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()}
+_ALLOWED_SCHEMA_FIELDS = []
+_ALLOWED_SCHEMA_FIELDS.extend([f.name for f in gapic.Schema()._pb.DESCRIPTOR.fields])
+_ALLOWED_SCHEMA_FIELDS.extend(
+    [
+        f
+        for f in gapic.Schema.to_dict(
+            gapic.Schema(), preserving_proto_field_name=False
+        ).keys()
+    ]
+)
+_ALLOWED_SCHEMA_FIELDS_SET = set(_ALLOWED_SCHEMA_FIELDS)
+
+
+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], gapic.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 gapic.Tool like. {"function_declarations": [ { "name": ...}.
+# OpenAI like dict is not be accepted. {{'type': 'function', 'function': {'name': ...}
+_ToolsType = Union[
+    gapic.Tool,
+    ToolDict,
+    _ToolDictLike,
+    _FunctionDeclarationLikeList,
+    _FunctionDeclarationLike,
+]
+
+
+def _format_json_schema_to_gapic(schema: Dict[str, Any]) -> Dict[str, Any]:
+    converted_schema: Dict[str, Any] = {}
+    for key, value in schema.items():
+        if key == "definitions":
+            continue
+        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
+                )
+            continue
+        elif key in ["type", "_type"]:
+            converted_schema["type"] = str(value).upper()
+        elif key not in _ALLOWED_SCHEMA_FIELDS_SET:
+            logger.warning(f"Key '{key}' is not supported in schema, ignoring")
+        else:
+            converted_schema[key] = value
+    return converted_schema
+
+
+def _dict_to_gapic_schema(schema: Dict[str, Any]) -> gapic.Schema:
+    dereferenced_schema = dereference_refs(schema)
+    formatted_schema = _format_json_schema_to_gapic(dereferenced_schema)
+    json_schema = json.dumps(formatted_schema)
+    return gapic.Schema.from_json(json_schema)
+
+
+def _format_dict_to_function_declaration(
+    tool: Union[FunctionDescription, Dict[str, Any]],
+) -> gapic.FunctionDeclaration:
+    return gapic.FunctionDeclaration(
+        name=tool.get("name"),
+        description=tool.get("description"),
+        parameters=_dict_to_gapic_schema(tool.get("parameters", {})),
+    )
+
+
+# Info: gapic.Tool means function_declarations and proto.Message.
+def convert_to_genai_function_declarations(
+    tools: Sequence[_ToolsType],
+) -> gapic.Tool:
+    if not isinstance(tools, collections.abc.Sequence):
+        logger.warning(
+            "convert_to_genai_function_declarations expects a Sequence "
+            "and not a single tool."
+        )
+        tools = [tools]
+    gapic_tool = gapic.Tool()
+    for tool in tools:
+        if isinstance(tool, gapic.Tool):
+            gapic_tool.function_declarations.extend(tool.function_declarations)
+        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"]
+            if not isinstance(function_declarations, collections.abc.Sequence):
+                raise ValueError(
+                    "function_declarations should be a list"
+                    f"got '{type(function_declarations)}'"
+                )
+            if function_declarations:
+                fds = [
+                    _format_to_gapic_function_declaration(fd)
+                    for fd in function_declarations
+                ]
+                gapic_tool.function_declarations.extend(fds)
+        else:
+            fd = _format_to_gapic_function_declaration(tool)
+            gapic_tool.function_declarations.append(fd)
+    return gapic_tool
+
+
+def tool_to_dict(tool: gapic.Tool) -> _ToolDict:
+    def _traverse_values(raw: Any) -> Any:
+        if isinstance(raw, list):
+            return [_traverse_values(v) for v in raw]
+        if isinstance(raw, dict):
+            return {k: _traverse_values(v) for k, v in raw.items()}
+        if isinstance(raw, proto.Message):
+            return _traverse_values(type(raw).to_dict(raw))
+        return raw
+
+    return _traverse_values(type(tool).to_dict(tool))
+
+
+def _format_to_gapic_function_declaration(
+    tool: _FunctionDeclarationLike,
+) -> gapic.FunctionDeclaration:
+    if isinstance(tool, BaseTool):
+        return _format_base_tool_to_function_declaration(tool)
+    elif isinstance(tool, type) and issubclass(tool, BaseModel):
+        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:
+            function = cast(dict, tool)
+            function["parameters"] = {}
+        else:
+            function = convert_to_openai_tool(cast(dict, tool))["function"]
+        return _format_dict_to_function_declaration(cast(FunctionDescription, function))
+    elif callable(tool):
+        return _format_base_tool_to_function_declaration(callable_as_lc_tool()(tool))
+    raise ValueError(f"Unsupported tool type {tool}")
+
+
+def _format_base_tool_to_function_declaration(
+    tool: BaseTool,
+) -> gapic.FunctionDeclaration:
+    if not tool.args_schema:
+        return gapic.FunctionDeclaration(
+            name=tool.name,
+            description=tool.description,
+            parameters=gapic.Schema(
+                type=gapic.Type.OBJECT,
+                properties={
+                    "__arg1": gapic.Schema(type=gapic.Type.STRING),
+                },
+                required=["__arg1"],
+            ),
+        )
+
+    schema = tool.args_schema.schema()
+    parameters = _dict_to_gapic_schema(schema)
+
+    return gapic.FunctionDeclaration(
+        name=tool.name or schema.get("title"),
+        description=tool.description or schema.get("description"),
+        parameters=parameters,
+    )
+
+
+def _convert_pydantic_to_genai_function(
+    pydantic_model: Type[BaseModel],
+    tool_name: Optional[str] = None,
+    tool_description: Optional[str] = None,
+) -> gapic.FunctionDeclaration:
+    schema = dereference_refs(pydantic_model.schema())
+    schema.pop("definitions", None)
+    function_declaration = gapic.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[gapic.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.upper(),
+            "allowed_function_names": allowed_function_names,
+        }
+    )

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

@@ -60,13 +60,11 @@ from langchain_core.messages import (
     BaseMessage,
     FunctionMessage,
     HumanMessage,
-    InvalidToolCall,
     SystemMessage,
-    ToolCall,
-    ToolCallChunk,
     ToolMessage,
 )
 from langchain_core.messages.ai import UsageMetadata
+from langchain_core.messages.tool import invalid_tool_call, tool_call, tool_call_chunk
 from langchain_core.output_parsers.base import OutputParserLike
 from langchain_core.output_parsers.openai_tools import (
     JsonOutputToolsParser,
@@ -140,7 +138,7 @@ def _create_retry_decorator() -> Callable[[Any], Any]:
     multiplier = 2
     min_seconds = 1
     max_seconds = 60
-    max_retries = 10
+    max_retries = 2
 
     return retry(
         reraise=True,
@@ -466,9 +464,6 @@ def _parse_response_candidate(
                 raise Exception("Unexpected content type")
 
         if part.function_call:
-            # TODO: support multiple function calls
-            if "function_call" in additional_kwargs:
-                raise Exception("Multiple function calls are not currently supported")
             function_call = {"name": part.function_call.name}
             # dump to match other function calling llm for now
             function_call_args_dict = proto.Message.to_dict(part.function_call)["args"]
@@ -479,7 +474,7 @@ def _parse_response_candidate(
 
             if streaming:
                 tool_call_chunks.append(
-                    ToolCallChunk(
+                    tool_call_chunk(
                         name=function_call.get("name"),
                         args=function_call.get("arguments"),
                         id=function_call.get("id", str(uuid.uuid4())),
@@ -488,27 +483,27 @@ def _parse_response_candidate(
                 )
             else:
                 try:
-                    tool_calls_dicts = parse_tool_calls(
+                    tool_call_dict = parse_tool_calls(
                         [{"function": function_call}],
                         return_id=False,
-                    )
-                    tool_calls = [
-                        ToolCall(
-                            name=tool_call["name"],
-                            args=tool_call["args"],
-                            id=tool_call.get("id", str(uuid.uuid4())),
-                        )
-                        for tool_call in tool_calls_dicts
-                    ]
+                    )[0]
                 except Exception as e:
-                    invalid_tool_calls = [
-                        InvalidToolCall(
+                    invalid_tool_calls.append(
+                        invalid_tool_call(
                             name=function_call.get("name"),
                             args=function_call.get("arguments"),
                             id=function_call.get("id", str(uuid.uuid4())),
                             error=str(e),
                         )
-                    ]
+                    )
+                else:
+                    tool_calls.append(
+                        tool_call(
+                            name=tool_call_dict["name"],
+                            args=tool_call_dict["args"],
+                            id=tool_call_dict.get("id", str(uuid.uuid4())),
+                        )
+                    )
     if content is None:
         content = ""
 
@@ -594,33 +589,215 @@ def _is_event_loop_running() -> bool:
 
 
 class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
-    """`Google Generative AI` Chat models API.
+    """`Google AI` chat models integration.
 
-    To use, you must have either:
+    Instantiation:
+        To use, you must have either:
 
-        1. The ``GOOGLE_API_KEY``` environment variable set with your API key, or
-        2. Pass your API key using the google_api_key kwarg to the ChatGoogle
-           constructor.
+            1. The ``GOOGLE_API_KEY``` environment variable set with your API key, or
+            2. Pass your API key using the google_api_key kwarg to the ChatGoogle
+               constructor.
 
-    Example:
         .. code-block:: python
 
             from langchain_google_genai import ChatGoogleGenerativeAI
-            chat = ChatGoogleGenerativeAI(model="gemini-pro")
-            chat.invoke("Write me a ballad about LangChain")
 
-    """
+            llm = ChatGoogleGenerativeAI(model="gemini-1.5-pro")
+            llm.invoke("Write me a ballad about LangChain")
+
+    Invoke:
+        .. code-block:: python
+
+            messages = [
+                ("system", "Translate the user sentence to French."),
+                ("human", "I love programming."),
+            ]
+            llm.invoke(messages)
+
+        .. code-block:: python
+
+            AIMessage(
+                content="J'adore programmer. \\n",
+                response_metadata={'prompt_feedback': {'block_reason': 0, 'safety_ratings': []}, 'finish_reason': 'STOP', 'safety_ratings': [{'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HATE_SPEECH', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HARASSMENT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT', 'probability': 'NEGLIGIBLE', 'blocked': False}]},
+                id='run-56cecc34-2e54-4b52-a974-337e47008ad2-0',
+                usage_metadata={'input_tokens': 18, 'output_tokens': 5, 'total_tokens': 23}
+            )
+
+    Stream:
+        .. code-block:: python
+
+            for chunk in llm.stream(messages):
+                print(chunk)
+
+        .. code-block:: python
+
+            AIMessageChunk(content='J', response_metadata={'finish_reason': 'STOP', 'safety_ratings': []}, id='run-e905f4f4-58cb-4a10-a960-448a2bb649e3', usage_metadata={'input_tokens': 18, 'output_tokens': 1, 'total_tokens': 19})
+            AIMessageChunk(content="'adore programmer. \n", response_metadata={'finish_reason': 'STOP', 'safety_ratings': [{'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HATE_SPEECH', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HARASSMENT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT', 'probability': 'NEGLIGIBLE', 'blocked': False}]}, id='run-e905f4f4-58cb-4a10-a960-448a2bb649e3', usage_metadata={'input_tokens': 18, 'output_tokens': 5, 'total_tokens': 23})
+
+        .. code-block:: python
+
+            stream = llm.stream(messages)
+            full = next(stream)
+            for chunk in stream:
+                full += chunk
+            full
+
+        .. code-block:: python
+
+            AIMessageChunk(
+                content="J'adore programmer. \\n",
+                response_metadata={'finish_reason': 'STOPSTOP', 'safety_ratings': [{'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HATE_SPEECH', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HARASSMENT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT', 'probability': 'NEGLIGIBLE', 'blocked': False}]},
+                id='run-3ce13a42-cd30-4ad7-a684-f1f0b37cdeec',
+                usage_metadata={'input_tokens': 36, 'output_tokens': 6, 'total_tokens': 42}
+            )
+
+    Async:
+        .. code-block:: python
+
+            await llm.ainvoke(messages)
+
+            # stream:
+            # async for chunk in (await llm.astream(messages))
+
+            # batch:
+            # await llm.abatch([messages])
+
+    Tool calling:
+        .. code-block:: python
+
+            from langchain_core.pydantic_v1 import BaseModel, Field
+
+
+            class GetWeather(BaseModel):
+                '''Get the current weather in a given location'''
+
+                location: str = Field(
+                    ..., description="The city and state, e.g. San Francisco, CA"
+                )
+
+
+            class GetPopulation(BaseModel):
+                '''Get the current population in a given location'''
+
+                location: str = Field(
+                    ..., description="The city and state, e.g. San Francisco, CA"
+                )
+
+
+            llm_with_tools = llm.bind_tools([GetWeather, GetPopulation])
+            ai_msg = llm_with_tools.invoke(
+                "Which city is hotter today and which is bigger: LA or NY?"
+            )
+            ai_msg.tool_calls
+
+        .. code-block:: python
+
+            [{'name': 'GetWeather',
+              'args': {'location': 'Los Angeles, CA'},
+              'id': 'c186c99f-f137-4d52-947f-9e3deabba6f6'},
+             {'name': 'GetWeather',
+              'args': {'location': 'New York City, NY'},
+              'id': 'cebd4a5d-e800-4fa5-babd-4aa286af4f31'},
+             {'name': 'GetPopulation',
+              'args': {'location': 'Los Angeles, CA'},
+              'id': '4f92d897-f5e4-4d34-a3bc-93062c92591e'},
+             {'name': 'GetPopulation',
+              'args': {'location': 'New York City, NY'},
+              'id': '634582de-5186-4e4b-968b-f192f0a93678'}]
+
+    Structured output:
+        .. code-block:: python
+
+            from typing import Optional
+
+            from langchain_core.pydantic_v1 import BaseModel, Field
+
+
+            class Joke(BaseModel):
+                '''Joke to tell user.'''
+
+                setup: str = Field(description="The setup of the joke")
+                punchline: str = Field(description="The punchline to the joke")
+                rating: Optional[int] = Field(description="How funny the joke is, from 1 to 10")
+
+
+            structured_llm = llm.with_structured_output(Joke)
+            structured_llm.invoke("Tell me a joke about cats")
 
-    client: Any  #: :meta private:
-    async_client: Any  #: :meta private:
+        .. code-block:: python
+
+            Joke(
+                setup='Why are cats so good at video games?',
+                punchline='They have nine lives on the internet',
+                rating=None
+            )
+
+    Image input:
+        .. code-block:: python
+
+            import base64
+            import httpx
+            from langchain_core.messages import HumanMessage
+
+            image_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
+            image_data = base64.b64encode(httpx.get(image_url).content).decode("utf-8")
+            message = HumanMessage(
+                content=[
+                    {"type": "text", "text": "describe the weather in this image"},
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": f"data:image/jpeg;base64,{image_data}"},
+                    },
+                ]
+            )
+            ai_msg = llm.invoke([message])
+            ai_msg.content
+
+        .. code-block:: python
+
+            'The weather in this image appears to be sunny and pleasant. The sky is a bright blue with scattered white clouds, suggesting fair weather. The lush green grass and trees indicate a warm and possibly slightly breezy day. There are no signs of rain or storms. \n'
+
+    Token usage:
+        .. code-block:: python
+
+            ai_msg = llm.invoke(messages)
+            ai_msg.usage_metadata
+
+        .. code-block:: python
+
+            {'input_tokens': 18, 'output_tokens': 5, 'total_tokens': 23}
+
+
+        Response metadata
+        .. code-block:: python
+
+            ai_msg = llm.invoke(messages)
+            ai_msg.response_metadata
+
+        .. code-block:: python
+
+            {
+                'prompt_feedback': {'block_reason': 0, 'safety_ratings': []},
+                'finish_reason': 'STOP',
+                'safety_ratings': [{'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HATE_SPEECH', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HARASSMENT', 'probability': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT', 'probability': 'NEGLIGIBLE', 'blocked': False}]
+            }
+
+    """  # noqa: E501
+
+    client: Any = None  #: :meta private:
+    async_client: Any = None  #: :meta private:
+    google_api_key: Optional[SecretStr] = Field(default=None, alias="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
     )  #: :meta private:
 
     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:
@@ -786,9 +963,18 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         **kwargs: Any,
     ) -> ChatResult:
         if not self.async_client:
-            raise RuntimeError(
-                "Initialize ChatGoogleGenerativeAI with a running event loop "
-                "to use async methods."
+            updated_kwargs = {
+                **kwargs,
+                **{
+                    "tools": tools,
+                    "functions": functions,
+                    "safety_settings": safety_settings,
+                    "tool_config": tool_config,
+                    "generation_config": generation_config,
+                },
+            }
+            return await super()._agenerate(
+                messages, stop, run_manager, **updated_kwargs
             )
 
         request = self._prepare_request(
@@ -857,27 +1043,43 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         generation_config: Optional[Dict[str, Any]] = None,
         **kwargs: Any,
     ) -> AsyncIterator[ChatGenerationChunk]:
-        request = self._prepare_request(
-            messages,
-            stop=stop,
-            tools=tools,
-            functions=functions,
-            safety_settings=safety_settings,
-            tool_config=tool_config,
-            generation_config=generation_config,
-        )
-        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)
-            gen = cast(ChatGenerationChunk, _chat_result.generations[0])
+        if not self.async_client:
+            updated_kwargs = {
+                **kwargs,
+                **{
+                    "tools": tools,
+                    "functions": functions,
+                    "safety_settings": safety_settings,
+                    "tool_config": tool_config,
+                    "generation_config": generation_config,
+                },
+            }
+            async for value in super()._astream(
+                messages, stop, run_manager, **updated_kwargs
+            ):
+                yield value
+        else:
+            request = self._prepare_request(
+                messages,
+                stop=stop,
+                tools=tools,
+                functions=functions,
+                safety_settings=safety_settings,
+                tool_config=tool_config,
+                generation_config=generation_config,
+            )
+            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)
+                gen = cast(ChatGenerationChunk, _chat_result.generations[0])
 
-            if run_manager:
-                await run_manager.on_llm_new_token(gen.text)
-            yield gen
+                if run_manager:
+                    await run_manager.on_llm_new_token(gen.text)
+                yield gen
 
     def _prepare_request(
         self,
@@ -892,9 +1094,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
     ) -> Tuple[GenerateContentRequest, Dict[str, Any]]:
         formatted_tools = None
         if tools:
-            formatted_tools = [
-                convert_to_genai_function_declarations(tool) for tool in tools
-            ]
+            formatted_tools = [convert_to_genai_function_declarations(tools)]
         elif functions:
             formatted_tools = [convert_to_genai_function_declarations(functions)]
 
@@ -959,7 +1159,8 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             )
         else:
             parser = JsonOutputToolsParser()
-        llm = self.bind_tools([schema], tool_choice=False)
+        tool_choice = _get_tool_name(schema) if self._supports_tool_choice else None
+        llm = self.bind_tools([schema], tool_choice=tool_choice)
         if include_raw:
             parser_with_fallback = RunnablePassthrough.assign(
                 parsed=itemgetter("raw") | parser, parsing_error=lambda _: None
@@ -997,9 +1198,7 @@ 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(tool)) for tool in tools
-        ]
+        genai_tools = [tool_to_dict(convert_to_genai_function_declarations(tools))]
         if tool_choice:
             all_names = [
                 f["name"]  # type: ignore[index]
@@ -1007,5 +1206,15 @@ 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)
+
+    @property
+    def _supports_tool_choice(self) -> bool:
+        return "gemini-1.5-pro" in self.model
+
+
+def _get_tool_name(
+    tool: Union[ToolDict, GoogleTool],
+) -> str:
+    genai_tool = tool_to_dict(convert_to_genai_function_declarations([tool]))
+    return [f["name"] for f in genai_tool["function_declarations"]][0]  # type: ignore[index]

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

@@ -39,20 +39,20 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
             embeddings.embed_query("What's our Q1 revenue?")
     """
 
-    client: Any  #: :meta private:
+    client: Any = None  #: :meta private:
     model: str = Field(
         ...,
         description="The name of the embedding model to use. "
         "Example: models/embedding-001",
     )
     task_type: Optional[str] = Field(
-        None,
+        default=None,
         description="The task type. Valid options include: "
         "task_type_unspecified, retrieval_query, retrieval_document, "
         "semantic_similarity, classification, and clustering",
     )
     google_api_key: Optional[SecretStr] = Field(
-        None,
+        default=None,
         description="The Google API key to use. If not provided, "
         "the GOOGLE_API_KEY environment variable will be used.",
     )
@@ -64,18 +64,18 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
         "provided, credentials will be ascertained from the GOOGLE_API_KEY envvar",
     )
     client_options: Optional[Dict] = Field(
-        None,
+        default=None,
         description=(
             "A dictionary of client options to pass to the Google API client, "
             "such as `api_endpoint`."
         ),
     )
     transport: Optional[str] = Field(
-        None,
+        default=None,
         description="A string, one of: [`rest`, `grpc`, `grpc_asyncio`].",
     )
     request_options: Optional[Dict] = Field(
-        None,
+        default=None,
         description="A dictionary of request options to pass to the Google API client."
         "Example: `{'timeout': 10}`",
     )

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

@@ -149,18 +149,18 @@ Supported examples:
     """The maximum number of seconds to wait for a response."""
 
     client_options: Optional[Dict] = Field(
-        None,
+        default=None,
         description=(
             "A dictionary of client options to pass to the Google API client, "
             "such as `api_endpoint`."
         ),
     )
     transport: Optional[str] = Field(
-        None,
+        default=None,
         description="A string, one of: [`rest`, `grpc`, `grpc_asyncio`].",
     )
     additional_headers: Optional[Dict[str, str]] = Field(
-        None,
+        default=None,
         description=(
             "A key-value dictionary representing additional headers for the model call"
         ),
@@ -212,7 +212,7 @@ class GoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseLLM):
             llm = GoogleGenerativeAI(model="gemini-pro")
     """
 
-    client: Any  #: :meta private:
+    client: Any = None  #: :meta private:
 
     @root_validator()
     def validate_environment(cls, values: Dict) -> Dict:

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langchain-google-genai"
-version = "1.0.7"
+version = "1.0.8"
 description = "An integration package connecting Google's genai package and LangChain"
 authors = []
 readme = "README.md"
@@ -12,7 +12,7 @@ license = "MIT"
 
 [tool.poetry.dependencies]
 python = ">=3.9,<4.0"
-langchain-core = ">=0.2.9,<0.3"
+langchain-core = ">=0.2.17,<0.3"
 google-generativeai = "^0.7.0"
 pillow = { version = "^10.1.0", optional = true }
 
@@ -31,6 +31,7 @@ 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" }
+langchain-standard-tests = { git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/standard-tests" }
 
 [tool.codespell]
 ignore-words-list = "rouge"

langchain_google_genai-1.0.7/langchain_google_genai/_function_utils.py

@@ -1,340 +0,0 @@
-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,
-        }
-    )