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

google/genai/tests/afc/test_get_function_map.py

@@ -0,0 +1,176 @@
+# 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 get_function_map."""
+
+import typing
+from typing import Any
+import pytest
+from ..._extra_utils import get_function_map
+from ...errors import UnsupportedFunctionError
+from ...types import GenerateContentConfig
+
+_is_mcp_imported = False
+if typing.TYPE_CHECKING:
+  from mcp import types as mcp_types
+  from mcp import ClientSession as McpClientSession
+  from ..._adapters import McpToGenAiToolAdapter
+
+  _is_mcp_imported = True
+else:
+  McpClientSession: typing.Type = Any
+  McpToGenAiToolAdapter: typing.Type = Any
+  try:
+    from mcp import types as mcp_types
+    from mcp import ClientSession as McpClientSession
+    from ..._adapters import McpToGenAiToolAdapter
+
+    _is_mcp_imported = True
+  except ImportError:
+    McpClientSession = None
+    McpToGenAiToolAdapter = None
+
+
+def test_coroutine_function():
+  async def func_under_test():
+    pass
+
+  config = GenerateContentConfig(tools=[func_under_test])
+
+  with pytest.raises(UnsupportedFunctionError):
+    get_function_map(config)
+
+
+def test_empty_config():
+  config = {}
+
+  assert get_function_map(config) == {}
+
+
+def test_empty_tools():
+  config = GenerateContentConfig(top_p=0.5)
+
+  assert get_function_map(config) == {}
+
+
+def test_valid_function():
+  def func_under_test():
+    pass
+
+  config = GenerateContentConfig(tools=[func_under_test])
+
+  assert get_function_map(config) == {'func_under_test': func_under_test}
+
+
+def test_mcp_tool_raises_error():
+  if not _is_mcp_imported:
+    return
+
+  session = McpClientSession(read_stream=None, write_stream=None)
+  config = GenerateContentConfig(tools=[session])
+  mcp_to_genai_tool_adapters = {'tool': McpToGenAiToolAdapter(session, [])}
+  with pytest.raises(UnsupportedFunctionError):
+    get_function_map(
+        config, mcp_to_genai_tool_adapters, is_caller_method_async=False
+    )
+
+
+@pytest.mark.asyncio
+async def test_mcp_tool():
+  if not _is_mcp_imported:
+    return
+
+  class MockMcpClientSession(McpClientSession):
+
+    def __init__(self):
+      self._read_stream = None
+      self._write_stream = None
+
+    async def list_tools(self):
+      return mcp_types.ListToolsResult(
+          tools=[
+              mcp_types.Tool(
+                  name='tool',
+                  description='tool-description',
+                  inputSchema={
+                      'type': 'OBJECT',
+                      'properties': {
+                          'key1': {
+                              'type': 'STRING',
+                          },
+                          'key2': {
+                              'type': 'NUMBER',
+                          },
+                      },
+                  },
+              )
+          ]
+      )
+
+  session = MockMcpClientSession()
+  config = GenerateContentConfig(tools=[session])
+  mcp_to_genai_tool_adapters = {
+      'tool': McpToGenAiToolAdapter(session, [await session.list_tools()]),
+  }
+  result = get_function_map(
+      config, mcp_to_genai_tool_adapters, is_caller_method_async=True
+  )
+  assert isinstance(result['tool'], McpToGenAiToolAdapter)
+
+
+@pytest.mark.asyncio
+async def test_duplicate_mcp_tool_raises_error():
+  if not _is_mcp_imported:
+    return
+
+  class MockMcpClientSession(McpClientSession):
+
+    def __init__(self):
+      self._read_stream = None
+      self._write_stream = None
+
+    async def list_tools(self):
+      return mcp_types.ListToolsResult(
+          tools=[
+              mcp_types.Tool(
+                  name='tool',
+                  description='tool-description',
+                  inputSchema={
+                      'type': 'OBJECT',
+                      'properties': {
+                          'key1': {
+                              'type': 'STRING',
+                          },
+                          'key2': {
+                              'type': 'NUMBER',
+                          },
+                      },
+                  },
+              )
+          ]
+      )
+
+  def tool():
+    pass
+
+  session = MockMcpClientSession()
+  config = GenerateContentConfig(tools=[tool, session])
+  mcp_to_genai_tool_adapters = {
+      'tool': McpToGenAiToolAdapter(session, [await session.list_tools()]),
+  }
+  with pytest.raises(ValueError):
+    get_function_map(
+        config, mcp_to_genai_tool_adapters, is_caller_method_async=True
+    )

google/genai/tests/afc/test_get_function_response_parts.py

