google-genai 1.53.0__py3-none-any.whl → 1.55.0__py3-none-any.whl

google/genai/tests/local_tokenizer/test_local_tokenizer.py

@@ -0,0 +1,343 @@
+# 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.
+#
+
+import unittest
+from unittest.mock import MagicMock, patch
+
+from sentencepiece import sentencepiece_model_pb2
+
+from ... import local_tokenizer
+from ... import types
+
+
+class TestLocalTokenizer(unittest.TestCase):
+
+  def setUp(self):
+    # This setup will be used by all tests
+    self.mock_load_model_proto = patch(
+        'genai._local_tokenizer_loader.load_model_proto'
+    ).start()
+    self.mock_get_sentencepiece = patch(
+        'genai._local_tokenizer_loader.get_sentencepiece'
+    ).start()
+
+    self.mock_load_model_proto.return_value = MagicMock()
+    self.mock_tokenizer = MagicMock()
+    self.mock_get_sentencepiece.return_value = self.mock_tokenizer
+
+    self.tokenizer = local_tokenizer.LocalTokenizer(model_name='gemini-2.5-flash')
+
+  def tearDown(self):
+    patch.stopall()
+
+  def test_count_tokens_simple_string(self):
+    self.mock_tokenizer.encode.return_value = [[1, 2, 3]]
+    result = self.tokenizer.count_tokens('Hello world')
+    self.assertEqual(result.total_tokens, 3)
+    self.mock_tokenizer.encode.assert_called_once_with(['Hello world'])
+
+  def test_count_tokens_list_of_strings(self):
+    self.mock_tokenizer.encode.return_value = [[1, 2], [3]]
+    result = self.tokenizer.count_tokens(['Hello', 'world'])
+    self.assertEqual(result.total_tokens, 3)
+    self.mock_tokenizer.encode.assert_called_once_with(['Hello', 'world'])
+
+  def test_count_tokens_with_content_object(self):
+    self.mock_tokenizer.encode.return_value = [[1, 2, 3]]
+    content = types.Content(parts=[types.Part(text='Hello world')])
+    result = self.tokenizer.count_tokens(content)
+    self.assertEqual(result.total_tokens, 3)
+    self.mock_tokenizer.encode.assert_called_once_with(['Hello world'])
+
+  def test_count_tokens_with_chat_history(self):
+    self.mock_tokenizer.encode.return_value = [[1, 2], [3, 4, 5]]
+    history = [
+        types.Content(role='user', parts=[types.Part(text='Hello')]),
+        types.Content(role='model', parts=[types.Part(text='Hi there!')]),
+    ]
+    result = self.tokenizer.count_tokens(history)
+    self.assertEqual(result.total_tokens, 5)
+    self.mock_tokenizer.encode.assert_called_once_with(['Hello', 'Hi there!'])
+
+  def test_count_tokens_with_tools(self):
+    self.mock_tokenizer.encode.return_value = [
+        [1],
+        [1, 2],
+        [1, 2, 3],
+        [1, 2, 3, 4],
+        [1, 2, 3, 4, 5],
+        [1, 2, 3, 4, 5, 6],
+    ]
+    tool = types.Tool(
+        function_declarations=[
+            types.FunctionDeclaration(
+                name='get_weather',
+                description='Get the weather for a location',
+                parameters=types.Schema(
+                    type=types.Type.OBJECT,
+                    properties={
+                        'location': types.Schema(
+                            type=types.Type.STRING, description='The location'
+                        )
+                    },
+                    required=['location'],
+                ),
+            )
+        ]
+    )
+    config = types.CountTokensConfig(tools=[tool])
+    result = self.tokenizer.count_tokens(
+        'What is the weather in Boston?', config=config
+    )
+    self.assertEqual(result.total_tokens, 21)
+    self.mock_tokenizer.encode.assert_called_once_with([
+        'What is the weather in Boston?',
+        'get_weather',
+        'Get the weather for a location',
+        'location',
+        'location',
+        'The location',
+    ])
+
+  def test_count_tokens_with_function_call(self):
+    self.mock_tokenizer.encode.return_value = [[1, 2], [3], [4, 5]]
+    content = types.Content(
+        role='model',
+        parts=[
+            types.Part(
+                function_call=types.FunctionCall(
+                    name='get_weather', args={'location': 'Boston'}
+                )
+            )
+        ],
+    )
+    result = self.tokenizer.count_tokens(content)
+    self.assertEqual(result.total_tokens, 5)
+    self.mock_tokenizer.encode.assert_called_once_with(
+        ['get_weather', 'location', 'Boston']
+    )
+
+  def test_count_tokens_with_function_response(self):
+    self.mock_tokenizer.encode.return_value = [[1, 2], [3], [4, 5]]
+    content = types.Content(
+        role='user',
+        parts=[
+            types.Part(
+                function_response=types.FunctionResponse(
+                    name='get_weather', response={'weather': 'sunny'}
+                )
+            )
+        ],
+    )
+    result = self.tokenizer.count_tokens(content)
+    self.assertEqual(result.total_tokens, 5)
+    self.mock_tokenizer.encode.assert_called_once_with(
+        ['get_weather', 'weather', 'sunny']
+    )
+
+  def test_count_tokens_with_unsupported_content(self):
+    with self.assertRaises(ValueError):
+      self.tokenizer.count_tokens(
+          [
+              types.Content(
+                  parts=[
+                      types.Part(
+                          inline_data=types.Blob(
+                              data=b'test', mime_type='image/png'
+                          )
+                      )
+                  ]
+              )
+          ]
+      )
+
+  def test_count_tokens_with_system_instruction(self):
+    self.mock_tokenizer.encode.return_value = [[1, 2, 3], [4, 5]]
+    config = types.CountTokensConfig(
+        system_instruction=types.Content(
+            parts=[types.Part(text='You are a helpful assistant.')]
+        )
+    )
+    result = self.tokenizer.count_tokens('Hello', config=config)
+    self.assertEqual(result.total_tokens, 5)
+    self.mock_tokenizer.encode.assert_called_once_with(
+        ['Hello', 'You are a helpful assistant.']
+    )
+
+  def test_count_tokens_with_response_schema(self):
+    self.mock_tokenizer.encode.return_value = [
+        [1],
+        [1, 2],
+        [1, 2, 3],
+        [1, 2, 3, 4],
+        [1, 2, 3, 4, 5],
+    ]
+    schema = types.Schema(
+        type=types.Type.OBJECT,
+        format='schema_format',
+        description='Recipe schema',
+        enum=['schema_enum1', 'schema_enum2'],
+        properties={
+            'recipe_name': types.Schema(
+                type=types.Type.STRING,
+                description='Name of the recipe',
+            )
+        },
+        items=types.Schema(
+            type=types.Type.STRING,
+            description='Item in the recipe',
+        ),
+        example={
+            'recipe_example': types.Schema(
+                type=types.Type.STRING,
+                description='example in the recipe',
+            )
+        },
+        required=['recipe_name'],
+    )
+    config = types.CountTokensConfig(
+        generation_config=types.GenerationConfig(response_schema=schema)
+    )
+    result = self.tokenizer.count_tokens(
+        'Generate a recipe for chocolate chip cookies.', config=config
+    )
+    self.assertEqual(result.total_tokens, 15)
+    self.mock_tokenizer.encode.assert_called_once_with([
+        'Generate a recipe for chocolate chip cookies.',
+        'schema_format',
+        'Recipe schema',
+        'schema_enum1',
+        'schema_enum2',
+        'recipe_name',
+        'Item in the recipe',
+        'recipe_name',
+        'Name of the recipe',
+        'recipe_example',
+    ])
+
+  def test_count_tokens_with_unsupported_fields_logs_warning(self):
+    self.mock_tokenizer.encode.return_value = [[1, 2, 3]]
+    content_with_unsupported = types.Content(
+        role='user',
+        parts=[
+            types.Part(text='hello'),
+            # executable_code is not supported by _TextsAccumulator
+            types.Part(
+                executable_code=types.ExecutableCode(
+                    language='PYTHON', code='print(1)'
+                )
+            ),
+        ],
+    )
+    with self.assertLogs('google_genai.local_tokenizer', level='WARNING') as cm:
+      self.tokenizer.count_tokens(content_with_unsupported)
+      self.assertIn(
+          'Content contains unsupported types for token counting', cm.output[0]
+      )
+
+  def test_compute_tokens_simple_string(self):
+    mock_spt = MagicMock()
+    mock_spt.pieces = [
+        MagicMock(id=1, piece='He'),
+        MagicMock(id=2, piece='llo'),
+        MagicMock(id=3, piece=' world'),
+    ]
+    self.mock_tokenizer.EncodeAsImmutableProto.return_value = [mock_spt]
+    result = self.tokenizer.compute_tokens('Hello world')
+    self.assertEqual(len(result.tokens_info), 1)
+    self.assertEqual(result.tokens_info[0].token_ids, [1, 2, 3])
+    self.assertEqual(result.tokens_info[0].tokens, [b'He', b'llo', b' world'])
+    self.assertEqual(result.tokens_info[0].role, 'user')
+    self.mock_tokenizer.EncodeAsImmutableProto.assert_called_once_with(
+        ['Hello world']
+    )
+
+  def test_compute_tokens_with_chat_history(self):
+    mock_spt1 = MagicMock()
+    mock_spt1.pieces = [MagicMock(id=1, piece='Hello')]
+    mock_spt2 = MagicMock()
+    mock_spt2.pieces = [
+        MagicMock(id=2, piece='Hi'),
+        MagicMock(id=3, piece=' there!'),
+    ]
+    self.mock_tokenizer.EncodeAsImmutableProto.return_value = [
+        mock_spt1,
+        mock_spt2,
+    ]
+    history = [
+        types.Content(role='user', parts=[types.Part(text='Hello')]),
+        types.Content(role='model', parts=[types.Part(text='Hi there!')]),
+    ]
+    result = self.tokenizer.compute_tokens(history)
+    self.assertEqual(len(result.tokens_info), 2)
+    self.assertEqual(result.tokens_info[0].token_ids, [1])
+    self.assertEqual(result.tokens_info[0].tokens, [b'Hello'])
+    self.assertEqual(result.tokens_info[0].role, 'user')
+    self.assertEqual(result.tokens_info[1].token_ids, [2, 3])
+    self.assertEqual(result.tokens_info[1].tokens, [b'Hi', b' there!'])
+    self.assertEqual(result.tokens_info[1].role, 'model')
+    self.mock_tokenizer.EncodeAsImmutableProto.assert_called_once_with(
+        ['Hello', 'Hi there!']
+    )
+
+  def test_compute_tokens_with_byte_tokens(self):
+    mock_spt = MagicMock()
+    mock_spt.pieces = [
+        MagicMock(id=1, piece='<0x48>'),
+        MagicMock(id=2, piece='ello'),
+    ]
+    self.mock_tokenizer.EncodeAsImmutableProto.return_value = [mock_spt]
+    self.tokenizer._model_proto = sentencepiece_model_pb2.ModelProto(
+        pieces=[
+            sentencepiece_model_pb2.ModelProto.SentencePiece(),
+            sentencepiece_model_pb2.ModelProto.SentencePiece(
+                type=sentencepiece_model_pb2.ModelProto.SentencePiece.Type.BYTE
+            ),
+            sentencepiece_model_pb2.ModelProto.SentencePiece(
+                type=sentencepiece_model_pb2.ModelProto.SentencePiece.Type.NORMAL
+            ),
+        ]
+    )
+    result = self.tokenizer.compute_tokens('Hello')
+    self.assertEqual(len(result.tokens_info), 1)
+    self.assertEqual(result.tokens_info[0].token_ids, [1, 2])
+    self.assertEqual(result.tokens_info[0].tokens, [b'H', b'ello'])
+    self.mock_tokenizer.EncodeAsImmutableProto.assert_called_once_with(
+        ['Hello']
+    )
+
+
+class TestParseHexByte(unittest.TestCase):
+
+  def test_valid_hex(self):
+    self.assertEqual(local_tokenizer._parse_hex_byte('<0x41>'), 65)
+    self.assertEqual(local_tokenizer._parse_hex_byte('<0xFF>'), 255)
+    self.assertEqual(local_tokenizer._parse_hex_byte('<0x00>'), 0)
+
+  def test_invalid_length(self):
+    with self.assertRaisesRegex(ValueError, 'Invalid byte length'):
+      local_tokenizer._parse_hex_byte('<0x41')
+    with self.assertRaisesRegex(ValueError, 'Invalid byte length'):
+      local_tokenizer._parse_hex_byte('<0x411>')
+
+  def test_invalid_format(self):
+    with self.assertRaisesRegex(ValueError, 'Invalid byte format'):
+      local_tokenizer._parse_hex_byte(' 0x41>')
+    with self.assertRaisesRegex(ValueError, 'Invalid byte format'):
+      local_tokenizer._parse_hex_byte('<0x41 ')
+
+  def test_invalid_hex_value(self):
+    with self.assertRaisesRegex(ValueError, 'Invalid hex value'):
+      local_tokenizer._parse_hex_byte('<0xFG>')

