langchain-google-genai 1.0.2__tar.gz → 1.0.3__tar.gz

{langchain_google_genai-1.0.2 → langchain_google_genai-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-google-genai
-Version: 1.0.2
+Version: 1.0.3
 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.0,<0.6.0)
-Requires-Dist: langchain-core (>=0.1.27,<0.2)
+Requires-Dist: google-generativeai (>=0.5.2,<0.6.0)
+Requires-Dist: langchain-core (>=0.1.45,<0.2)
 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.3/langchain_google_genai/_function_utils.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+from typing import (
+    Any,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Sequence,
+    Type,
+    TypedDict,
+    Union,
+)
+
+import google.ai.generativelanguage as glm
+from google.generativeai.types import Tool as GoogleTool  # type: ignore[import]
+from google.generativeai.types.content_types import (  # type: ignore[import]
+    FunctionCallingConfigType,
+    FunctionDeclarationType,
+    ToolDict,
+    ToolType,
+)
+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()}
+
+
+def convert_to_genai_function_declarations(
+    tool: Union[
+        GoogleTool, ToolDict, FunctionDeclarationType, Sequence[FunctionDeclarationType]
+    ],
+) -> ToolType:
+    """Convert any tool-like object to a ToolType.
+
+    https://github.com/google-gemini/generative-ai-python/blob/668695ebe3e9de496a36eeb95cb2ed2faba9b939/google/generativeai/types/content_types.py#L574
+    """
+    if isinstance(tool, GoogleTool):
+        return tool
+    # check whether a dict is supported by glm, otherwise we parse it explicitly
+    if isinstance(tool, dict):
+        first_function_declaration = tool.get("function_declarations", [None])[0]
+        if isinstance(first_function_declaration, glm.FunctionDeclaration):
+            return tool
+        schema = None
+        try:
+            schema = first_function_declaration.parameters
+        except AttributeError:
+            pass
+        if schema is None:
+            schema = first_function_declaration.get("parameters")
+        if schema is None or isinstance(schema, glm.Schema):
+            return tool
+        return glm.Tool(
+            function_declarations=[
+                _convert_to_genai_function(fc) for fc in tool["function_declarations"]
+            ],
+        )
+    elif isinstance(tool, type) and issubclass(tool, BaseModel):
+        return glm.Tool(function_declarations=[_convert_to_genai_function(tool)])
+    elif callable(tool):
+        return _convert_tool_to_genai_function(callable_as_lc_tool()(tool))
+    elif isinstance(tool, list):
+        return glm.Tool(
+            function_declarations=[_convert_to_genai_function(fc) for fc in tool]
+        )
+    return glm.Tool(function_declarations=[_convert_to_genai_function(tool)])
+
+
+def tool_to_dict(tool: Union[glm.Tool, GoogleTool]) -> ToolDict:
+    if isinstance(tool, GoogleTool):
+        tool = tool._proto
+    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: FunctionDeclarationType) -> glm.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):
+        return glm.FunctionDeclaration(
+            name=fc["name"],
+            description=fc.get("description"),
+            parameters={
+                "properties": {
+                    k: {
+                        "type_": TYPE_ENUM[v["type"]],
+                        "description": v.get("description"),
+                    }
+                    for k, v in fc["parameters"]["properties"].items()
+                },
+                "required": fc["parameters"].get("required", []),
+                "type_": TYPE_ENUM[fc["parameters"]["type"]],
+            },
+        )
+    else:
+        raise ValueError(f"Unsupported function call type {fc}")
+
+
+def _convert_tool_to_genai_function(tool: BaseTool) -> glm.FunctionDeclaration:
+    if tool.args_schema:
+        schema = dereference_refs(tool.args_schema.schema())
+        schema.pop("definitions", None)
+        return glm.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 glm.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],
+) -> glm.FunctionDeclaration:
+    schema = dereference_refs(pydantic_model.schema())
+    schema.pop("definitions", None)
+    return glm.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 _ToolConfigDict(TypedDict):
+    function_calling_config: FunctionCallingConfigType
+
+
+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.2 → langchain_google_genai-1.0.3}/langchain_google_genai/chat_models.py

@@ -4,6 +4,7 @@ import base64
 import json
 import logging
 import os