@@ -0,0 +1,277 @@
+# 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 get_function_response_parts."""
+
+import typing
+from typing import Any
+import pytest
+from ..._extra_utils import get_function_response_parts, get_function_response_parts_async
+from ...errors import UnsupportedFunctionError
+from ...types import Candidate
+from ...types import Content
+from ...types import FunctionCall
+from ...types import FunctionResponse
+from ...types import GenerateContentResponse
+from ...types import Part
+
+_is_mcp_imported = False
+if typing.TYPE_CHECKING:
+  from mcp import types as mcp_types
+  from mcp import ClientSession as McpClientSession
+  from ..._adapters import McpToGenAiToolAdapter
+
+  _is_mcp_imported = True
+else:
+  McpClientSession: typing.Type = Any
+  McpToGenAiToolAdapter: typing.Type = Any
+  try:
+    from mcp import types as mcp_types
+    from mcp import ClientSession as McpClientSession
+    from ..._adapters import McpToGenAiToolAdapter
+
+    _is_mcp_imported = True
+  except ImportError:
+    McpClientSession = None
+    McpToGenAiToolAdapter = None
+
+
+def test_integer_value():
+  def func_under_test(a: int) -> int:
+    return a + 1
+
+  response = GenerateContentResponse(
+      candidates=[
+          Candidate(
+              content=Content(
+                  parts=[
+                      Part(
+                          function_call=FunctionCall(
+                              name='func_under_test',
+                              args={'a': 1},
+                          )
+                      )
+                  ]
+              )
+          )
+      ]
+  )
+  function_map = {'func_under_test': func_under_test}
+  expected_parts = [
+      Part(
+          function_response=FunctionResponse(
+              name='func_under_test',
+              response={'result': 2},
+          )
+      )
+  ]
+  actual_parts = get_function_response_parts(response, function_map)
+
+  for actual_part, expected_part in zip(actual_parts, expected_parts):
+    assert actual_part.model_dump_json(
+        exclude_none=True
+    ) == expected_part.model_dump_json(exclude_none=True)
+
+
+def test_float_value():
+  def func_under_test(a: float) -> float:
+    return a + 1.0
+
+  response = GenerateContentResponse(
+      candidates=[
+          Candidate(
+              content=Content(
+                  parts=[
+                      Part(
+                          function_call=FunctionCall(
+                              name='func_under_test',
+                              args={'a': 1.0},
+                          )
+                      )
+                  ]
+              )
+          )
+      ]
+  )
+  function_map = {'func_under_test': func_under_test}
+  expected_parts = [
+      Part(
+          function_response=FunctionResponse(
+              name='func_under_test',
+              response={'result': 2.0},
+          )
+      )
+  ]
+  actual_parts = get_function_response_parts(response, function_map)
+
+  for actual_part, expected_part in zip(actual_parts, expected_parts):
+    assert actual_part.model_dump_json(
+        exclude_none=True
+    ) == expected_part.model_dump_json(exclude_none=True)
+
+
+def test_string_value():
+  def func_under_test(a: str) -> str:
+    return a + '1'
+
+  response = GenerateContentResponse(
+      candidates=[
+          Candidate(
+              content=Content(
+                  parts=[
+                      Part(
+                          function_call=FunctionCall(
+                              name='func_under_test',
+                              args={'a': '1.0'},
+                          )
+                      )
+                  ]
+              )
+          )
+      ]
+  )
+  function_map = {'func_under_test': func_under_test}
+  expected_parts = [
+      Part(
+          function_response=FunctionResponse(
+              name='func_under_test',
+              response={'result': '1.01'},
+          )
+      )
+  ]
+  actual_parts = get_function_response_parts(response, function_map)
+
+  for actual_part, expected_part in zip(actual_parts, expected_parts):
+    assert actual_part.model_dump_json(
+        exclude_none=True
+    ) == expected_part.model_dump_json(exclude_none=True)
+
+
+@pytest.mark.asyncio
+async def test_mcp_tool():
+  if not _is_mcp_imported:
+    return
+
+  class MockMcpClientSession(McpClientSession):
+
+    def __init__(self):
+      self._read_stream = None
+      self._write_stream = None
+
+    async def call_tool(self, name: str, arguments: dict[str, Any]) -> Any:
+      return mcp_types.CallToolResult(
+          content=[mcp_types.TextContent(type='text', text='1.01')]
+      )
+
+  mcp_to_genai_tool_adapter = McpToGenAiToolAdapter(
+      session=MockMcpClientSession(),
+      list_tools_result=mcp_types.ListToolsResult(tools=[]),
+  )
+  response = GenerateContentResponse(
+      candidates=[
+          Candidate(
+              content=Content(
+                  parts=[
+                      Part(
+                          function_call=FunctionCall(
+                              name='tool',
+                              args={'key1': 'value1', 'key2': 1},
+                          )
+                      )
+                  ]
+              )
+          )
+      ]
+  )
+  function_map = {'tool': mcp_to_genai_tool_adapter}
+  expected_parts = [
+      Part(
+          function_response=FunctionResponse(
+              name='tool',
+              response={
+                  'result': {
+                      'content': [{'type': 'text', 'text': '1.01'}],
+                      'isError': False,
+                  }
+              },
+          )
+      )
+  ]
+  actual_parts = await get_function_response_parts_async(response, function_map)
+
+  for actual_part, expected_part in zip(actual_parts, expected_parts):
+    assert actual_part.model_dump_json(
+        exclude_none=True
+    ) == expected_part.model_dump_json(exclude_none=True)
+
+
+@pytest.mark.asyncio
+async def test_mcp_tool_error():
+  if not _is_mcp_imported:
+    return
+
+  class MockMcpClientSession(McpClientSession):
+
+    def __init__(self):
+      self._read_stream = None
+      self._write_stream = None
+
+    async def call_tool(self, name: str, arguments: dict[str, Any]) -> Any:
+      return mcp_types.CallToolResult(
+          content=[mcp_types.TextContent(type='text', text='Internal error')],
+          isError=True,
+      )
+
+  mcp_to_genai_tool_adapter = McpToGenAiToolAdapter(
+      session=MockMcpClientSession(),
+      list_tools_result=mcp_types.ListToolsResult(tools=[]),
+  )
+  response = GenerateContentResponse(
+      candidates=[
+          Candidate(
+              content=Content(
+                  parts=[
+                      Part(
+                          function_call=FunctionCall(
+                              name='tool',
+                              args={'key1': 'value1', 'key2': 1},
+                          )
+                      )
+                  ]
+              )
+          )
+      ]
+  )
+  function_map = {'tool': mcp_to_genai_tool_adapter}
+  expected_parts = [
+      Part(
+          function_response=FunctionResponse(
+              name='tool',
+              response={
+                  'error': {
+                      'content': [{'type': 'text', 'text': 'Internal error'}],
+                      'isError': True,
+                  }
+              },
+          )
+      )
+  ]
+  actual_parts = await get_function_response_parts_async(response, function_map)
+
+  for actual_part, expected_part in zip(actual_parts, expected_parts):
+    assert actual_part.model_dump_json(
+        exclude_none=True
+    ) == expected_part.model_dump_json(exclude_none=True)

