diff --git a/README.md b/README.md
index 23f2308f6..e31c5ffbb 100644
--- a/README.md
+++ b/README.md
@@ -4,10 +4,20 @@ With Gemini 2.0, we took the chance to create a single unified SDK for all devel
 
 The full migration guide from the old SDK to new SDK is available in the [Gemini API docs](https://ai.google.dev/gemini-api/docs/migrate).
 
-We won't be adding anything to this SDK or making any further changes. The Gemini API docs are fully updated to show examples of the new Google Gen AI SDK. We know how disruptive an SDK change can be and don't take this change lightly, but our goal is to create an extremely simple and clear path for developers to build with our models so it felt necessary to make this change.
+The Gemini API docs are fully updated to show examples of the new Google Gen AI SDK. We know how disruptive an SDK change can be and don't take this change lightly, but our goal is to create an extremely simple and clear path for developers to build with our models so it felt necessary to make this change.
 
 Thank you for building with Gemini and [let us know](https://discuss.ai.google.dev/c/gemini-api/4) if you need any help!
 
+**Please be advised that this repository is now considered legacy.** For the latest features, performance improvements, and active development, we strongly recommend migrating to the official **[Google Generative AI SDK for Python](https://github.com/googleapis/python-genai)**.
+
+**Support Plan for this Repository:**
+
+*   **Limited Maintenance:** Development is now restricted to **critical bug fixes only**. No new features will be added.
+*   **Purpose:** This limited support aims to provide stability for users while they transition to the new SDK.
+*   **End-of-Life Date:** All support for this repository (including bug fixes) will permanently end on **August 31st, 2025**.
+
+We encourage all users to begin planning their migration to the [Google Generative AI SDK](https://github.com/googleapis/python-genai) to ensure continued access to the latest capabilities and support.
+
 <!-- 
 [START update]
 # With Gemini 2 we're launching a new SDK. See the following doc for details.
diff --git a/google/generativeai/client.py b/google/generativeai/client.py
index c9c5c8c5b..113592594 100644
--- a/google/generativeai/client.py
+++ b/google/generativeai/client.py
@@ -185,12 +185,12 @@ def configure(
                     "Invalid configuration: Please set either `api_key` or `client_options['api_key']`, but not both."
                 )
         else:
-            if api_key is None:
+            if not api_key:
                 # If no key is provided explicitly, attempt to load one from the
                 # environment.
                 api_key = os.getenv("GEMINI_API_KEY")
 
-            if api_key is None:
+            if not api_key:
                 # If the GEMINI_API_KEY doesn't exist, attempt to load the
                 # GOOGLE_API_KEY from the environment.
                 api_key = os.getenv("GOOGLE_API_KEY")
diff --git a/google/generativeai/responder.py b/google/generativeai/responder.py
index dd388c6a6..70a58cf5b 100644
--- a/google/generativeai/responder.py
+++ b/google/generativeai/responder.py
@@ -23,6 +23,7 @@
 import pydantic
 
 from google.generativeai import protos
+from google.generativeai.types import content_types
 
 Type = protos.Type
 
@@ -89,52 +90,36 @@ def _generate_schema(
     """
     if descriptions is None:
         descriptions = {}
-    if required is None:
-        required = []
     defaults = dict(inspect.signature(f).parameters)
-    fields_dict = {
-        name: (
-            # 1. We infer the argument type here: use Any rather than None so
-            # it will not try to auto-infer the type based on the default value.
-            (param.annotation if param.annotation != inspect.Parameter.empty else Any),
-            pydantic.Field(
-                # 2. We do not support default values for now.
-                # default=(
-                #     param.default if param.default != inspect.Parameter.empty
-                #     else None
-                # ),
-                # 3. We support user-provided descriptions.
-                description=descriptions.get(name, None),
-            ),
-        )
-        for name, param in defaults.items()
-        # We do not support *args or **kwargs
-        if param.kind
-        in (
+
+    fields_dict = {}
+    for name, param in defaults.items():
+        if param.kind in (
             inspect.Parameter.POSITIONAL_OR_KEYWORD,
             inspect.Parameter.KEYWORD_ONLY,
             inspect.Parameter.POSITIONAL_ONLY,
-        )
-    }
-    parameters = pydantic.create_model(f.__name__, **fields_dict).model_json_schema()
-    # Postprocessing
-    # 4. Suppress unnecessary title generation:
-    #    * https://github.com/pydantic/pydantic/issues/1051
-    #    * http://cl/586221780
-    parameters.pop("title", None)
-    for name, function_arg in parameters.get("properties", {}).items():
-        function_arg.pop("title", None)
-        annotation = defaults[name].annotation
-        # 5. Nullable fields:
-        #     * https://github.com/pydantic/pydantic/issues/1270
-        #     * https://stackoverflow.com/a/58841311
-        #     * https://github.com/pydantic/pydantic/discussions/4872
-        if typing.get_origin(annotation) is typing.Union and type(None) in typing.get_args(
-            annotation
         ):
-            function_arg["nullable"] = True
+            # We do not support default values for now.
+            # default=(
+            #     param.default if param.default != inspect.Parameter.empty
+            #     else None
+            # ),
+            field = pydantic.Field(
+                # We support user-provided descriptions.
+                description=descriptions.get(name, None)
+            )
+
+            # 1. We infer the argument type here: use Any rather than None so
+            # it will not try to auto-infer the type based on the default value.
+            if param.annotation != inspect.Parameter.empty:
+                fields_dict[name] = param.annotation, field
+            else:
+                fields_dict[name] = Any, field
+
+    parameters = _build_schema(f.__name__, fields_dict)
+
     # 6. Annotate required fields.
-    if required:
+    if required is not None:
         # We use the user-provided "required" fields if specified.
         parameters["required"] = required
     else:
@@ -152,10 +137,138 @@ def _generate_schema(
                 )
             )
         ]
-    schema = dict(name=f.__name__, description=f.__doc__, parameters=parameters)
+    schema = dict(name=f.__name__, description=f.__doc__)
+    if parameters["properties"]:
+        schema["parameters"] = parameters
+
     return schema
 
 
+def _build_schema(fname, fields_dict):
+    parameters = pydantic.create_model(fname, **fields_dict).model_json_schema()
+    defs = parameters.pop("$defs", {})
+    # flatten the defs
+    for name, value in defs.items():
+        unpack_defs(value, defs)
+    unpack_defs(parameters, defs)
+
+    # 5. Nullable fields:
+    #     * https://github.com/pydantic/pydantic/issues/1270
+    #     * https://stackoverflow.com/a/58841311
+    #     * https://github.com/pydantic/pydantic/discussions/4872
+    convert_to_nullable(parameters)
+    add_object_type(parameters)
+    # Postprocessing
+    # 4. Suppress unnecessary title generation:
+    #    * https://github.com/pydantic/pydantic/issues/1051
+    #    * http://cl/586221780
+    strip_titles(parameters)
+    strip_additional_properties(parameters)
+    return parameters
+
+
+def unpack_defs(schema, defs):
+    properties = schema.get("properties", None)
+    if properties is None:
+        return
+
+    for name, value in properties.items():
+        ref_key = value.get("$ref", None)
+        if ref_key is not None:
+            ref = defs[ref_key.split("defs/")[-1]]
+            unpack_defs(ref, defs)
+            properties[name] = ref
+            continue
+
+        anyof = value.get("anyOf", None)
+        if anyof is not None:
+            for i, atype in enumerate(anyof):
+                ref_key = atype.get("$ref", None)
+                if ref_key is not None:
+                    ref = defs[ref_key.split("defs/")[-1]]
+                    unpack_defs(ref, defs)
+                    anyof[i] = ref
+            continue
+
+        items = value.get("items", None)
+        if items is not None:
+            ref_key = items.get("$ref", None)
+            if ref_key is not None:
+                ref = defs[ref_key.split("defs/")[-1]]
+                unpack_defs(ref, defs)
+                value["items"] = ref
+                continue
+
+
+def strip_titles(schema):
+    title = schema.pop("title", None)
+
+    properties = schema.get("properties", None)
+    if properties is not None:
+        for name, value in properties.items():
+            strip_titles(value)
+
+    items = schema.get("items", None)
+    if items is not None:
+        strip_titles(items)
+
+
+def strip_additional_properties(schema):
+    schema.pop("additionalProperties", None)
+
+    properties = schema.get("properties", None)
+    if properties is not None:
+        for name, value in properties.items():
+            strip_additional_properties(value)
+
+    items = schema.get("items", None)
+    if items is not None:
+        strip_additional_properties(items)
+
+
+def add_object_type(schema):
+    properties = schema.get("properties", None)
+    if properties is not None:
+        schema.pop("required", None)
+        schema["type"] = "object"
+        for name, value in properties.items():
+            add_object_type(value)
+
+    items = schema.get("items", None)
+    if items is not None:
+        add_object_type(items)
+
+
+def convert_to_nullable(schema):
+    anyof = schema.pop("anyOf", None)
+    if anyof is not None:
+        if len(anyof) != 2:
+            raise ValueError(
+                "Invalid input: Type Unions are not supported, except for `Optional` types. "
+                "Please provide an `Optional` type or a non-Union type."
+            )
+        a, b = anyof
+        if a == {"type": "null"}:
+            schema.update(b)
+        elif b == {"type": "null"}:
+            schema.update(a)
+        else:
+            raise ValueError(
+                "Invalid input: Type Unions are not supported, except for `Optional` types. "
+                "Please provide an `Optional` type or a non-Union type."
+            )
+        schema["nullable"] = True
+
+    properties = schema.get("properties", None)
+    if properties is not None:
+        for name, value in properties.items():
+            convert_to_nullable(value)
+
+    items = schema.get("items", None)
+    if items is not None:
+        convert_to_nullable(items)
+
+
 def _rename_schema_fields(schema: dict[str, Any]):
     if schema is None:
         return schema
diff --git a/google/generativeai/types/content_types.py b/google/generativeai/types/content_types.py
index f3db610e1..80f60d2b2 100644
--- a/google/generativeai/types/content_types.py
+++ b/google/generativeai/types/content_types.py
@@ -435,6 +435,7 @@ def _build_schema(fname, fields_dict):
     #    * https://github.com/pydantic/pydantic/issues/1051
     #    * http://cl/586221780
     strip_titles(parameters)
+    strip_additional_properties(parameters)
     return parameters
 
 
@@ -484,6 +485,19 @@ def strip_titles(schema):
         strip_titles(items)
 
 
+def strip_additional_properties(schema):
+    schema.pop("additionalProperties", None)
+
+    properties = schema.get("properties", None)
+    if properties is not None:
+        for name, value in properties.items():
+            strip_additional_properties(value)
+
+    items = schema.get("items", None)
+    if items is not None:
+        strip_additional_properties(items)
+
+
 def add_object_type(schema):
     properties = schema.get("properties", None)
     if properties is not None:
diff --git a/google/generativeai/version.py b/google/generativeai/version.py
index b5271a21d..6df9e6f74 100644
--- a/google/generativeai/version.py
+++ b/google/generativeai/version.py
@@ -14,4 +14,4 @@
 # limitations under the License.
 from __future__ import annotations
 
-__version__ = "0.8.4"
+__version__ = "0.8.5"
diff --git a/samples/tuned_models.py b/samples/tuned_models.py
index 970919115..df12903ac 100644
--- a/samples/tuned_models.py
+++ b/samples/tuned_models.py
@@ -22,7 +22,9 @@
 
 
 class UnitTests(absltest.TestCase):
-    def test_tuned_models_create(self):
+    @classmethod
+    def setUpClass(cls):
+        # Code to run once before all tests in the class
         # [START tuned_models_create]
         import google.generativeai as genai
 
@@ -53,7 +55,7 @@ def test_tuned_models_create(self):
             # You can use a tuned model here too. Set `source_model="tunedModels/..."`
             display_name="increment",
             source_model=base_model,
-            epoch_count=20,
+            epoch_count=5,
             batch_size=4,
             learning_rate=0.001,
             training_data=training_data,
@@ -62,22 +64,24 @@ def test_tuned_models_create(self):
         for status in operation.wait_bar():
             time.sleep(10)
 
-        result = operation.result()
-        print(result)
+        tuned_model = operation.result()
+        print(tuned_model)
         # # You can plot the loss curve with:
         # snapshots = pd.DataFrame(result.tuning_task.snapshots)
         # sns.lineplot(data=snapshots, x='epoch', y='mean_loss')
 
-        model = genai.GenerativeModel(model_name=result.name)
+        model = genai.GenerativeModel(model_name=tuned_model.name)
         result = model.generate_content("III")
         print(result.text)  # IV
         # [END tuned_models_create]
 
+        cls.tuned_model_name = tuned_model_name = tuned_model.name
+
     def test_tuned_models_generate_content(self):
         # [START tuned_models_generate_content]
         import google.generativeai as genai
 
-        model = genai.GenerativeModel(model_name="tunedModels/my-increment-model")
+        model = genai.GenerativeModel(model_name=self.tuned_model_name)
         result = model.generate_content("III")
         print(result.text)  # "IV"
         # [END tuned_models_generate_content]
@@ -86,7 +90,7 @@ def test_tuned_models_get(self):
         # [START tuned_models_get]
         import google.generativeai as genai
 
-        model_info = genai.get_model("tunedModels/my-increment-model")
+        model_info = genai.get_model(self.tuned_model_name)
         print(model_info)
         # [END tuned_models_get]
 
@@ -100,6 +104,7 @@ def test_tuned_models_list(self):
 
     def test_tuned_models_delete(self):
         import time
+        import google.generativeai as genai
 
         base_model = "models/gemini-1.5-flash-001-tuning"
         training_data = samples / "increment_tuning_data.json"
@@ -109,7 +114,7 @@ def test_tuned_models_delete(self):
                 # You can use a tuned model here too. Set `source_model="tunedModels/..."`
                 display_name="increment",
                 source_model=base_model,
-                epoch_count=20,
+                epoch_count=5,
                 batch_size=4,
                 learning_rate=0.001,
                 training_data=training_data,
@@ -135,7 +140,7 @@ def test_tuned_models_permissions_create(self):
         # [START tuned_models_permissions_create]
         import google.generativeai as genai
 
-        model_info = genai.get_model("tunedModels/my-increment-model")
+        model_info = genai.get_model(self.tuned_model_name)
         # [START_EXCLUDE]
         for p in model_info.permissions.list():
             if p.role.name != "OWNER":
@@ -161,7 +166,7 @@ def test_tuned_models_permissions_list(self):
         # [START tuned_models_permissions_list]
         import google.generativeai as genai
 
-        model_info = genai.get_model("tunedModels/my-increment-model")
+        model_info = genai.get_model(self.tuned_model_name)
 
         # [START_EXCLUDE]
         for p in model_info.permissions.list():
@@ -190,7 +195,7 @@ def test_tuned_models_permissions_get(self):
         # [START tuned_models_permissions_get]
         import google.generativeai as genai
 
-        model_info = genai.get_model("tunedModels/my-increment-model")
+        model_info = genai.get_model(self.tuned_model_name)
 
         # [START_EXCLUDE]
         for p in model_info.permissions.list():
@@ -214,7 +219,7 @@ def test_tuned_models_permissions_update(self):
         # [START tuned_models_permissions_update]
         import google.generativeai as genai
 
-        model_info = genai.get_model("tunedModels/my-increment-model")
+        model_info = genai.get_model(self.tuned_model_name)
 
         # [START_EXCLUDE]
         for p in model_info.permissions.list():
@@ -235,7 +240,7 @@ def test_tuned_models_permission_delete(self):
         # [START tuned_models_permissions_delete]
         import google.generativeai as genai
 
-        model_info = genai.get_model("tunedModels/my-increment-model")
+        model_info = genai.get_model(self.tuned_model_name)
         # [START_EXCLUDE]
         for p in model_info.permissions.list():
             if p.role.name != "OWNER":
diff --git a/setup.py b/setup.py
index ee7160eaf..d8ab792a4 100644
--- a/setup.py
+++ b/setup.py
@@ -36,10 +36,7 @@ def get_version():
 
 version = get_version()
 
-if version[0] == "0":
-    release_status = "Development Status :: 4 - Beta"
-else:
-    release_status = "Development Status :: 5 - Production/Stable"
+release_status = "Development Status :: 7 - Inactive"
 
 dependencies = [
     "google-ai-generativelanguage==0.6.15",
@@ -86,6 +83,7 @@ def get_version():
         "Programming Language :: Python :: 3.10",  # Colab
         "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
         "Operating System :: OS Independent",
         "Topic :: Scientific/Engineering :: Artificial Intelligence",
         "Typing :: Typed",
diff --git a/tests/test_client.py b/tests/test_client.py
index 9162c3d75..e6e4acfd4 100644
--- a/tests/test_client.py
+++ b/tests/test_client.py
@@ -29,6 +29,18 @@ def test_api_key_passed_via_client_options(self):
         client_opts = client._client_manager.client_config["client_options"]
         self.assertEqual(client_opts.api_key, "AIzA_client_opts")
 
+    @mock.patch.dict(os.environ, {"GEMINI_API_KEY": "AIzA_env"})
+    def test_api_key_from_environment(self):
+        # Default to API key loaded from environment.
+        client.configure()
+        client_opts = client._client_manager.client_config["client_options"]
+        self.assertEqual(client_opts.api_key, "AIzA_env")
+
+        # But not when a key is provided explicitly.
+        client.configure(api_key="AIzA_client")
+        client_opts = client._client_manager.client_config["client_options"]
+        self.assertEqual(client_opts.api_key, "AIzA_client")
+
     @mock.patch.dict(os.environ, {"GOOGLE_API_KEY": "AIzA_env"})
     def test_api_key_from_environment(self):
         # Default to API key loaded from environment.
@@ -41,6 +53,30 @@ def test_api_key_from_environment(self):
         client_opts = client._client_manager.client_config["client_options"]
         self.assertEqual(client_opts.api_key, "AIzA_client")
 
+    @mock.patch.dict(os.environ, {"GEMINI_API_KEY": "", "GOOGLE_API_KEY": "AIzA_env"})
+    def test_empty_gemini_api_key_doesnt_shadow(self):
+        # Default to API key loaded from environment.
+        client.configure()
+        client_opts = client._client_manager.client_config["client_options"]
+        self.assertEqual(client_opts.api_key, "AIzA_env")
+
+        # But not when a key is provided explicitly.
+        client.configure(api_key="AIzA_client")
+        client_opts = client._client_manager.client_config["client_options"]
+        self.assertEqual(client_opts.api_key, "AIzA_client")
+
+    @mock.patch.dict(os.environ, {"GEMINI_API_KEY": "", "GOOGLE_API_KEY": "AIzA_env"})
+    def test_empty_google_api_key_doesnt_shadow(self):
+        # Default to API key loaded from environment.
+        client.configure()
+        client_opts = client._client_manager.client_config["client_options"]
+        self.assertEqual(client_opts.api_key, "AIzA_env")
+
+        # But not when a key is provided explicitly.
+        client.configure(api_key="AIzA_client")
+        client_opts = client._client_manager.client_config["client_options"]
+        self.assertEqual(client_opts.api_key, "AIzA_client")
+
     def test_api_key_cannot_be_set_twice(self):
         client_opts = client_options.ClientOptions(api_key="AIzA_client_opts")
 
diff --git a/tests/test_responder.py b/tests/test_responder.py
deleted file mode 100644
index d2818da8a..000000000
--- a/tests/test_responder.py
+++ /dev/null
@@ -1,255 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2023 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.
-import pathlib
-from typing import Any
-
-from absl.testing import absltest
-from absl.testing import parameterized
-from google.generativeai import protos
-from google.generativeai import responder
-
-
-HERE = pathlib.Path(__file__).parent
-TEST_PNG_PATH = HERE / "test_img.png"
-TEST_PNG_URL = "https://storage.googleapis.com/generativeai-downloads/data/test_img.png"
-TEST_PNG_DATA = TEST_PNG_PATH.read_bytes()
-
-TEST_JPG_PATH = HERE / "test_img.jpg"
-TEST_JPG_URL = "https://storage.googleapis.com/generativeai-downloads/data/test_img.jpg"
-TEST_JPG_DATA = TEST_JPG_PATH.read_bytes()
-
-
-# simple test function
-def datetime():
-    "Returns the current UTC date and time."
-
-
-class UnitTests(parameterized.TestCase):
-    @parameterized.named_parameters(
-        [
-            "FunctionLibrary",
-            responder.FunctionLibrary(
-                tools=protos.Tool(
-                    function_declarations=[
-                        protos.FunctionDeclaration(
-                            name="datetime", description="Returns the current UTC date and time."
-                        )
-                    ]
-                )
-            ),
-        ],
-        [
-            "IterableTool-Tool",
-            [
-                responder.Tool(
-                    function_declarations=[
-                        protos.FunctionDeclaration(
-                            name="datetime", description="Returns the current UTC date and time."
-                        )
-                    ]
-                )
-            ],
-        ],
-        [
-            "IterableTool-protos.Tool",
-            [
-                protos.Tool(
-                    function_declarations=[
-                        protos.FunctionDeclaration(
-                            name="datetime",
-                            description="Returns the current UTC date and time.",
-                        )
-                    ]
-                )
-            ],
-        ],
-        [
-            "IterableTool-ToolDict",
-            [
-                dict(
-                    function_declarations=[
-                        dict(
-                            name="datetime",
-                            description="Returns the current UTC date and time.",
-                        )
-                    ]
-                )
-            ],
-        ],
-        [
-            "IterableTool-IterableFD",
-            [
-                [
-                    protos.FunctionDeclaration(
-                        name="datetime",
-                        description="Returns the current UTC date and time.",
-                    )
-                ]
-            ],
-        ],
-        [
-            "IterableTool-FD",
-            [
-                protos.FunctionDeclaration(
-                    name="datetime",
-                    description="Returns the current UTC date and time.",
-                )
-            ],
-        ],
-        [
-            "Tool",
-            responder.Tool(
-                function_declarations=[
-                    protos.FunctionDeclaration(
-                        name="datetime", description="Returns the current UTC date and time."
-                    )
-                ]
-            ),
-        ],
-        [
-            "protos.Tool",
-            protos.Tool(
-                function_declarations=[
-                    protos.FunctionDeclaration(
-                        name="datetime", description="Returns the current UTC date and time."
-                    )
-                ]
-            ),
-        ],
-        [
-            "ToolDict",
-            dict(
-                function_declarations=[
-                    dict(name="datetime", description="Returns the current UTC date and time.")
-                ]
-            ),
-        ],
-        [
-            "IterableFD-FD",
-            [
-                responder.FunctionDeclaration(
-                    name="datetime", description="Returns the current UTC date and time."
-                )
-            ],
-        ],
-        [
-            "IterableFD-CFD",
-            [
-                responder.CallableFunctionDeclaration(
-                    name="datetime",
-                    description="Returns the current UTC date and time.",
-                    function=datetime,
-                )
-            ],
-        ],
-        [
-            "IterableFD-dict",
-            [dict(name="datetime", description="Returns the current UTC date and time.")],
-        ],
-        ["IterableFD-Callable", [datetime]],
-        [
-            "FD",
-            responder.FunctionDeclaration(
-                name="datetime", description="Returns the current UTC date and time."
-            ),
-        ],
-        [
-            "CFD",
-            responder.CallableFunctionDeclaration(
-                name="datetime",
-                description="Returns the current UTC date and time.",
-                function=datetime,
-            ),
-        ],
-        [
-            "protos.FD",
-            protos.FunctionDeclaration(
-                name="datetime", description="Returns the current UTC date and time."
-            ),
-        ],
-        ["dict", dict(name="datetime", description="Returns the current UTC date and time.")],
-        ["Callable", datetime],
-    )
-    def test_to_tools(self, tools):
-        function_library = responder.to_function_library(tools)
-        if function_library is None:
-            raise ValueError("This shouldn't happen")
-        tools = function_library.to_proto()
-
-        tools = type(tools[0]).to_dict(tools[0])
-        tools["function_declarations"][0].pop("parameters", None)
-
-        expected = dict(
-            function_declarations=[
-                dict(name="datetime", description="Returns the current UTC date and time.")
-            ]
-        )
-
-        self.assertEqual(tools, expected)
-
-    def test_two_fun_is_one_tool(self):
-        def a():
-            pass
-
-        def b():
-            pass
-
-        function_library = responder.to_function_library([a, b])
-        if function_library is None:
-            raise ValueError("This shouldn't happen")
-        tools = function_library.to_proto()
-
-        self.assertLen(tools, 1)
-        self.assertLen(tools[0].function_declarations, 2)
-
-    @parameterized.named_parameters(
-        ["int", int, protos.Schema(type=protos.Type.INTEGER)],
-        ["float", float, protos.Schema(type=protos.Type.NUMBER)],
-        ["str", str, protos.Schema(type=protos.Type.STRING)],
-        [
-            "list",
-            list[str],
-            protos.Schema(
-                type=protos.Type.ARRAY,
-                items=protos.Schema(type=protos.Type.STRING),
-            ),
-        ],
-        [
-            "list-list-int",
-            list[list[int]],
-            protos.Schema(
-                type=protos.Type.ARRAY,
-                items=protos.Schema(
-                    protos.Schema(
-                        type=protos.Type.ARRAY,
-                        items=protos.Schema(type=protos.Type.INTEGER),
-                    ),
-                ),
-            ),
-        ],
-        ["dict", dict, protos.Schema(type=protos.Type.OBJECT)],
-        ["dict-str-any", dict[str, Any], protos.Schema(type=protos.Type.OBJECT)],
-    )
-    def test_auto_schema(self, annotation, expected):
-        def fun(a: annotation):
-            pass
-
-        cfd = responder.FunctionDeclaration.from_function(fun)
-        got = cfd.parameters.properties["a"]
-        self.assertEqual(got, expected)
-
-
-if __name__ == "__main__":
-    absltest.main()