+import uuid
 import warnings
 from io import BytesIO
 from typing import (
@@ -29,10 +30,17 @@ import google.api_core
 import google.generativeai as genai  # type: ignore[import]
 import proto  # type: ignore[import]
 import requests
+from google.generativeai.types import SafetySettingDict  # type: ignore[import]
+from google.generativeai.types import Tool as GoogleTool  # type: ignore[import]
+from google.generativeai.types.content_types import (  # type: ignore[import]
+    FunctionDeclarationType,
+    ToolDict,
+)
 from langchain_core.callbacks.manager import (
     AsyncCallbackManagerForLLMRun,
     CallbackManagerForLLMRun,
 )
+from langchain_core.language_models import LanguageModelInput
 from langchain_core.language_models.chat_models import BaseChatModel
 from langchain_core.messages import (
     AIMessage,
@@ -40,10 +48,16 @@ from langchain_core.messages import (
     BaseMessage,
     FunctionMessage,
     HumanMessage,
+    InvalidToolCall,
     SystemMessage,
+    ToolCall,
+    ToolCallChunk,
+    ToolMessage,
 )
+from langchain_core.output_parsers.openai_tools import parse_tool_calls
 from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult
 from langchain_core.pydantic_v1 import SecretStr, root_validator
+from langchain_core.runnables import Runnable
 from langchain_core.utils import get_from_dict_or_env
 from tenacity import (
     before_sleep_log,
@@ -55,7 +69,11 @@ from tenacity import (
 
 from langchain_google_genai._common import GoogleGenerativeAIError
 from langchain_google_genai._function_utils import (
+    _tool_choice_to_tool_config,
+    _ToolChoiceType,
+    _ToolConfigDict,
     convert_to_genai_function_declarations,
+    tool_to_dict,
 )
 from langchain_google_genai.llms import GoogleModelFamily, _BaseGoogleGenerativeAI
 
@@ -350,6 +368,40 @@ def _parse_chat_history(
                     )
                 )
             ]
+        elif isinstance(message, ToolMessage):
+            role = "user"
+            prev_message: Optional[BaseMessage] = (
+                input_messages[i - 1] if i > 0 else None
+            )
+            if (
+                prev_message
+                and isinstance(prev_message, AIMessage)
+                and prev_message.tool_calls
+            ):
+                # message.name can be null for ToolMessage
+                name: str = prev_message.tool_calls[0]["name"]
+            else:
+                name = message.name  # type: ignore
+            tool_response: Any
+            if not isinstance(message.content, str):
+                tool_response = message.content
+            else:
+                try:
+                    tool_response = json.loads(message.content)
+                except json.JSONDecodeError:
+                    tool_response = message.content  # leave as str representation
+            parts = [
+                glm.Part(
+                    function_response=glm.FunctionResponse(
+                        name=name,
+                        response=(
+                            {"output": tool_response}
+                            if not isinstance(tool_response, dict)
+                            else tool_response
+                        ),
+                    )
+                )
+            ]
         else:
             raise ValueError(
                 f"Unexpected message with type {type(message)} at the position {i}."
@@ -360,24 +412,89 @@ def _parse_chat_history(
 
 
 def _parse_response_candidate(
-    response_candidate: glm.Candidate, stream: bool
+    response_candidate: glm.Candidate, streaming: bool = False
 ) -> AIMessage:
-    first_part = response_candidate.content.parts[0]
-    if first_part.function_call:
-        function_call = proto.Message.to_dict(first_part.function_call)
-        function_call["arguments"] = json.dumps(function_call.pop("args", {}))
-        return (AIMessageChunk if stream else AIMessage)(
-            content="", additional_kwargs={"function_call": function_call}
+    content: Union[None, str, List[str]] = None
+    additional_kwargs = {}
+    tool_calls = []
+    invalid_tool_calls = []
+    tool_call_chunks = []
+
+    for part in response_candidate.content.parts:
+        try:
+            text: Optional[str] = part.text
+        except AttributeError:
+            text = None
+
+        if text is not None:
+            if not content:
+                content = text
+            elif isinstance(content, str) and text:
+                content = [content, text]
+            elif isinstance(content, list) and text:
+                content.append(text)
+            elif text:
+                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"]
+            function_call["arguments"] = json.dumps(
+                {k: function_call_args_dict[k] for k in function_call_args_dict}
+            )
+            additional_kwargs["function_call"] = function_call
+
+            if streaming:
+                tool_call_chunks.append(
+                    ToolCallChunk(
+                        name=function_call.get("name"),
+                        args=function_call.get("arguments"),
+                        id=function_call.get("id", str(uuid.uuid4())),
+                        index=function_call.get("index"),  # type: ignore
+                    )
+                )
+            else:
+                try:
+                    tool_calls_dicts = 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
+                    ]
+                except Exception as e:
+                    invalid_tool_calls = [
+                        InvalidToolCall(
+                            name=function_call.get("name"),
+                            args=function_call.get("arguments"),
+                            id=function_call.get("id", str(uuid.uuid4())),
+                            error=str(e),
+                        )
+                    ]
+    if content is None:
+        content = ""
+
+    if streaming:
+        return AIMessageChunk(
+            content=cast(Union[str, List[Union[str, Dict[Any, Any]]]], content),
+            additional_kwargs=additional_kwargs,
+            tool_call_chunks=tool_call_chunks,
         )
-    else:
-        parts = response_candidate.content.parts
-
-    if len(parts) == 1 and parts[0].text:
-        content: Union[str, List[Union[str, Dict]]] = parts[0].text
-    else:
-        content = [proto.Message.to_dict(part) for part in parts]
-    return (AIMessageChunk if stream else AIMessage)(
-        content=content, additional_kwargs={}
+
+    return AIMessage(
+        content=cast(Union[str, List[Union[str, Dict[Any, Any]]]], content),
+        additional_kwargs=additional_kwargs,
+        tool_calls=tool_calls,
+        invalid_tool_calls=invalid_tool_calls,
     )
 
 
@@ -400,7 +517,7 @@ def _response_to_result(
         ]
         generations.append(
             (ChatGenerationChunk if stream else ChatGeneration)(
-                message=_parse_response_candidate(candidate, stream=stream),
+                message=_parse_response_candidate(candidate, streaming=stream),
                 generation_info=generation_info,
             )
         )
@@ -627,20 +744,29 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         self,
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
+        tools: Optional[Sequence[Union[ToolDict, GoogleTool]]] = None,
+        functions: Optional[Sequence[FunctionDeclarationType]] = None,
+        safety_settings: Optional[SafetySettingDict] = None,
+        tool_config: Optional[Union[Dict, _ToolConfigDict]] = None,
         **kwargs: Any,
     ) -> Tuple[Dict[str, Any], genai.ChatSession, genai.types.ContentDict]:
         client = self.client
-        functions = kwargs.pop("functions", None)
-        safety_settings = kwargs.pop("safety_settings", self.safety_settings)
-        if functions or safety_settings:
-            tools = (
-                convert_to_genai_function_declarations(functions) if functions else None
-            )
+        formatted_tools = None
+        if tools:
+            formatted_tools = [
+                convert_to_genai_function_declarations(tool) for tool in tools
+            ]
+        elif functions:
+            formatted_tools = [convert_to_genai_function_declarations(functions)]
+
+        if formatted_tools or safety_settings:
             client = genai.GenerativeModel(
-                model_name=self.model, tools=tools, safety_settings=safety_settings
+                model_name=self.model,
+                tools=formatted_tools,
+                safety_settings=safety_settings,
             )
 
-        params = self._prepare_params(stop, **kwargs)
+        params = self._prepare_params(stop, tool_config=tool_config, **kwargs)
         system_instruction, history = _parse_chat_history(
             messages,
             convert_system_message_to_human=self.convert_system_message_to_human,
@@ -672,3 +798,37 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             token_count = result["token_count"]
 
         return token_count
+
+    def bind_tools(
+        self,
+        tools: Sequence[Union[ToolDict, GoogleTool]],
+        tool_config: Optional[Union[Dict, _ToolConfigDict]] = None,
+        *,
+        tool_choice: Optional[Union[_ToolChoiceType, bool]] = None,
+        **kwargs: Any,
+    ) -> Runnable[LanguageModelInput, BaseMessage]:
+        """Bind tool-like objects to this chat model.
+
+        Assumes model is compatible with google-generativeAI tool-calling API.
+
+        Args:
+            tools: A list of tool definitions to bind to this chat model.
+                Can be a pydantic model, callable, or BaseTool. Pydantic
+                models, callables, and BaseTools will be automatically converted to
+                their schema dictionary representation.
+            **kwargs: Any additional parameters to pass to the
+                :class:`~langchain.runnable.Runnable` constructor.
+        """
+        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=}"
+            )
+        # Bind dicts for easier serialization/deserialization.
+        genai_tools = [tool_to_dict(convert_to_genai_function_declarations(tools))]
+        if tool_choice:
+            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)

{langchain_google_genai-1.0.2 → langchain_google_genai-1.0.3}/langchain_google_genai/embeddings.py

@@ -61,6 +61,11 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
         None,
         description="A string, one of: [`rest`, `grpc`, `grpc_asyncio`].",
     )
+    request_options: Optional[Dict] = Field(
+        None,
+        description="A dictionary of request options to pass to the Google API client."
+        "Example: `{'timeout': 10}`",
+    )
 
     @root_validator()
     def validate_environment(cls, values: Dict) -> Dict:
@@ -95,6 +100,7 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
                 content=texts,
                 task_type=task_type,
                 title=title,
+                request_options=self.request_options,
             )
         except Exception as e:
             raise GoogleGenerativeAIError(f"Error embedding content: {e}") from e