google/genai/tests/afc/test_get_max_remote_calls_for_afc.py

@@ -0,0 +1,130 @@
+# 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 get_max_remote_calls_for_afc."""
+
+from ... import types
+from ..._extra_utils import get_max_remote_calls_afc
+import pytest
+
+
+def test_config_is_none():
+  assert get_max_remote_calls_afc(None) == 10
+
+
+def test_afc_unset_max_unset():
+  assert get_max_remote_calls_afc(types.GenerateContentConfig()) == 10
+
+
+def test_afc_unset_max_set():
+  assert (
+      get_max_remote_calls_afc(
+          types.GenerateContentConfig(
+              automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                  maximum_remote_calls=20,
+              ),
+          )
+      )
+      == 20
+  )
+
+
+def test_afc_disabled_max_unset():
+  with pytest.raises(ValueError):
+      get_max_remote_calls_afc(
+          types.GenerateContentConfig(
+              automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                  disable=True,
+              ),
+          )
+      )
+
+
+def test_afc_disabled_max_set():
+  with pytest.raises(ValueError):
+    get_max_remote_calls_afc(
+        types.GenerateContentConfig(
+            automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                disable=True,
+                maximum_remote_calls=20,
+            ),
+        )
+    )
+
+
+def test_afc_d_max_unset():
+  assert (
+      get_max_remote_calls_afc(
+          types.GenerateContentConfig(
+              automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                  disable=False,
+              ),
+          )
+      )
+      == 10
+  )
+
+
+def test_afc_d_max_set():
+  assert (
+      get_max_remote_calls_afc(
+          types.GenerateContentConfig(
+              automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                  disable=False,
+                  maximum_remote_calls=5,
+              ),
+          )
+      )
+      == 5
+  )
+
+
+def test_afc_enabled_max_set_to_zero():
+  with pytest.raises(ValueError):
+    get_max_remote_calls_afc(
+        types.GenerateContentConfig(
+          automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                disable=False,
+                maximum_remote_calls=0,
+            ),
+        )
+    )
+
+
+def test_afc_enabled_max_set_to_negative():
+  with pytest.raises(ValueError):
+    get_max_remote_calls_afc(
+        types.GenerateContentConfig(
+            automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                disable=False,
+                maximum_remote_calls=-1,
+            ),
+        )
+    )
+
+
+def test_afc_enabled_max_set_to_float():
+  assert (
+      get_max_remote_calls_afc(
+          types.GenerateContentConfig(
+              automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                  disable=False,
+                  maximum_remote_calls=5.0,
+              ),
+          )
+      )
+      == 5
+  )