google-adk 1.5.0__py3-none-any.whl → 1.6.1__py3-none-any.whl

google/adk/tools/bigquery/query_tool.py

@@ -20,10 +20,12 @@ from google.auth.credentials import Credentials
 from google.cloud import bigquery
 
 from . import client
+from ..tool_context import ToolContext
 from .config import BigQueryToolConfig
 from .config import WriteMode
 
 MAX_DOWNLOADED_QUERY_RESULT_ROWS = 50
+BIGQUERY_SESSION_INFO_KEY = "bigquery_session_info"
 
 
 def execute_sql(
@@ -31,14 +33,17 @@ def execute_sql(
     query: str,
     credentials: Credentials,
     config: BigQueryToolConfig,
+    tool_context: ToolContext,
 ) -> dict:
-  """Run a BigQuery SQL query in the project and return the result.
+  """Run a BigQuery or BigQuery ML SQL query in the project and return the result.
 
   Args:
       project_id (str): The GCP project id in which the query should be
         executed.
       query (str): The BigQuery SQL query to be executed.
       credentials (Credentials): The credentials to use for the request.
+      config (BigQueryToolConfig): The configuration for the tool.
+      tool_context (ToolContext): The context for the tool.
 
   Returns:
       dict: Dictionary representing the result of the query.
@@ -49,11 +54,11 @@ def execute_sql(
   Examples:
       Fetch data or insights from a table:
 
-          >>> execute_sql("bigframes-dev",
+          >>> execute_sql("my_project",
           ... "SELECT island, COUNT(*) AS population "
           ... "FROM bigquery-public-data.ml_datasets.penguins GROUP BY island")
           {
-            "status": "ERROR",
+            "status": "SUCCESS",
             "rows": [
                 {
                     "island": "Dream",
@@ -72,23 +77,87 @@ def execute_sql(
   """
 
   try:
+    # Get BigQuery client
     bq_client = client.get_bigquery_client(
         project=project_id, credentials=credentials
     )
+
+    # BigQuery connection properties where applicable
+    bq_connection_properties = None
+
     if not config or config.write_mode == WriteMode.BLOCKED:
-      query_job = bq_client.query(
+      dry_run_query_job = bq_client.query(
           query,
           project=project_id,
           job_config=bigquery.QueryJobConfig(dry_run=True),
       )
-      if query_job.statement_type != "SELECT":
+      if dry_run_query_job.statement_type != "SELECT":
         return {
             "status": "ERROR",
             "error_details": "Read-only mode only supports SELECT statements.",
         }
+    elif config.write_mode == WriteMode.PROTECTED:
+      # In protected write mode, write operation only to a temporary artifact is
+      # allowed. This artifact must have been created in a BigQuery session. In
+      # such a scenario the session info (session id and the anonymous dataset
+      # containing the artifact) is persisted in the tool context.
+      bq_session_info = tool_context.state.get(BIGQUERY_SESSION_INFO_KEY, None)
+      if bq_session_info:
+        bq_session_id, bq_session_dataset_id = bq_session_info
+      else:
+        session_creator_job = bq_client.query(
+            "SELECT 1",
+            project=project_id,
+            job_config=bigquery.QueryJobConfig(
+                dry_run=True, create_session=True
+            ),
+        )
+        bq_session_id = session_creator_job.session_info.session_id
+        bq_session_dataset_id = session_creator_job.destination.dataset_id
+
+        # Remember the BigQuery session info for subsequent queries
+        tool_context.state[BIGQUERY_SESSION_INFO_KEY] = (
+            bq_session_id,
+            bq_session_dataset_id,
+        )
+
+      # Session connection property will be set in the query execution
+      bq_connection_properties = [
+          bigquery.ConnectionProperty("session_id", bq_session_id)
+      ]
+
+      # Check the query type w.r.t. the BigQuery session
+      dry_run_query_job = bq_client.query(
+          query,
+          project=project_id,
+          job_config=bigquery.QueryJobConfig(
+              dry_run=True,
+              connection_properties=bq_connection_properties,
+          ),
+      )
+      if (
+          dry_run_query_job.statement_type != "SELECT"
+          and dry_run_query_job.destination.dataset_id != bq_session_dataset_id
+      ):
+        return {
+            "status": "ERROR",
+            "error_details": (
+                "Protected write mode only supports SELECT statements, or write"
+                " operations in the anonymous dataset of a BigQuery session."
+            ),
+        }
 
+    # Finally execute the query and fetch the result
+    job_config = (
+        bigquery.QueryJobConfig(connection_properties=bq_connection_properties)
+        if bq_connection_properties
+        else None
+    )
     row_iterator = bq_client.query_and_wait(
-        query, project=project_id, max_results=MAX_DOWNLOADED_QUERY_RESULT_ROWS
+        query,
+        job_config=job_config,
+        project=project_id,
+        max_results=MAX_DOWNLOADED_QUERY_RESULT_ROWS,
     )
     rows = [{key: val for key, val in row.items()} for row in row_iterator]
     result = {"status": "SUCCESS", "rows": rows}
@@ -106,9 +175,29 @@ def execute_sql(
 
 
 _execute_sql_write_examples = """
+      Create a table with schema prescribed:
+
+          >>> execute_sql("my_project",
+          ... "CREATE TABLE my_project.my_dataset.my_table "
+          ... "(island STRING, population INT64)")
+          {
+            "status": "SUCCESS",
+            "rows": []
+          }
+
+      Insert data into an existing table:
+
+          >>> execute_sql("my_project",
+          ... "INSERT INTO my_project.my_dataset.my_table (island, population) "
+          ... "VALUES ('Dream', 124), ('Biscoe', 168)")
+          {
+            "status": "SUCCESS",
+            "rows": []
+          }
+
       Create a table from the result of a query:
 
-          >>> execute_sql("bigframes-dev",
+          >>> execute_sql("my_project",
           ... "CREATE TABLE my_project.my_dataset.my_table AS "
           ... "SELECT island, COUNT(*) AS population "
           ... "FROM bigquery-public-data.ml_datasets.penguins GROUP BY island")
@@ -119,7 +208,7 @@ _execute_sql_write_examples = """
 
       Delete a table:
 
-          >>> execute_sql("bigframes-dev",
+          >>> execute_sql("my_project",
           ... "DROP TABLE my_project.my_dataset.my_table")
           {
             "status": "SUCCESS",
@@ -128,7 +217,7 @@ _execute_sql_write_examples = """
 
       Copy a table to another table:
 
-          >>> execute_sql("bigframes-dev",
+          >>> execute_sql("my_project",
           ... "CREATE TABLE my_project.my_dataset.my_table_clone "
           ... "CLONE my_project.my_dataset.my_table")
           {
@@ -139,7 +228,7 @@ _execute_sql_write_examples = """
       Create a snapshot (a lightweight, read-optimized copy) of en existing
       table:
 
-          >>> execute_sql("bigframes-dev",
+          >>> execute_sql("my_project",
           ... "CREATE SNAPSHOT TABLE my_project.my_dataset.my_table_snapshot "
           ... "CLONE my_project.my_dataset.my_table")
           {
@@ -147,12 +236,214 @@ _execute_sql_write_examples = """
             "rows": []
           }
 
+      Create a BigQuery ML linear regression model:
+
+          >>> execute_sql("my_project",
+          ... "CREATE MODEL `my_dataset.my_model` "
+          ... "OPTIONS (model_type='linear_reg', input_label_cols=['body_mass_g']) AS "
+          ... "SELECT * FROM `bigquery-public-data.ml_datasets.penguins` "
+          ... "WHERE body_mass_g IS NOT NULL")
+          {
+            "status": "SUCCESS",
+            "rows": []
+          }
+
+      Evaluate BigQuery ML model:
+
+          >>> execute_sql("my_project",
+          ... "SELECT * FROM ML.EVALUATE(MODEL `my_dataset.my_model`)")
+          {
+            "status": "SUCCESS",
+            "rows": [{'mean_absolute_error': 227.01223667447218,
+                      'mean_squared_error': 81838.15989216768,
+                      'mean_squared_log_error': 0.0050704473735013,
+                      'median_absolute_error': 173.08081641661738,
+                      'r2_score': 0.8723772534253441,
+                      'explained_variance': 0.8723772534253442}]
+          }
+
+      Evaluate BigQuery ML model on custom data:
+
+          >>> execute_sql("my_project",
+          ... "SELECT * FROM ML.EVALUATE(MODEL `my_dataset.my_model`, "
+          ... "(SELECT * FROM `my_dataset.my_table`))")
+          {
+            "status": "SUCCESS",
+            "rows": [{'mean_absolute_error': 227.01223667447218,
+                      'mean_squared_error': 81838.15989216768,
+                      'mean_squared_log_error': 0.0050704473735013,
+                      'median_absolute_error': 173.08081641661738,
+                      'r2_score': 0.8723772534253441,
+                      'explained_variance': 0.8723772534253442}]
+          }
+
+      Predict using BigQuery ML model:
+
+          >>> execute_sql("my_project",
+          ... "SELECT * FROM ML.PREDICT(MODEL `my_dataset.my_model`, "
+          ... "(SELECT * FROM `my_dataset.my_table`))")
+          {
+            "status": "SUCCESS",
+            "rows": [
+                {
+                  "predicted_body_mass_g": "3380.9271650847013",
+                  ...
+                }, {
+                  "predicted_body_mass_g": "3873.6072435386004",
+                  ...
+                },
+                ...
+            ]
+          }
+
+      Delete a BigQuery ML model:
+
+          >>> execute_sql("my_project", "DROP MODEL `my_dataset.my_model`")
+          {
+            "status": "SUCCESS",
+            "rows": []
+          }
+
   Notes:
       - If a destination table already exists, there are a few ways to overwrite
       it:
           - Use "CREATE OR REPLACE TABLE" instead of "CREATE TABLE".
           - First run "DROP TABLE", followed by "CREATE TABLE".
-      - To insert data into a table, use "INSERT INTO" statement.
+      - If a model already exists, there are a few ways to overwrite it:
+          - Use "CREATE OR REPLACE MODEL" instead of "CREATE MODEL".
+          - First run "DROP MODEL", followed by "CREATE MODEL".
+  """
+
+
+_execute_sql_protecetd_write_examples = """
+      Create a temporary table with schema prescribed:
+
+          >>> execute_sql("my_project",
+          ... "CREATE TEMP TABLE my_table (island STRING, population INT64)")
+          {
+            "status": "SUCCESS",
+            "rows": []
+          }
+
+      Insert data into an existing temporary table:
+
+          >>> execute_sql("my_project",
+          ... "INSERT INTO my_table (island, population) "
+          ... "VALUES ('Dream', 124), ('Biscoe', 168)")
+          {
+            "status": "SUCCESS",
+            "rows": []
+          }
+
+      Create a temporary table from the result of a query:
+
+          >>> execute_sql("my_project",
+          ... "CREATE TEMP TABLE my_table AS "
+          ... "SELECT island, COUNT(*) AS population "
+          ... "FROM bigquery-public-data.ml_datasets.penguins GROUP BY island")
+          {
+            "status": "SUCCESS",
+            "rows": []
+          }
+
+      Delete a temporary table:
+
+          >>> execute_sql("my_project", "DROP TABLE my_table")
+          {
+            "status": "SUCCESS",
+            "rows": []
+          }
+
+      Copy a temporary table to another temporary table:
+
+          >>> execute_sql("my_project",
+          ... "CREATE TEMP TABLE my_table_clone CLONE my_table")
+          {
+            "status": "SUCCESS",
+            "rows": []
+          }
+
+      Create a temporary BigQuery ML linear regression model:
+
+          >>> execute_sql("my_project",
+          ... "CREATE TEMP MODEL my_model "
+          ... "OPTIONS (model_type='linear_reg', input_label_cols=['body_mass_g']) AS"
+          ... "SELECT * FROM `bigquery-public-data.ml_datasets.penguins` "
+          ... "WHERE body_mass_g IS NOT NULL")
+          {
+            "status": "SUCCESS",
+            "rows": []
+          }
+
+      Evaluate BigQuery ML model:
+
+          >>> execute_sql("my_project", "SELECT * FROM ML.EVALUATE(MODEL my_model)")
+          {
+            "status": "SUCCESS",
+            "rows": [{'mean_absolute_error': 227.01223667447218,
+                      'mean_squared_error': 81838.15989216768,
+                      'mean_squared_log_error': 0.0050704473735013,
+                      'median_absolute_error': 173.08081641661738,
+                      'r2_score': 0.8723772534253441,
+                      'explained_variance': 0.8723772534253442}]
+          }
+
+      Evaluate BigQuery ML model on custom data:
+
+          >>> execute_sql("my_project",
+          ... "SELECT * FROM ML.EVALUATE(MODEL my_model, "
+          ... "(SELECT * FROM `my_dataset.my_table`))")
+          {
+            "status": "SUCCESS",
+            "rows": [{'mean_absolute_error': 227.01223667447218,
+                      'mean_squared_error': 81838.15989216768,
+                      'mean_squared_log_error': 0.0050704473735013,
+                      'median_absolute_error': 173.08081641661738,
+                      'r2_score': 0.8723772534253441,
+                      'explained_variance': 0.8723772534253442}]
+          }
+
+      Predict using BigQuery ML model:
+
+          >>> execute_sql("my_project",
+          ... "SELECT * FROM ML.PREDICT(MODEL my_model, "
+          ... "(SELECT * FROM `my_dataset.my_table`))")
+          {
+            "status": "SUCCESS",
+            "rows": [
+                {
+                  "predicted_body_mass_g": "3380.9271650847013",
+                  ...
+                }, {
+                  "predicted_body_mass_g": "3873.6072435386004",
+                  ...
+                },
+                ...
+            ]
+          }
+
+      Delete a BigQuery ML model:
+
+          >>> execute_sql("my_project", "DROP MODEL my_model")
+          {
+            "status": "SUCCESS",
+            "rows": []
+          }
+
+  Notes:
+      - If a destination table already exists, there are a few ways to overwrite
+      it:
+          - Use "CREATE OR REPLACE TEMP TABLE" instead of "CREATE TEMP TABLE".
+          - First run "DROP TABLE", followed by "CREATE TEMP TABLE".
+      - Only temporary tables can be created, inserted into or deleted. Please
+      do not try creating a permanent table (non-TEMP table), inserting into or
+      deleting one.
+      - If a destination model already exists, there are a few ways to overwrite
+      it:
+          - Use "CREATE OR REPLACE TEMP MODEL" instead of "CREATE TEMP MODEL".
+          - First run "DROP MODEL", followed by "CREATE TEMP MODEL".
+      - Only temporary models can be created or deleted. Please do not try
+      creating a permanent model (non-TEMP model) or deleting one.
   """
 
 
@@ -189,6 +480,9 @@ def get_execute_sql(config: BigQueryToolConfig) -> Callable[..., dict]:
   functools.update_wrapper(execute_sql_wrapper, execute_sql)
 
   # Now, set the new docstring
-  execute_sql_wrapper.__doc__ += _execute_sql_write_examples
+  if config.write_mode == WriteMode.PROTECTED:
+    execute_sql_wrapper.__doc__ += _execute_sql_protecetd_write_examples
+  else:
+    execute_sql_wrapper.__doc__ += _execute_sql_write_examples
 
   return execute_sql_wrapper

google/adk/tools/enterprise_search_tool.py

@@ -47,8 +47,8 @@ class EnterpriseWebSearchTool(BaseTool):
       tool_context: ToolContext,
       llm_request: LlmRequest,
   ) -> None:
-    if llm_request.model and llm_request.model.startswith('gemini-'):
-      if llm_request.model.startswith('gemini-1') and llm_request.config.tools:
+    if llm_request.model and 'gemini-' in llm_request.model:
+      if 'gemini-1' in llm_request.model and llm_request.config.tools:
         raise ValueError(
             'Enterprise web search tool can not be used with other tools in'
             ' Gemini 1.x.'

google/adk/tools/function_tool.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import inspect
 from typing import Any
 from typing import Callable
@@ -79,9 +81,13 @@ class FunctionTool(BaseTool):
   ) -> Any:
     args_to_call = args.copy()
     signature = inspect.signature(self.func)
-    if 'tool_context' in signature.parameters:
+    valid_params = {param for param in signature.parameters}
+    if 'tool_context' in valid_params:
       args_to_call['tool_context'] = tool_context
 
+    # Filter args_to_call to only include valid parameters for the function
+    args_to_call = {k: v for k, v in args_to_call.items() if k in valid_params}
+
     # Before invoking the function, we check for if the list of args passed in
     # has all the mandatory arguments or not.
     # If the check fails, then we don't invoke the tool and let the Agent know

google/adk/tools/google_search_tool.py

@@ -54,7 +54,7 @@ class GoogleSearchTool(BaseTool):
       llm_request.config.tools.append(
           types.Tool(google_search_retrieval=types.GoogleSearchRetrieval())
       )
-    elif llm_request.model and 'gemini-2' in llm_request.model:
+    elif llm_request.model and 'gemini-' in llm_request.model:
       llm_request.config.tools.append(
           types.Tool(google_search=types.GoogleSearch())
       )

google/adk/tools/mcp_tool/mcp_session_manager.py

@@ -251,6 +251,49 @@ class MCPSessionManager:
     """
     return session._read_stream._closed or session._write_stream._closed
 
+  def _create_client(self, merged_headers: Optional[Dict[str, str]] = None):
+    """Creates an MCP client based on the connection parameters.
+
+    Args:
+        merged_headers: Optional headers to include in the connection.
+                       Only applicable for SSE and StreamableHTTP connections.
+
+    Returns:
+        The appropriate MCP client instance.
+
+    Raises:
+        ValueError: If the connection parameters are not supported.
+    """
+    if isinstance(self._connection_params, StdioConnectionParams):
+      client = stdio_client(
+          server=self._connection_params.server_params,
+          errlog=self._errlog,
+      )
+    elif isinstance(self._connection_params, SseConnectionParams):
+      client = sse_client(
+          url=self._connection_params.url,
+          headers=merged_headers,
+          timeout=self._connection_params.timeout,
+          sse_read_timeout=self._connection_params.sse_read_timeout,
+      )
+    elif isinstance(self._connection_params, StreamableHTTPConnectionParams):
+      client = streamablehttp_client(
+          url=self._connection_params.url,
+          headers=merged_headers,
+          timeout=timedelta(seconds=self._connection_params.timeout),
+          sse_read_timeout=timedelta(
+              seconds=self._connection_params.sse_read_timeout
+          ),
+          terminate_on_close=self._connection_params.terminate_on_close,
+      )
+    else:
+      raise ValueError(
+          'Unable to initialize connection. Connection should be'
+          ' StdioServerParameters or SseServerParams, but got'
+          f' {self._connection_params}'
+      )
+    return client
+
   async def create_session(
       self, headers: Optional[Dict[str, str]] = None
   ) -> ClientSession:
@@ -298,36 +341,7 @@ class MCPSessionManager:
       exit_stack = AsyncExitStack()
 
       try:
-        if isinstance(self._connection_params, StdioConnectionParams):
-          client = stdio_client(
-              server=self._connection_params.server_params,
-              errlog=self._errlog,
-          )
-        elif isinstance(self._connection_params, SseConnectionParams):
-          client = sse_client(
-              url=self._connection_params.url,
-              headers=merged_headers,
-              timeout=self._connection_params.timeout,
-              sse_read_timeout=self._connection_params.sse_read_timeout,
-          )
-        elif isinstance(
-            self._connection_params, StreamableHTTPConnectionParams
-        ):
-          client = streamablehttp_client(
-              url=self._connection_params.url,
-              headers=merged_headers,
-              timeout=timedelta(seconds=self._connection_params.timeout),
-              sse_read_timeout=timedelta(
-                  seconds=self._connection_params.sse_read_timeout
-              ),
-              terminate_on_close=self._connection_params.terminate_on_close,
-          )
-        else:
-          raise ValueError(
-              'Unable to initialize connection. Connection should be'
-              ' StdioServerParameters or SseServerParams, but got'
-              f' {self._connection_params}'
-          )
+        client = self._create_client(merged_headers)
 
         transports = await exit_stack.enter_async_context(client)
         # The streamable http client returns a GetSessionCallback in addition to the read/write MemoryObjectStreams

google/adk/tools/mcp_tool/mcp_tool.py

@@ -15,12 +15,11 @@
 from __future__ import annotations
 
 import base64
-import json
 import logging
 from typing import Optional
 
+from fastapi.openapi.models import APIKeyIn
 from google.genai.types import FunctionDeclaration
-from google.oauth2.credentials import Credentials
 from typing_extensions import override
 
 from .._gemini_schema_util import _to_gemini_schema
@@ -58,6 +57,9 @@ class MCPTool(BaseAuthenticatedTool):
 
   Internally, the tool initializes from a MCP Tool, and uses the MCP Session to
   call the tool.
+
+  Note: For API key authentication, only header-based API keys are supported.
+  Query and cookie-based API keys will result in authentication errors.
   """
 
   def __init__(
@@ -134,7 +136,19 @@ class MCPTool(BaseAuthenticatedTool):
   async def _get_headers(
       self, tool_context: ToolContext, credential: AuthCredential
   ) -> Optional[dict[str, str]]:
-    headers = None
+    """Extracts authentication headers from credentials.
+
+    Args:
+        tool_context: The tool context of the current invocation.
+        credential: The authentication credential to process.
+
+    Returns:
+        Dictionary of headers to add to the request, or None if no auth.
+
+    Raises:
+        ValueError: If API key authentication is configured for non-header location.
+    """
+    headers: Optional[dict[str, str]] = None
     if credential:
       if credential.oauth2:
         headers = {"Authorization": f"Bearer {credential.oauth2.access_token}"}
@@ -167,10 +181,33 @@ class MCPTool(BaseAuthenticatedTool):
               )
           }
       elif credential.api_key:
-        # For API keys, we'll add them as headers since MCP typically uses header-based auth
-        # The specific header name would depend on the API, using a common default
-        # TODO Allow user to specify the header name for API keys.
-        headers = {"X-API-Key": credential.api_key}
+        if (
+            not self._credentials_manager
+            or not self._credentials_manager._auth_config
+        ):
+          error_msg = (
+              "Cannot find corresponding auth scheme for API key credential"
+              f" {credential}"
+          )
+          logger.error(error_msg)
+          raise ValueError(error_msg)
+        elif (
+            self._credentials_manager._auth_config.auth_scheme.in_
+            != APIKeyIn.header
+        ):
+          error_msg = (
+              "MCPTool only supports header-based API key authentication."
+              " Configured location:"
+              f" {self._credentials_manager._auth_config.auth_scheme.in_}"
+          )
+          logger.error(error_msg)
+          raise ValueError(error_msg)
+        else:
+          headers = {
+              self._credentials_manager._auth_config.auth_scheme.name: (
+                  credential.api_key
+              )
+          }
       elif credential.service_account:
         # Service accounts should be exchanged for access tokens before reaching this point
         logger.warning(

google/adk/version.py

@@ -13,4 +13,4 @@
 # limitations under the License.
 
 # version: major.minor.patch
-__version__ = "1.5.0"
+__version__ = "1.6.1"

{google_adk-1.5.0.dist-info → google_adk-1.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-adk
-Version: 1.5.0
+Version: 1.6.1
 Summary: Agent Development Kit
 Author-email: Google LLC <googleapis-packages@google.com>
 Requires-Python: >=3.9
@@ -41,9 +41,11 @@ Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: requests>=2.32.4
 Requires-Dist: sqlalchemy>=2.0
 Requires-Dist: starlette>=0.46.2
+Requires-Dist: tenacity>=8.0.0
 Requires-Dist: typing-extensions>=4.5, <5
 Requires-Dist: tzlocal>=5.3
 Requires-Dist: uvicorn>=0.34.0
+Requires-Dist: watchdog>=6.0.0
 Requires-Dist: websockets>=15.0.1
 Requires-Dist: a2a-sdk>=0.2.7 ; extra == "a2a" and (python_version>='3.10')
 Requires-Dist: flit>=3.10.0 ; extra == "dev"
@@ -57,7 +59,7 @@ Requires-Dist: myst-parser ; extra == "docs"
 Requires-Dist: sphinx ; extra == "docs"
 Requires-Dist: sphinx-autodoc-typehints ; extra == "docs"
 Requires-Dist: sphinx-rtd-theme ; extra == "docs"
-Requires-Dist: google-cloud-aiplatform[evaluation]>=1.87.0 ; extra == "eval"
+Requires-Dist: google-cloud-aiplatform[evaluation]>=1.100.0 ; extra == "eval"
 Requires-Dist: pandas>=2.2.3 ; extra == "eval"
 Requires-Dist: tabulate>=0.9.0 ; extra == "eval"
 Requires-Dist: rouge-score>=0.1.2 ; extra == "eval"
@@ -72,7 +74,7 @@ Requires-Dist: lxml>=5.3.0 ; extra == "extensions"
 Requires-Dist: toolbox-core>=0.1.0 ; extra == "extensions"
 Requires-Dist: anthropic>=0.43.0 ; extra == "test"
 Requires-Dist: langchain-community>=0.3.17 ; extra == "test"
-Requires-Dist: langgraph>=0.2.60 ; extra == "test"
+Requires-Dist: langgraph>=0.2.60, <= 0.4.10 ; extra == "test"
 Requires-Dist: litellm>=1.71.2 ; extra == "test"
 Requires-Dist: llama-index-readers-file>=0.4.0 ; extra == "test"
 Requires-Dist: pytest-asyncio>=0.25.0 ; extra == "test"
@@ -137,7 +139,7 @@ Agent Development Kit (ADK) is a flexible and modular framework for developing a
 
 For remote agent-to-agent communication, ADK integrates with the
 [A2A protocol](https://github.com/google-a2a/A2A/).
-See this [example](https://github.com/google-a2a/a2a-samples/tree/main/samples/python/agents/google_adk)
+See this [example](https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents)
 for how they can work together.
 
 ## 🚀 Installation