google/genai/tests/local_tokenizer/test_local_tokenizer_loader.py

@@ -0,0 +1,235 @@
+# 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.
+#
+
+import unittest
+from unittest.mock import MagicMock, mock_open, patch
+
+import sentencepiece as spm
+from sentencepiece import sentencepiece_model_pb2
+
+from ... import _local_tokenizer_loader as loader
+
+# A minimal valid sentencepiece model proto
+FAKE_MODEL_CONTENT = sentencepiece_model_pb2.ModelProto(
+    pieces=[
+        sentencepiece_model_pb2.ModelProto.SentencePiece(
+            piece="<unk>",
+            score=0,
+            type=sentencepiece_model_pb2.ModelProto.SentencePiece.Type.UNKNOWN,
+        ),
+        sentencepiece_model_pb2.ModelProto.SentencePiece(
+            piece="<s>",
+            score=0,
+            type=sentencepiece_model_pb2.ModelProto.SentencePiece.Type.CONTROL,
+        ),
+        sentencepiece_model_pb2.ModelProto.SentencePiece(
+            piece="</s>",
+            score=0,
+            type=sentencepiece_model_pb2.ModelProto.SentencePiece.Type.CONTROL,
+        ),
+        sentencepiece_model_pb2.ModelProto.SentencePiece(
+            piece="a",
+            score=0,
+            type=sentencepiece_model_pb2.ModelProto.SentencePiece.Type.NORMAL,
+        ),
+    ]
+).SerializeToString()
+
+GEMMA2_HASH = "61a7b147390c64585d6c3543dd6fc636906c9af3865a5548f27f31aee1d4c8e2"
+
+
+class TestGetTokenizerName(unittest.TestCase):
+
+  def test_get_tokenizer_name_success(self):
+    self.assertEqual(loader.get_tokenizer_name("gemini-2.5-pro"), "gemma3")
+    self.assertEqual(
+        loader.get_tokenizer_name("gemini-2.5-pro-preview-06-05"), "gemma3"
+    )
+
+  def test_get_tokenizer_name_unsupported(self):
+    with self.assertRaisesRegex(
+        ValueError, "Model unsupported-model is not supported"
+    ):
+      loader.get_tokenizer_name("unsupported-model")
+
+
+@patch("genai._local_tokenizer_loader.os.rename")
+@patch("genai._local_tokenizer_loader.os.makedirs")
+@patch("genai._local_tokenizer_loader.os.remove")
+@patch("genai._local_tokenizer_loader.open", new_callable=mock_open)
+@patch("genai._local_tokenizer_loader.os.path.exists")
+@patch("genai._local_tokenizer_loader.requests.get")
+@patch("genai._local_tokenizer_loader.hashlib.sha256")
+class TestLoaderFunctions(unittest.TestCase):
+
+  def setUp(self):
+    # Clear caches before each test
+    loader.load_model_proto.cache_clear()
+    loader.get_sentencepiece.cache_clear()
+    # Patch tempfile.gettempdir to control cache location
+    self.tempdir_patcher = patch(
+        "tempfile.gettempdir", return_value="/tmp/fake_temp_dir"
+    )
+    self.mock_tempdir = self.tempdir_patcher.start()
+
+  def tearDown(self):
+    self.tempdir_patcher.stop()
+
+  def _setup_get_mock(self, mock_get):
+    mock_response = MagicMock()
+    mock_response.content = FAKE_MODEL_CONTENT
+    mock_response.raise_for_status.return_value = None
+    mock_get.return_value = mock_response
+
+  def test_load_model_proto_from_url(
+      self,
+      mock_sha256,
+      mock_get,
+      mock_exists,
+      mock_open_func,
+      mock_remove,
+      mock_makedirs,
+      mock_rename,
+  ):
+    mock_exists.return_value = False  # Don't use cache
+    self._setup_get_mock(mock_get)
+    mock_sha256.return_value.hexdigest.return_value = GEMMA2_HASH
+
+    proto = loader.load_model_proto("gemma2")
+
+    self.assertIsInstance(proto, sentencepiece_model_pb2.ModelProto)
+    self.assertEqual(len(proto.pieces), 4)
+    mock_get.assert_called_once()
+    mock_makedirs.assert_called_once()
+    mock_open_func.assert_called()
+    mock_rename.assert_called_once()
+
+  def test_load_model_proto_from_cache(
+      self,
+      mock_sha256,
+      mock_get,
+      mock_exists,
+      mock_open_func,
+      mock_remove,
+      mock_makedirs,
+      mock_rename,
+  ):
+    mock_exists.return_value = True  # Use cache
+    mock_open_func.return_value.read.return_value = FAKE_MODEL_CONTENT
+    mock_sha256.return_value.hexdigest.return_value = GEMMA2_HASH
+
+    proto = loader.load_model_proto("gemma2")
+
+    self.assertIsInstance(proto, sentencepiece_model_pb2.ModelProto)
+    mock_get.assert_not_called()
+
+  def test_load_model_proto_corrupted_cache(
+      self,
+      mock_sha256,
+      mock_get,
+      mock_exists,
+      mock_open_func,
+      mock_remove,
+      mock_makedirs,
+      mock_rename,
+  ):
+    mock_exists.return_value = True  # Use cache initially
+    self._setup_get_mock(mock_get)
+    mock_open_func.return_value.__enter__.return_value.read.return_value = (
+        b"corrupted"
+    )
+
+    # First hash for corrupted cache, second for good download
+    mock_sha256.side_effect = [
+        MagicMock(hexdigest=MagicMock(return_value="wrong_hash")),
+        MagicMock(hexdigest=MagicMock(return_value=GEMMA2_HASH)),
+    ]
+
+    proto = loader.load_model_proto("gemma2")
+
+    self.assertIsInstance(proto, sentencepiece_model_pb2.ModelProto)
+    mock_remove.assert_called_once()
+    mock_get.assert_called_once()
+
+  def test_load_model_proto_bad_hash_from_url(
+      self,
+      mock_sha256,
+      mock_get,
+      mock_exists,
+      mock_open_func,
+      mock_remove,
+      mock_makedirs,
+      mock_rename,
+  ):
+    mock_exists.return_value = False
+    self._setup_get_mock(mock_get)
+    mock_sha256.return_value.hexdigest.return_value = "wrong_hash"
+
+    with self.assertRaisesRegex(
+        ValueError, "Downloaded model file is corrupted"
+    ):
+      loader.load_model_proto("gemma2")
+
+  def test_load_model_proto_unsupported(self, *args):
+    with self.assertRaisesRegex(
+        ValueError, "Tokenizer unsupported is not supported"
+    ):
+      loader.load_model_proto("unsupported")
+
+  def test_get_sentencepiece_success(
+      self,
+      mock_sha256,
+      mock_get,
+      mock_exists,
+      mock_open_func,
+      mock_remove,
+      mock_makedirs,
+      mock_rename,
+  ):
+    mock_exists.return_value = False
+    self._setup_get_mock(mock_get)
+    mock_sha256.return_value.hexdigest.return_value = GEMMA2_HASH
+
+    processor = loader.get_sentencepiece("gemma2")
+
+    self.assertIsInstance(processor, spm.SentencePieceProcessor)
+    mock_get.assert_called_once()
+
+  def test_get_sentencepiece_unsupported(self, *args):
+    with self.assertRaisesRegex(
+        ValueError, "Tokenizer unsupported is not supported"
+    ):
+      loader.get_sentencepiece("unsupported")
+
+  def test_get_sentencepiece_caching(
+      self,
+      mock_sha256,
+      mock_get,
+      mock_exists,
+      mock_open_func,
+      mock_remove,
+      mock_makedirs,
+      mock_rename,
+  ):
+    mock_exists.return_value = False
+    self._setup_get_mock(mock_get)
+    mock_sha256.return_value.hexdigest.return_value = GEMMA2_HASH
+
+    # Call twice
+    loader.get_sentencepiece("gemma2")
+    loader.get_sentencepiece("gemma2")
+
+    # Should only be loaded once due to lru_cache
+    mock_get.assert_called_once()

