Skip to content

Build and run agents you can see, understand and trust.

feat(model): add Gemini 4 Argon and Carbon support (#3675)

qbc3fef100ee13d
diff --git a/pyproject.toml b/pyproject.toml
index 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.py
index 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, Type
from pydantic import BaseModel, Field
+from ..._logging import logger
from ..._utils._common import _generate_id, _flatten_json_schema
from .._base import ChatModelBase, _TOOL_CHOICE_LITERAL_MODES
from .._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 is
enabled.
"""
- 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.yaml
index 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: 1048576
output_size: 65536
parameter_overrides:
+ thinking_level:
+ hidden: true
max_tokens:
maximum: 65536
diff --git a/src/agentscope/model/_gemini/_models/gemini-2.5-flash.yaml b/src/agentscope/model/_gemini/_models/gemini-2.5-flash.yaml
index 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: 1048576
output_size: 65536
parameter_overrides:
+ thinking_level:
+ hidden: true
max_tokens:
maximum: 65536
diff --git a/src/agentscope/model/_gemini/_models/gemini-2.5-pro.yaml b/src/agentscope/model/_gemini/_models/gemini-2.5-pro.yaml
index 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: 1048576
output_size: 65536
parameter_overrides:
+ thinking_level:
+ hidden: true
max_tokens:
maximum: 65536
diff --git a/src/agentscope/model/_gemini/_models/gemini-3-flash-preview.yaml b/src/agentscope/model/_gemini/_models/gemini-3-flash-preview.yaml
index 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: 1048576
output_size: 65536
parameter_overrides:
+ thinking_level:
+ hidden: true
max_tokens:
maximum: 65536
diff --git a/src/agentscope/model/_gemini/_models/gemini-3.1-flash-lite.yaml b/src/agentscope/model/_gemini/_models/gemini-3.1-flash-lite.yaml
index 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: 1048576
output_size: 65536
parameter_overrides:
+ thinking_level:
+ hidden: true
max_tokens:
maximum: 65536
diff --git a/src/agentscope/model/_gemini/_models/gemini-3.1-pro-preview.yaml b/src/agentscope/model/_gemini/_models/gemini-3.1-pro-preview.yaml
index 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: 1048576
output_size: 65536
parameter_overrides:
+ thinking_level:
+ hidden: true
max_tokens:
maximum: 65536
diff --git a/src/agentscope/model/_gemini/_models/gemini-3.5-flash-lite.yaml b/src/agentscope/model/_gemini/_models/gemini-3.5-flash-lite.yaml
index 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: 1048576
output_size: 65536
parameter_overrides:
+ thinking_level:
+ hidden: true
max_tokens:
maximum: 65536
diff --git a/src/agentscope/model/_gemini/_models/gemini-3.5-flash.yaml b/src/agentscope/model/_gemini/_models/gemini-3.5-flash.yaml
index 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: 1048576
output_size: 65536
parameter_overrides:
+ thinking_level:
+ hidden: true
max_tokens:
maximum: 65536
diff --git a/src/agentscope/model/_gemini/_models/gemini-3.6-flash.yaml b/src/agentscope/model/_gemini/_models/gemini-3.6-flash.yaml
index 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: 1048576
output_size: 65536
parameter_overrides:
+ thinking_level:
+ hidden: true
max_tokens:
maximum: 65536
diff --git a/src/agentscope/model/_gemini/_models/gemini-3.7-flash.yaml b/src/agentscope/model/_gemini/_models/gemini-3.7-flash.yaml
index 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: 1048576
output_size: 65536
parameter_overrides:
+ thinking_level:
+ hidden: true
max_tokens:
maximum: 65536
diff --git a/src/agentscope/model/_gemini/_models/gemini-3.8-flash.yaml b/src/agentscope/model/_gemini/_models/gemini-3.8-flash.yaml
index 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: 1048576
output_size: 65536
parameter_overrides:
+ thinking_level:
+ hidden: true
max_tokens:
maximum: 65536
diff --git a/src/agentscope/model/_gemini/_models/gemini-4-argon.yaml b/src/agentscope/model/_gemini/_models/gemini-4-argon.yaml
new file mode 100644
index 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: true
diff --git a/src/agentscope/model/_gemini/_models/gemini-4-carbon.yaml b/src/agentscope/model/_gemini/_models/gemini-4-carbon.yaml
new file mode 100644
index 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: true
diff --git a/tests/model_gemini_test.py b/tests/model_gemini_test.py
index a7c058944..e001df908 100644
--- a/tests/model_gemini_test.py
+++ b/tests/model_gemini_test.py
@@ -12,8 +12,9 @@ from types import SimpleNamespace
from typing import Any, Annotated, Literal
import unittest
from unittest import IsolatedAsyncioTestCase
-from unittest.mock import AsyncMock, MagicMock, patch
+from unittest.mock import AsyncMock, MagicMock, call, patch
+from google.genai.types import HttpOptions, ThinkingConfig
from pydantic import BaseModel, Field
from 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!")]