google-adk 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

google/adk/tools/load_artifacts_tool.py

@@ -0,0 +1,113 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import json
+from typing import Any
+from typing import TYPE_CHECKING
+
+from google.genai import types
+from typing_extensions import override
+
+from .base_tool import BaseTool
+
+if TYPE_CHECKING:
+  from ..models.llm_request import LlmRequest
+  from .tool_context import ToolContext
+
+
+class LoadArtifactsTool(BaseTool):
+  """A tool that loads the artifacts and adds them to the session."""
+
+  def __init__(self):
+    super().__init__(
+        name='load_artifacts',
+        description='Loads the artifacts and adds them to the session.',
+    )
+
+  def _get_declaration(self) -> types.FunctionDeclaration | None:
+    return types.FunctionDeclaration(
+        name=self.name,
+        description=self.description,
+        parameters=types.Schema(
+            type=types.Type.OBJECT,
+            properties={
+                'artifact_names': types.Schema(
+                    type=types.Type.ARRAY,
+                    items=types.Schema(
+                        type=types.Type.STRING,
+                    ),
+                )
+            },
+        ),
+    )
+
+  @override
+  async def run_async(
+      self, *, args: dict[str, Any], tool_context: ToolContext
+  ) -> Any:
+    artifact_names: list[str] = args.get('artifact_names', [])
+    return {'artifact_names': artifact_names}
+
+  @override
+  async def process_llm_request(
+      self, *, tool_context: ToolContext, llm_request: LlmRequest
+  ) -> None:
+    await super().process_llm_request(
+        tool_context=tool_context,
+        llm_request=llm_request,
+    )
+    self._append_artifacts_to_llm_request(
+        tool_context=tool_context, llm_request=llm_request
+    )
+
+  def _append_artifacts_to_llm_request(
+      self, *, tool_context: ToolContext, llm_request: LlmRequest
+  ):
+    artifact_names = tool_context.list_artifacts()
+    if not artifact_names:
+      return
+
+    # Tell the model about the available artifacts.
+    llm_request.append_instructions([f"""You have a list of artifacts:
+  {json.dumps(artifact_names)}
+
+  When the user asks questions about any of the artifacts, you should call the
+  `load_artifacts` function to load the artifact. Do not generate any text other
+  than the function call.
+  """])
+
+    # Attache the content of the artifacts if the model requests them.
+    # This only adds the content to the model request, instead of the session.
+    if llm_request.contents and llm_request.contents[-1].parts:
+      function_response = llm_request.contents[-1].parts[0].function_response
+      if function_response and function_response.name == 'load_artifacts':
+        artifact_names = function_response.response['artifact_names']
+        for artifact_name in artifact_names:
+          artifact = tool_context.load_artifact(artifact_name)
+          llm_request.contents.append(
+              types.Content(
+                  role='user',
+                  parts=[
+                      types.Part.from_text(
+                          text=f'Artifact {artifact_name} is:'
+                      ),
+                      artifact,
+                  ],
+              )
+          )
+
+
+load_artifacts_tool = LoadArtifactsTool()

google/adk/tools/load_memory_tool.py

@@ -0,0 +1,58 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import override
+
+from .function_tool import FunctionTool
+from .tool_context import ToolContext
+
+if TYPE_CHECKING:
+  from ..models import LlmRequest
+  from ..memory.base_memory_service import MemoryResult
+
+
+def load_memory(query: str, tool_context: ToolContext) -> 'list[MemoryResult]':
+  """Loads the memory for the current user."""
+  response = tool_context.search_memory(query)
+  return response.memories
+
+
+class LoadMemoryTool(FunctionTool):
+  """A tool that loads the memory for the current user."""
+
+  def __init__(self):
+    super().__init__(load_memory)
+
+  @override
+  async def process_llm_request(
+      self,
+      *,
+      tool_context: ToolContext,
+      llm_request: LlmRequest,
+  ) -> None:
+    await super().process_llm_request(
+        tool_context=tool_context, llm_request=llm_request
+    )
+    # Tell the model about the memory.
+    llm_request.append_instructions(["""
+You have memory. You can use it to answer questions. If any questions need
+you to look up the memory, you should call load_memory function with a query.
+"""])
+
+
+load_memory_tool = LoadMemoryTool()

google/adk/tools/load_web_page.py