google/genai/tests/mcp/__init__.py

@@ -0,0 +1,17 @@
+# 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.
+#
+
+
+"""Tests for the Google GenAI SDK's _mcp_utils module."""

google/genai/tests/mcp/test_has_mcp_tool_usage.py

@@ -0,0 +1,89 @@
+# 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.
+#
+
+import typing
+from typing import Any
+
+from ... import _mcp_utils
+from ... import types
+
+if typing.TYPE_CHECKING:
+  from mcp.types import Tool as McpTool
+  from mcp import ClientSession as McpClientSession
+else:
+  McpTool: typing.Type = Any
+  McpClientSession: typing.Type = Any
+  try:
+    from mcp.types import Tool as McpTool
+    from mcp import ClientSession as McpClientSession
+  except ImportError:
+    McpTool = None
+    McpClientSession = None
+
+
+def test_mcp_tools():
+  """Test whether the list of tools contains any MCP tools."""
+  if McpTool is None:
+    return
+  mcp_tools = [
+      McpTool(
+          name='tool',
+          description='tool-description',
+          inputSchema={
+              'type': 'OBJECT',
+              'properties': {
+                  'key1': {'type': 'STRING'},
+                  'key2': {'type': 'NUMBER'},
+              },
+          },
+      ),
+  ]
+  assert _mcp_utils.has_mcp_tool_usage(mcp_tools)
+
+
+def test_mcp_client_session():
+  """Test whether the list of tools contains any MCP tools."""
+
+  class MockMcpClientSession(McpClientSession):
+
+    def __init__(self):
+      self._read_stream = None
+      self._write_stream = None
+
+  mcp_tools = [
+      MockMcpClientSession(),
+  ]
+  assert _mcp_utils.has_mcp_tool_usage(mcp_tools)
+
+
+def test_no_mcp_tools():
+  if McpClientSession is None:
+    return
+  """Test whether the list of tools contains any MCP tools."""
+  gemini_tools = [
+      types.Tool(
+          function_declarations=[
+              types.FunctionDeclaration(
+                  name='tool',
+                  description='tool-description',
+                  parameters=types.Schema(
+                      type='OBJECT',
+                      properties={},
+                  ),
+              ),
+          ],
+      ),
+  ]
+  assert not _mcp_utils.has_mcp_tool_usage(gemini_tools)