{langchain_google_genai-1.0.2 → langchain_google_genai-1.0.3}/langchain_google_genai/llms.py

@@ -86,6 +86,7 @@ def _completion_with_retry(
                     stream=stream,
                     generation_config=generation_config,
                     safety_settings=kwargs.pop("safety_settings", None),
+                    request_options={"timeout": llm.timeout} if llm.timeout else None,
                 )
             return llm.client.generate_text(prompt=prompt, **kwargs)
         except google.api_core.exceptions.FailedPrecondition as exc:
@@ -143,6 +144,10 @@ Supported examples:
        not return the full n completions if duplicates are generated."""
     max_retries: int = 6
     """The maximum number of retries to make when generating."""
+
+    timeout: Optional[float] = None
+    """The maximum number of seconds to wait for a response."""
+
     client_options: Optional[Dict] = Field(
         None,
         description=(
@@ -259,6 +264,9 @@ class GoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseLLM):
         if values["max_output_tokens"] is not None and values["max_output_tokens"] <= 0:
             raise ValueError("max_output_tokens must be greater than zero")
 
+        if values["timeout"] is not None and values["timeout"] <= 0:
+            raise ValueError("timeout must be greater than zero")
+
         return values
 
     def _generate(

{langchain_google_genai-1.0.2 → langchain_google_genai-1.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langchain-google-genai"
-version = "1.0.2"
+version = "1.0.3"
 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.1.27,<0.2"
-google-generativeai = "^0.5.0"
+langchain-core = ">=0.1.45,<0.2"
+google-generativeai = "^0.5.2"
 pillow = { version = "^10.1.0", optional = true }
 
 [tool.poetry.extras]
@@ -96,7 +96,7 @@ build-backend = "poetry.core.masonry.api"
 #
 # https://github.com/tophat/syrupy
 # --snapshot-warn-unused    Prints a warning on unused snapshots rather than fail the test suite.
-addopts = "--snapshot-warn-unused --strict-markers --strict-config --durations=5"
+#addopts = "--snapshot-warn-unused --strict-markers --strict-config --durations=5"
 # Registering custom markers.
 # https://docs.pytest.org/en/7.1.x/example/markers.html#registering-markers
 markers = [

langchain_google_genai-1.0.2/langchain_google_genai/_function_utils.py

@@ -1,116 +0,0 @@
-from __future__ import annotations
-
-from typing import (
-    Dict,
-    List,
-    Type,
-    Union,
-)
-
-import google.ai.generativelanguage as glm
-from langchain_core.pydantic_v1 import BaseModel
-from langchain_core.tools import BaseTool
-from langchain_core.utils.json_schema import dereference_refs
-
-FunctionCallType = Union[BaseTool, Type[BaseModel], Dict]
-
-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,
-}
-
-
-def convert_to_genai_function_declarations(
-    function_calls: List[FunctionCallType],
-) -> List[glm.Tool]:
-    return [
-        glm.Tool(
-            function_declarations=[_convert_to_genai_function(fc)],
-        )
-        for fc in function_calls
-    ]
-
-
-def _convert_to_genai_function(fc: FunctionCallType) -> glm.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 isinstance(fc, dict):
-        return glm.FunctionDeclaration(
-            name=fc["name"],
-            description=fc.get("description"),
-            parameters={
-                "properties": {
-                    k: {
-                        "type_": TYPE_ENUM[v["type"]],
-                        "description": v.get("description"),
-                    }
-                    for k, v in fc["parameters"]["properties"].items()
-                },
-                "required": fc["parameters"].get("required", []),
-                "type_": TYPE_ENUM[fc["parameters"]["type"]],
-            },
-        )
-    else:
-        raise ValueError(f"Unsupported function call type {fc}")
-
-
-def _convert_tool_to_genai_function(tool: BaseTool) -> glm.FunctionDeclaration:
-    if tool.args_schema:
-        schema = dereference_refs(tool.args_schema.schema())
-        schema.pop("definitions", None)
-
-        return glm.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["required"],
-                "type_": TYPE_ENUM[schema["type"]],
-            },
-        )
-    else:
-        return glm.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],
-) -> glm.FunctionDeclaration:
-    schema = dereference_refs(pydantic_model.schema())
-    schema.pop("definitions", None)
-    return glm.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"]],
-        },
-    )