@@ -0,0 +1,41 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Tool for web browse."""
+
+import requests
+
+
+def load_web_page(url: str) -> str:
+  """Fetches the content in the url and returns the text in it.
+
+  Args:
+      url (str): The url to browse.
+
+  Returns:
+      str: The text content of the url.
+  """
+  from bs4 import BeautifulSoup
+
+  response = requests.get(url)
+
+  if response.status_code == 200:
+    soup = BeautifulSoup(response.content, 'lxml')
+    text = soup.get_text(separator='\n', strip=True)
+  else:
+    text = f'Failed to fetch url: {url}'
+
+  # Split the text into lines, filtering out very short lines
+  # (e.g., single words or short subtitles)
+  return '\n'.join(line for line in text.splitlines() if len(line.split()) > 3)

google/adk/tools/long_running_tool.py

@@ -0,0 +1,39 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Callable
+
+from .function_tool import FunctionTool
+
+
+class LongRunningFunctionTool(FunctionTool):
+  """A function tool that returns the result asynchronously.
+
+  This tool is used for long-running operations that may take a significant
+  amount of time to complete. The framework will call the function. Once the
+  function returns, the response will be returned asynchronously to the
+  framework which is identified by the function_call_id.
+
+  Example:
+  ```python
+  tool = LongRunningFunctionTool(a_long_running_function)
+  ```
+
+  Attributes:
+    is_long_running: Whether the tool is a long running operation.
+  """
+
+  def __init__(self, func: Callable):
+    super().__init__(func)
+    self.is_long_running = True

google/adk/tools/mcp_tool/__init__.py

@@ -0,0 +1,42 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+__all__ = []
+
+try:
+  from .conversion_utils import adk_to_mcp_tool_type, gemini_to_json_schema
+  from .mcp_tool import MCPTool
+  from .mcp_toolset import MCPToolset
+
+  __all__.extend([
+      'adk_to_mcp_tool_type',
+      'gemini_to_json_schema',
+      'MCPTool',
+      'MCPToolset',
+  ])
+
+except ImportError as e:
+  import logging
+  import sys
+
+  logger = logging.getLogger(__name__)
+
+  if sys.version_info < (3, 10):
+    logger.warning(
+        'MCP Tool requires Python 3.10 or above. Please upgrade your Python'
+        ' version.'
+    )
+  else:
+    logger.debug('MCP Tool is not installed')
+    logger.debug(e)

google/adk/tools/mcp_tool/conversion_utils.py

@@ -0,0 +1,161 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any, Dict
+from google.genai.types import Schema, Type
+import mcp.types as mcp_types
+from ..base_tool import BaseTool
+
+
+def adk_to_mcp_tool_type(tool: BaseTool) -> mcp_types.Tool:
+  """Convert a Tool in ADK into MCP tool type.
+
+  This function transforms an ADK tool definition into its equivalent
+  representation in the MCP (Model Control Plane) system.
+
+  Args:
+      tool: The ADK tool to convert. It should be an instance of a class derived
+        from `BaseTool`.
+
+  Returns:
+      An object of MCP Tool type, representing the converted tool.
+
+  Examples:
+      # Assuming 'my_tool' is an instance of a BaseTool derived class
+      mcp_tool = adk_to_mcp_tool_type(my_tool)
+      print(mcp_tool)
+  """
+  tool_declaration = tool._get_declaration()
+  if not tool_declaration:
+    input_schema = {}
+  else:
+    input_schema = gemini_to_json_schema(tool._get_declaration().parameters)
+  return mcp_types.Tool(
+      name=tool.name,
+      description=tool.description,
+      inputSchema=input_schema,
+  )
+
+
+def gemini_to_json_schema(gemini_schema: Schema) -> Dict[str, Any]:
+  """Converts a Gemini Schema object into a JSON Schema dictionary.
+
+  Args:
+      gemini_schema: An instance of the Gemini Schema class.
+
+  Returns:
+      A dictionary representing the equivalent JSON Schema.
+
+  Raises:
+      TypeError: If the input is not an instance of the expected Schema class.
+      ValueError: If an invalid Gemini Type enum value is encountered.
+  """
+  if not isinstance(gemini_schema, Schema):
+    raise TypeError(
+        f"Input must be an instance of Schema, got {type(gemini_schema)}"
+    )
+
+  json_schema_dict: Dict[str, Any] = {}
+
+  # Map Type
+  gemini_type = getattr(gemini_schema, "type", None)
+  if gemini_type and gemini_type != Type.TYPE_UNSPECIFIED:
+    json_schema_dict["type"] = gemini_type.lower()
+  else:
+    json_schema_dict["type"] = "null"
+
+  # Map Nullable
+  if getattr(gemini_schema, "nullable", None) == True:
+    json_schema_dict["nullable"] = True
+
+  # --- Map direct fields ---
+  direct_mappings = {
+      "title": "title",
+      "description": "description",
+      "default": "default",
+      "enum": "enum",
+      "format": "format",
+      "example": "example",
+  }
+  for gemini_key, json_key in direct_mappings.items():
+    value = getattr(gemini_schema, gemini_key, None)
+    if value is not None:
+      json_schema_dict[json_key] = value
+
+  # String validation
+  if gemini_type == Type.STRING:
+    str_mappings = {
+        "pattern": "pattern",
+        "min_length": "minLength",
+        "max_length": "maxLength",
+    }
+    for gemini_key, json_key in str_mappings.items():
+      value = getattr(gemini_schema, gemini_key, None)
+      if value is not None:
+        json_schema_dict[json_key] = value
+
+  # Number/Integer validation
+  if gemini_type in (Type.NUMBER, Type.INTEGER):
+    num_mappings = {
+        "minimum": "minimum",
+        "maximum": "maximum",
+    }
+    for gemini_key, json_key in num_mappings.items():
+      value = getattr(gemini_schema, gemini_key, None)
+      if value is not None:
+        json_schema_dict[json_key] = value
+
+  # Array validation (Recursive call for items)
+  if gemini_type == Type.ARRAY:
+    items_schema = getattr(gemini_schema, "items", None)
+    if items_schema is not None:
+      json_schema_dict["items"] = gemini_to_json_schema(items_schema)
+
+    arr_mappings = {
+        "min_items": "minItems",
+        "max_items": "maxItems",
+    }
+    for gemini_key, json_key in arr_mappings.items():
+      value = getattr(gemini_schema, gemini_key, None)
+      if value is not None:
+        json_schema_dict[json_key] = value
+
+  # Object validation (Recursive call for properties)
+  if gemini_type == Type.OBJECT:
+    properties_dict = getattr(gemini_schema, "properties", None)
+    if properties_dict is not None:
+      json_schema_dict["properties"] = {
+          prop_name: gemini_to_json_schema(prop_schema)
+          for prop_name, prop_schema in properties_dict.items()
+      }
+
+    obj_mappings = {
+        "required": "required",
+        "min_properties": "minProperties",
+        "max_properties": "maxProperties",
+        # Note: Ignoring 'property_ordering' as it's not standard JSON Schema
+    }
+    for gemini_key, json_key in obj_mappings.items():
+      value = getattr(gemini_schema, gemini_key, None)
+      if value is not None:
+        json_schema_dict[json_key] = value
+
+  # Map anyOf (Recursive call for subschemas)
+  any_of_list = getattr(gemini_schema, "any_of", None)
+  if any_of_list is not None:
+    json_schema_dict["anyOf"] = [
+        gemini_to_json_schema(sub_schema) for sub_schema in any_of_list
+    ]
+
+  return json_schema_dict

google/adk/tools/mcp_tool/mcp_tool.py

@@ -0,0 +1,113 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional
+
+from google.genai.types import FunctionDeclaration
+from typing_extensions import override
+
+# Attempt to import MCP Tool from the MCP library, and hints user to upgrade
+# their Python version to 3.10 if it fails.
+try:
+  from mcp import ClientSession
+  from mcp.types import Tool as McpBaseTool
+except ImportError as e:
+  import sys
+
+  if sys.version_info < (3, 10):
+    raise ImportError(
+        "MCP Tool requires Python 3.10 or above. Please upgrade your Python"
+        " version."
+    ) from e
+  else:
+    raise e
+
+from ..base_tool import BaseTool
+from ...auth.auth_credential import AuthCredential
+from ...auth.auth_schemes import AuthScheme
+from ..openapi_tool.openapi_spec_parser.rest_api_tool import to_gemini_schema
+from ..tool_context import ToolContext
+
+
+class MCPTool(BaseTool):
+  """Turns a MCP Tool into a Vertex Agent Framework Tool.
+
+  Internally, the tool initializes from a MCP Tool, and uses the MCP Session to
+  call the tool.
+  """
+
+  def __init__(
+      self,
+      mcp_tool: McpBaseTool,
+      mcp_session: ClientSession,
+      auth_scheme: Optional[AuthScheme] = None,
+      auth_credential: Optional[AuthCredential] | None = None,
+  ):
+    """Initializes a MCPTool.
+
+    This tool wraps a MCP Tool interface and an active MCP Session. It invokes
+    the MCP Tool through executing the tool from remote MCP Session.
+
+    Example:
+        tool = MCPTool(mcp_tool=mcp_tool, mcp_session=mcp_session)
+
+    Args:
+        mcp_tool: The MCP tool to wrap.
+        mcp_session: The MCP session to use to call the tool.
+        auth_scheme: The authentication scheme to use.
+        auth_credential: The authentication credential to use.
+
+    Raises:
+        ValueError: If mcp_tool or mcp_session is None.
+    """
+    if mcp_tool is None:
+      raise ValueError("mcp_tool cannot be None")
+    if mcp_session is None:
+      raise ValueError("mcp_session cannot be None")
+    self.name = mcp_tool.name
+    self.description = mcp_tool.description if mcp_tool.description else ""
+    self.mcp_tool = mcp_tool
+    self.mcp_session = mcp_session
+    # TODO(cheliu): Support passing auth to MCP Server.
+    self.auth_scheme = auth_scheme
+    self.auth_credential = auth_credential
+
+  @override
+  def _get_declaration(self) -> FunctionDeclaration:
+    """Gets the function declaration for the tool.
+
+    Returns:
+        FunctionDeclaration: The Gemini function declaration for the tool.
+    """
+    schema_dict = self.mcp_tool.inputSchema
+    parameters = to_gemini_schema(schema_dict)
+    function_decl = FunctionDeclaration(
+        name=self.name, description=self.description, parameters=parameters
+    )
+    return function_decl
+
+  @override
+  async def run_async(self, *, args, tool_context: ToolContext):
+    """Runs the tool asynchronously.
+
+    Args:
+        args: The arguments as a dict to pass to the tool.
+        tool_context: The tool context from upper level ADK agent.
+
+    Returns:
+        Any: The response from the tool.
+    """
+    # TODO(cheliu): Support passing tool context to MCP Server.
+    response = await self.mcp_session.call_tool(self.name, arguments=args)
+    return response