Build and run agents you can see, understand and trust.
Python agentchatbotlarge-language-modelsllmllm-agentmcpmulti-agentmulti-modalreact-agentrealtime-agentvoice-agentvoice-assistant
feat(model): add Gemini 4 Argon and Carbon support (#3675)
qbc3fef100ee13d
diff --git a/pyproject.toml b/pyproject.tomlindex 8b6dc66bb..d9b70bd0f 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -53,7 +53,7 @@ dependencies = [[project.optional-dependencies]# ------------ Model APIs -------------model-gemini = ["google-genai>=2.25.0"]+model-gemini = ["google-genai>=2.30.1"]model-ollama = ["ollama>=0.5.4"]model-xai = ["xai-sdk"]classifier-jev = ["typesafe-sdk>=0.7"]diff --git a/src/agentscope/model/_gemini/_model.py b/src/agentscope/model/_gemini/_model.pyindex f04859a28..96f578f7a 100644--- a/src/agentscope/model/_gemini/_model.py+++ b/src/agentscope/model/_gemini/_model.py@@ -7,6 +7,7 @@ from typing import Literal, Any, AsyncGenerator, TYPE_CHECKING, List, Typefrom pydantic import BaseModel, Field+from ..._logging import loggerfrom ..._utils._common import _generate_id, _flatten_json_schemafrom .._base import ChatModelBase, _TOOL_CHOICE_LITERAL_MODESfrom .._content_block import _enum_name@@ -228,8 +229,9 @@ class GeminiChatModel(ChatModelBase):default=None,title="Thinking",description="Whether to enable thinking output."- " When None, no ``thinking_config`` is sent and the"- " model's default behavior applies.",+ " When no thinking settings are supplied, the model's"+ " default behavior applies. For Gemini 4 Argon and Carbon,"+ " this controls summaries only, not reasoning itself.",)thinking_budget: int | None = Field(@@ -239,6 +241,13 @@ class GeminiChatModel(ChatModelBase):gt=0,)+ thinking_level: Literal["low", "medium", "high"] | None = Field(+ default=None,+ title="Thinking Level",+ description="The reasoning effort for Gemini 4 Argon and Carbon."+ " When unset, the model defaults to medium.",+ )+temperature: float | None = Field(default=None,title="Temperature",@@ -314,10 +323,21 @@ class GeminiChatModel(ChatModelBase):raise_on_content_filter=raise_on_content_filter,)self.formatter = formatter or GeminiChatFormatter()- self.client_kwargs = client_kwargs or {}+ self.client_kwargs = dict(client_kwargs or {})from google import genai+ if self._is_gemini_4(model):+ http_options = genai.types.HttpOptions.model_validate(+ self.client_kwargs.get("http_options") or {},+ )+ # Preserve zero: the SDK uses it to disable client timeouts.+ if http_options.timeout is None:+ http_options = http_options.model_copy(+ update={"timeout": 900_000},+ )+ self.client_kwargs["http_options"] = http_options+self.client: genai.Client = genai.Client(api_key=self.credential.api_key.get_secret_value(),**self.client_kwargs,@@ -334,6 +354,56 @@ class GeminiChatModel(ChatModelBase):# rare 4xx like auth/bad-request a few times.return (errors.APIError,)+ @staticmethod+ def _is_gemini_4(model_name: str) -> bool:+ """Match supported Gemini 4 IDs, including qualified API names."""+ return model_name.rsplit("/", 1)[-1] in (+ "gemini-4-argon",+ "gemini-4-carbon",+ )++ @staticmethod+ def _prepare_gemini_4_config(config: dict[str, Any]) -> None:+ """Validate the final config and omit ignored sampling settings."""+ from google.genai.types import ThinkingConfig++ thinking = config.get("thinking_config")+ if thinking is not None:+ # The SDK normalizes nested aliases and rejects duplicate names.+ thinking = ThinkingConfig.model_validate(thinking).model_dump(+ exclude_none=True,+ )+ if thinking.get("thinking_budget") is not None:+ raise ValueError(+ "Gemini 4 Argon and Carbon require thinking_level "+ "instead of thinking_budget.",+ )+ level = thinking.get("thinking_level")+ if level is not None:+ level = level.upper()+ if level not in ("LOW", "MEDIUM", "HIGH"):+ raise ValueError(+ "Gemini 4 Argon and Carbon thinking_level must be "+ "low, medium, or high.",+ )+ thinking["thinking_level"] = level+ config["thinking_config"] = thinking++ max_tokens = config.get("max_output_tokens")+ if max_tokens is not None and max_tokens > 65_536:+ raise ValueError(+ "Gemini 4 Argon and Carbon max_output_tokens must not "+ "exceed 65536; long decode is not supported by this "+ "adapter yet.",+ )+ for key in ("temperature", "top_p", "top_k"):+ if config.pop(key, None) is not None:+ logger.warning(+ "Gemini 4 Argon and Carbon ignore %s; "+ "the parameter will not be sent.",+ key,+ )+async def _call_api(self,model_name: str,@@ -362,8 +432,6 @@ class GeminiChatModel(ChatModelBase):generator of ``ChatResponse`` objects when streaming isenabled."""- formatted_messages = await self.formatter.format(messages)-config: dict[str, Any] = {}if self.parameters.max_tokens is not None:@@ -375,7 +443,23 @@ class GeminiChatModel(ChatModelBase):if self.parameters.top_p is not None:config["top_p"] = self.parameters.top_p- if self.parameters.thinking_enable is not None:+ is_gemini_4 = self._is_gemini_4(model_name)+ if is_gemini_4:+ thinking = {}+ if self.parameters.thinking_enable is not None:+ thinking["include_thoughts"] = self.parameters.thinking_enable+ if self.parameters.thinking_level is not None:+ thinking["thinking_level"] = self.parameters.thinking_level+ if self.parameters.thinking_budget is not None:+ thinking["thinking_budget"] = self.parameters.thinking_budget+ if thinking:+ config["thinking_config"] = thinking+ elif self.parameters.thinking_level is not None:+ raise ValueError(+ "The thinking_level parameter is currently supported only "+ "for Gemini 4 Argon and Carbon in this adapter.",+ )+ elif self.parameters.thinking_enable is not None:if self.parameters.thinking_enable:config["thinking_config"] = {"include_thoughts": True,@@ -387,8 +471,25 @@ class GeminiChatModel(ChatModelBase):"thinking_budget": 0,}+ # Normalize aliases before merging so per-call values take precedence.+ if is_gemini_4:+ for alias, name in {+ "thinkingConfig": "thinking_config",+ "maxOutputTokens": "max_output_tokens",+ "topP": "top_p",+ "topK": "top_k",+ }.items():+ if alias in config_kwargs:+ if name in config_kwargs:+ raise ValueError(+ f"Cannot supply both {alias} and {name}.",+ )+ config_kwargs[name] = config_kwargs.pop(alias)+# Per-call config takes precedence over model-level defaults.config.update(config_kwargs)+ if is_gemini_4:+ self._prepare_gemini_4_config(config)fmt_tools, fmt_tool_choice = self._format_tools(tools, tool_choice)@@ -398,6 +499,9 @@ class GeminiChatModel(ChatModelBase):if fmt_tool_choice is not None:config["tool_config"] = fmt_tool_choice+ # Validate config before formatting can read or download media.+ formatted_messages = await self.formatter.format(messages)+kwargs: dict[str, Any] = {"model": model_name,"contents": formatted_messages,diff --git a/src/agentscope/model/_gemini/_models/gemini-2.5-flash-lite.yaml b/src/agentscope/model/_gemini/_models/gemini-2.5-flash-lite.yamlindex 08ee25c3a..4fb7de525 100644--- a/src/agentscope/model/_gemini/_models/gemini-2.5-flash-lite.yaml+++ b/src/agentscope/model/_gemini/_models/gemini-2.5-flash-lite.yaml@@ -21,5 +21,7 @@ context_size: 1048576output_size: 65536parameter_overrides:+ thinking_level:+ hidden: truemax_tokens:maximum: 65536diff --git a/src/agentscope/model/_gemini/_models/gemini-2.5-flash.yaml b/src/agentscope/model/_gemini/_models/gemini-2.5-flash.yamlindex 318f69c30..6a018916a 100644--- a/src/agentscope/model/_gemini/_models/gemini-2.5-flash.yaml+++ b/src/agentscope/model/_gemini/_models/gemini-2.5-flash.yaml@@ -22,5 +22,7 @@ context_size: 1048576output_size: 65536parameter_overrides:+ thinking_level:+ hidden: truemax_tokens:maximum: 65536diff --git a/src/agentscope/model/_gemini/_models/gemini-2.5-pro.yaml b/src/agentscope/model/_gemini/_models/gemini-2.5-pro.yamlindex abbb9a64d..ebba39a69 100644--- a/src/agentscope/model/_gemini/_models/gemini-2.5-pro.yaml+++ b/src/agentscope/model/_gemini/_models/gemini-2.5-pro.yaml@@ -22,5 +22,7 @@ context_size: 1048576output_size: 65536parameter_overrides:+ thinking_level:+ hidden: truemax_tokens:maximum: 65536diff --git a/src/agentscope/model/_gemini/_models/gemini-3-flash-preview.yaml b/src/agentscope/model/_gemini/_models/gemini-3-flash-preview.yamlindex 954f462e4..d899bab57 100644--- a/src/agentscope/model/_gemini/_models/gemini-3-flash-preview.yaml+++ b/src/agentscope/model/_gemini/_models/gemini-3-flash-preview.yaml@@ -21,5 +21,7 @@ context_size: 1048576output_size: 65536parameter_overrides:+ thinking_level:+ hidden: truemax_tokens:maximum: 65536diff --git a/src/agentscope/model/_gemini/_models/gemini-3.1-flash-lite.yaml b/src/agentscope/model/_gemini/_models/gemini-3.1-flash-lite.yamlindex 2ea92bb23..65f8a0a22 100644--- a/src/agentscope/model/_gemini/_models/gemini-3.1-flash-lite.yaml+++ b/src/agentscope/model/_gemini/_models/gemini-3.1-flash-lite.yaml@@ -21,5 +21,7 @@ context_size: 1048576output_size: 65536parameter_overrides:+ thinking_level:+ hidden: truemax_tokens:maximum: 65536diff --git a/src/agentscope/model/_gemini/_models/gemini-3.1-pro-preview.yaml b/src/agentscope/model/_gemini/_models/gemini-3.1-pro-preview.yamlindex 4040646c1..48145b57b 100644--- a/src/agentscope/model/_gemini/_models/gemini-3.1-pro-preview.yaml+++ b/src/agentscope/model/_gemini/_models/gemini-3.1-pro-preview.yaml@@ -21,5 +21,7 @@ context_size: 1048576output_size: 65536parameter_overrides:+ thinking_level:+ hidden: truemax_tokens:maximum: 65536diff --git a/src/agentscope/model/_gemini/_models/gemini-3.5-flash-lite.yaml b/src/agentscope/model/_gemini/_models/gemini-3.5-flash-lite.yamlindex 09b1e6d4a..a360b5a02 100644--- a/src/agentscope/model/_gemini/_models/gemini-3.5-flash-lite.yaml+++ b/src/agentscope/model/_gemini/_models/gemini-3.5-flash-lite.yaml@@ -21,5 +21,7 @@ context_size: 1048576output_size: 65536parameter_overrides:+ thinking_level:+ hidden: truemax_tokens:maximum: 65536diff --git a/src/agentscope/model/_gemini/_models/gemini-3.5-flash.yaml b/src/agentscope/model/_gemini/_models/gemini-3.5-flash.yamlindex 037ca634c..468cc787f 100644--- a/src/agentscope/model/_gemini/_models/gemini-3.5-flash.yaml+++ b/src/agentscope/model/_gemini/_models/gemini-3.5-flash.yaml@@ -21,5 +21,7 @@ context_size: 1048576output_size: 65536parameter_overrides:+ thinking_level:+ hidden: truemax_tokens:maximum: 65536diff --git a/src/agentscope/model/_gemini/_models/gemini-3.6-flash.yaml b/src/agentscope/model/_gemini/_models/gemini-3.6-flash.yamlindex 1c48e87fb..56aa002eb 100644--- a/src/agentscope/model/_gemini/_models/gemini-3.6-flash.yaml+++ b/src/agentscope/model/_gemini/_models/gemini-3.6-flash.yaml@@ -21,5 +21,7 @@ context_size: 1048576output_size: 65536parameter_overrides:+ thinking_level:+ hidden: truemax_tokens:maximum: 65536diff --git a/src/agentscope/model/_gemini/_models/gemini-3.7-flash.yaml b/src/agentscope/model/_gemini/_models/gemini-3.7-flash.yamlindex b4be6bf9f..8ac13bfcf 100644--- a/src/agentscope/model/_gemini/_models/gemini-3.7-flash.yaml+++ b/src/agentscope/model/_gemini/_models/gemini-3.7-flash.yaml@@ -21,5 +21,7 @@ context_size: 1048576output_size: 65536parameter_overrides:+ thinking_level:+ hidden: truemax_tokens:maximum: 65536diff --git a/src/agentscope/model/_gemini/_models/gemini-3.8-flash.yaml b/src/agentscope/model/_gemini/_models/gemini-3.8-flash.yamlindex bc1fd14fe..3bdba3b16 100644--- a/src/agentscope/model/_gemini/_models/gemini-3.8-flash.yaml+++ b/src/agentscope/model/_gemini/_models/gemini-3.8-flash.yaml@@ -21,5 +21,7 @@ context_size: 1048576output_size: 65536parameter_overrides:+ thinking_level:+ hidden: truemax_tokens:maximum: 65536diff --git a/src/agentscope/model/_gemini/_models/gemini-4-argon.yaml b/src/agentscope/model/_gemini/_models/gemini-4-argon.yamlnew file mode 100644index 000000000..44d63b316--- /dev/null+++ b/src/agentscope/model/_gemini/_models/gemini-4-argon.yaml@@ -0,0 +1,36 @@+name: gemini-4-argon+label: Gemini 4 Argon+status: active++input_types:+ - text/plain+ - image/jpeg+ - image/png+ - image/gif+ - image/webp+ - audio/mp3+ - audio/wav+ - video/mp4+ - application/pdf++output_types:+ - text/plain+ - application/x-thinking++# Input, thinking, and output share this window.+context_size: 1048576+# Long decode requires separate continuation support.+output_size: 65536++parameter_overrides:+ thinking_enable:+ title: Thought Summaries+ description: Show reasoning summaries; this does not disable reasoning.+ thinking_level:+ default: medium+ thinking_budget:+ hidden: true+ temperature:+ hidden: true+ top_p:+ hidden: truediff --git a/src/agentscope/model/_gemini/_models/gemini-4-carbon.yaml b/src/agentscope/model/_gemini/_models/gemini-4-carbon.yamlnew file mode 100644index 000000000..8f8e89601--- /dev/null+++ b/src/agentscope/model/_gemini/_models/gemini-4-carbon.yaml@@ -0,0 +1,36 @@+name: gemini-4-carbon+label: Gemini 4 Carbon+status: active++input_types:+ - text/plain+ - image/jpeg+ - image/png+ - image/gif+ - image/webp+ - audio/mp3+ - audio/wav+ - video/mp4+ - application/pdf++output_types:+ - text/plain+ - application/x-thinking++# Input, thinking, and output share this window.+context_size: 1048576+# Long decode requires separate continuation support.+output_size: 65536++parameter_overrides:+ thinking_enable:+ title: Thought Summaries+ description: Show reasoning summaries; this does not disable reasoning.+ thinking_level:+ default: medium+ thinking_budget:+ hidden: true+ temperature:+ hidden: true+ top_p:+ hidden: truediff --git a/tests/model_gemini_test.py b/tests/model_gemini_test.pyindex a7c058944..e001df908 100644--- a/tests/model_gemini_test.py+++ b/tests/model_gemini_test.py@@ -12,8 +12,9 @@ from types import SimpleNamespacefrom typing import Any, Annotated, Literalimport unittestfrom unittest import IsolatedAsyncioTestCase-from unittest.mock import AsyncMock, MagicMock, patch+from unittest.mock import AsyncMock, MagicMock, call, patch+from google.genai.types import HttpOptions, ThinkingConfigfrom pydantic import BaseModel, Fieldfrom utils import AnyString@@ -132,6 +133,313 @@ class _MockAsyncStream:return chunk+# ---------------------------------------------------------------------------+# Gemini 4 configuration tests+# ---------------------------------------------------------------------------+++class TestGemini4Argon(IsolatedAsyncioTestCase):+ """Verify Gemini 4 requests and configuration without network access."""++ model_name = "gemini-4-argon"+ model_label = "Gemini 4 Argon"++ def setUp(self) -> None:+ with patch("google.genai.Client"):+ self.model = GeminiChatModel(+ credential=GeminiCredential(api_key="test"),+ model=self.model_name,+ stream=False,+ )++ async def test_request_parameters(self) -> None:+ """Check defaults, levels, summaries, and per-call overrides."""+ cases: list[tuple[dict[str, Any], dict[str, Any], dict[str, Any]]] = [+ ({}, {}, {}),+ (+ {"thinking_enable": False},+ {},+ {"thinking_config": {"include_thoughts": False}},+ ),+ ]+ for level in ("low", "medium", "high"):+ cases.append(+ (+ {"thinking_level": level, "thinking_enable": True},+ {},+ {+ "thinking_config": {+ "thinking_level": level.upper(),+ "include_thoughts": True,+ },+ },+ ),+ )+ cases.append(+ (+ {"thinking_budget": 1024, "max_tokens": 100_000},+ {+ "thinking_config": ThinkingConfig(thinking_level="LOW"),+ "max_output_tokens": 65_536,+ "temperature": 0.2,+ "top_p": 0.3,+ "top_k": 20,+ },+ {+ "thinking_config": {"thinking_level": "LOW"},+ "max_output_tokens": 65_536,+ },+ ),+ )+ cases.extend(+ [+ (+ {"thinking_budget": 1024, "max_tokens": 100_000},+ {"thinkingConfig": None, "maxOutputTokens": None},+ {"thinking_config": None, "max_output_tokens": None},+ ),+ (+ {"thinking_level": "high", "max_tokens": 100_000},+ {+ "thinkingConfig": {"thinkingLevel": "LOW"},+ "maxOutputTokens": 65_536,+ "topP": 0.3,+ "topK": 20,+ },+ {+ "thinking_config": {"thinking_level": "LOW"},+ "max_output_tokens": 65_536,+ },+ ),+ ],+ )+ for stream in (False, True):+ for parameters, overrides, expected in cases:+ with self.subTest(stream=stream, parameters=parameters):+ self.model.stream = stream+ self.model.parameters = GeminiChatModel.Parameters(+ **parameters,+ )+ api = AsyncMock(return_value=_mock_completion([]))+ stream_api = AsyncMock(return_value=_MockAsyncStream([]))+ self.model.client.aio.models.generate_content = api+ self.model.client.aio.models.generate_content_stream = (+ stream_api+ )+ response = await self.model([], **overrides)+ if stream:+ async for _ in response:+ pass+ expected_calls = [+ call(+ model=self.model_name,+ contents=[],+ config=expected,+ ),+ ]+ self.assertEqual(+ api.await_args_list,+ [] if stream else expected_calls,+ )+ self.assertEqual(+ stream_api.await_args_list,+ expected_calls if stream else [],+ )++ async def test_ignored_sampling_parameters_warn(self) -> None:+ """Warn for non-null sampling values from either config source."""+ cases = [+ (+ {"temperature": 0.2, "top_p": 0.3},+ {},+ ["temperature", "top_p"],+ ),+ (+ {},+ {"temperature": 0, "topP": 0.3, "topK": 20},+ ["temperature", "top_p", "top_k"],+ ),+ (+ {"temperature": 0.2, "top_p": 0.3},+ {"temperature": None, "topP": None, "topK": None},+ [],+ ),+ ]+ for parameters, overrides, ignored in cases:+ with self.subTest(parameters=parameters, overrides=overrides):+ self.model.parameters = GeminiChatModel.Parameters(+ **parameters,+ )+ api = AsyncMock(return_value=_mock_completion([]))+ self.model.client.aio.models.generate_content = api+ with patch(+ "agentscope.model._gemini._model.logger.warning",+ ) as warning:+ await self.model([], **overrides)+ self.assertEqual(+ warning.call_args_list,+ [+ call(+ "Gemini 4 Argon and Carbon ignore %s; "+ "the parameter will not be sent.",+ key,+ )+ for key in ignored+ ],+ )+ self.assertEqual(+ api.await_args_list,+ [call(model=self.model_name, contents=[], config={})],+ )++ async def test_invalid_config_never_reaches_api(self) -> None:+ """Reject unsupported budgets, reasoning levels, and long decode."""+ cases: list[tuple[dict[str, Any], dict[str, Any], str]] = [+ ({"thinking_budget": 1024}, {}, "thinking_budget"),+ ({}, {"thinking_config": {"thinking_budget": 0}}, "budget"),+ ({}, {"thinking_config": {"thinkingBudget": 100}}, "budget"),+ ({}, {"thinkingConfig": {"thinkingBudget": 100}}, "budget"),+ (+ {},+ {"thinking_config": {"thinking_level": "MINIMAL"}},+ "thinking_level",+ ),+ ({"max_tokens": 65_537}, {}, "65536"),+ ({}, {"max_output_tokens": 65_537}, "65536"),+ ({}, {"maxOutputTokens": 65_537}, "65536"),+ (+ {},+ {"thinkingConfig": {"thinkingLevel": "MINIMAL"}},+ "thinking_level",+ ),+ ]+ for alias, name in (+ ("thinkingConfig", "thinking_config"),+ ("maxOutputTokens", "max_output_tokens"),+ ("topP", "top_p"),+ ("topK", "top_k"),+ ):+ cases.append(({}, {alias: None, name: None}, name))+ for alias, name, value in (+ ("thinkingBudget", "thinking_budget", 1024),+ ("thinkingLevel", "thinking_level", "LOW"),+ ("includeThoughts", "include_thoughts", True),+ ):+ cases.append(+ ({}, {"thinking_config": {alias: value, name: value}}, name),+ )+ self.model.formatter = MagicMock()+ self.model.formatter.format = AsyncMock(return_value=[])+ for stream in (False, True):+ self.model.stream = stream+ for parameters, kwargs, message in cases:+ with self.subTest(+ stream=stream,+ parameters=parameters,+ **kwargs,+ ):+ self.model.parameters = GeminiChatModel.Parameters(+ **parameters,+ )+ self.model.client.reset_mock()+ with self.assertRaisesRegex(ValueError, message):+ await self.model([], **kwargs)+ self.assertEqual(self.model.client.mock_calls, [])+ self.assertEqual(self.model.formatter.mock_calls, [])++ def test_timeout_does_not_mutate_shared_client_options(self) -> None:+ """Keep model defaults local for dict and SDK HTTP options."""+ cases: list[tuple[dict[str, Any] | HttpOptions, int]] = [+ ({"timeout": None}, 900_000),+ (HttpOptions(), 900_000),+ ({"timeout": 1234}, 1234),+ ({"timeout": 0}, 0),+ (HttpOptions(timeout=0), 0),+ ]+ for options, expected_timeout in cases:+ with self.subTest(options=options):+ shared = {"http_options": options}+ before = copy.deepcopy(shared)+ with patch("google.genai.Client") as client:+ model = GeminiChatModel(+ credential=GeminiCredential(api_key="test"),+ model=f"models/{self.model_name}",+ client_kwargs=shared,+ )+ self.assertEqual(+ client.call_args.kwargs,+ {+ "api_key": "test",+ "http_options": HttpOptions(+ timeout=expected_timeout,+ ),+ },+ )+ self.assertEqual(shared, before)+ self.assertIsNot(model.client_kwargs, shared)+ GeminiChatModel(+ credential=GeminiCredential(api_key="test"),+ model="gemini-2.5-flash",+ client_kwargs=shared,+ )+ self.assertEqual(+ client.call_args.kwargs,+ {"api_key": "test", **before},+ )+ self.assertEqual(shared, before)++ def test_model_card_parameters(self) -> None:+ """Expose supported controls and hide legacy reasoning settings."""+ cards = {card.name: card for card in GeminiChatModel.list_models()}+ card = cards[self.model_name]+ properties = card.parameter_schema["properties"]+ self.assertEqual(+ {+ "name": card.name,+ "label": card.label,+ "context_size": card.context_size,+ "output_size": card.output_size,+ "parameters": sorted(properties),+ "max_tokens": properties["max_tokens"]["maximum"],+ "thinking_level": properties["thinking_level"]["default"],+ "summary_title": properties["thinking_enable"]["title"],+ },+ {+ "name": self.model_name,+ "label": self.model_label,+ "context_size": 1_048_576,+ "output_size": 65_536,+ "parameters": [+ "max_tokens",+ "thinking_enable",+ "thinking_level",+ ],+ "max_tokens": 65_536,+ "thinking_level": "medium",+ "summary_title": "Thought Summaries",+ },+ )+ self.assertEqual(+ {+ name: "thinking_level" in item.parameter_schema["properties"]+ for name, item in cards.items()+ if name not in ("gemini-4-argon", "gemini-4-carbon")+ },+ {+ name: False+ for name in cards+ if name not in ("gemini-4-argon", "gemini-4-carbon")+ },+ )+++class TestGemini4Carbon(TestGemini4Argon):+ """Run the shared Gemini 4 contract against Carbon as well."""++ model_name = "gemini-4-carbon"+ model_label = "Gemini 4 Carbon"++# ---------------------------------------------------------------------------# Non-streaming tests# ---------------------------------------------------------------------------@@ -147,6 +455,16 @@ class TestGeminiNonStream(IsolatedAsyncioTestCase):self.mock_client = MagicMock()self.model.client = self.mock_client+ async def test_thinking_level_rejected_for_legacy_models(self) -> None:+ """Keep the Gemini 4 reasoning control scoped to supported IDs."""+ self.model.parameters.thinking_level = "low"+ for name in ("gemini-2.5-flash", "gemini-4-carbon-unknown"):+ with self.subTest(model=name):+ self.model.model = name+ with self.assertRaisesRegex(ValueError, "thinking_level"):+ await self.model([])+ self.assertEqual(self.mock_client.mock_calls, [])+async def test_text_response(self) -> None:"""Non-stream text response returns a single ChatResponse."""parts = [_make_part(text="Hello!")]