prompture 1.13.11.dev1__tar.gz → 1.13.12.dev2__tar.gz

{prompture-1.13.11.dev1 → prompture-1.13.12.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 1.13.11.dev1
+Version: 1.13.12.dev2
 Summary: Ask LLMs to return structured JSON and run cross-model tests. API-first.
 Author-email: Juan Denis <juan@vene.co>
 License-Expression: MIT
@@ -24,7 +24,7 @@ Requires-Dist: openai>=1.55.0; extra == "openai"
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.8.0; extra == "anthropic"
 Provides-Extra: google
-Requires-Dist: google-genai>=1.0.0; extra == "google"
+Requires-Dist: google-genai>=1.56.0; extra == "google"
 Provides-Extra: groq
 Requires-Dist: groq>=0.4.0; extra == "groq"
 Provides-Extra: toon
@@ -1751,6 +1751,46 @@ if doc.found:
 
 Both helpers return plain dataclasses with no I/O of their own.  See `examples/assistant_example.py` for the assistant + review-loop + extractor flow end-to-end.
 
+### Gemini 4 Argon
+
+Install or upgrade with `pip install -U "prompture[google]"` and set
+`GOOGLE_API_KEY` to a key for a billing-enabled Gemini API project.
+
+```python
+from prompture import Conversation
+
+conv = Conversation(
+    model_name="google/gemini-4-argon",
+    options={"effort": "medium", "max_tokens": 32768},
+)
+print(conv.ask("Review this design and explain the tradeoffs: ..."))
+```
+
+Use `google_vertexai/gemini-4-argon` for Vertex AI, with
+`GOOGLE_VERTEX_PROJECT_ID`, Application Default Credentials, and
+`GOOGLE_VERTEX_LOCATION=global` (or a supported endpoint for your project).
+Both providers support synchronous and asynchronous conversations, tools,
+structured output, vision, and streaming. Prompture preserves signed Gemini
+response parts in conversation history; callers managing driver history directly
+must copy the response's `_google_parts` onto the corresponding assistant message.
+
+Argon accepts `low`, `medium`, and `high` effort. Prompture maps `none` and
+`minimal` to `low`, and `xhigh` and `max` to `high`; it does not disable thinking.
+Explicit `generation_config.thinking_config` takes precedence. Sampling options
+(`temperature`, `top_p`, `top_k`) are omitted for this model.
+
+`completion_tokens` includes billed thinking tokens; `reasoning_tokens` reports
+that subset. Cached input receives the implicit-cache discount. The local pricing
+catalog uses $2 input / $10 output / $0.10 cached input per million tokens through
+November 30, 2026, then switches to $4 / $20 / $0.20 on December 1 (UTC), without
+requiring a restart. There is no free API tier. See [Google's pricing](https://ai.google.dev/gemini-api/docs/pricing).
+
+The catalog records the normal SDK output limit of 65,536 tokens, shared between
+thinking and the visible answer. The 1,048,576-token context includes input too.
+[Long decode](https://ai.google.dev/gemini-api/docs/generate-content/long-decode)
+requires `google-genai>=2.30.1` and a larger `max_tokens`; the baseline Google extra
+requires `>=1.56.0` for the thinking-level API.
+
 ### Prompt Caching
 
 Prompt caching cuts input-token cost on the repeated prefix to ~10% of the

{prompture-1.13.11.dev1 → prompture-1.13.12.dev2}/README.md

@@ -1632,6 +1632,46 @@ if doc.found:
 
 Both helpers return plain dataclasses with no I/O of their own.  See `examples/assistant_example.py` for the assistant + review-loop + extractor flow end-to-end.
 
+### Gemini 4 Argon
+
+Install or upgrade with `pip install -U "prompture[google]"` and set
+`GOOGLE_API_KEY` to a key for a billing-enabled Gemini API project.
+
+```python
+from prompture import Conversation
+
+conv = Conversation(
+    model_name="google/gemini-4-argon",
+    options={"effort": "medium", "max_tokens": 32768},
+)
+print(conv.ask("Review this design and explain the tradeoffs: ..."))
+```
+
+Use `google_vertexai/gemini-4-argon` for Vertex AI, with
+`GOOGLE_VERTEX_PROJECT_ID`, Application Default Credentials, and
+`GOOGLE_VERTEX_LOCATION=global` (or a supported endpoint for your project).
+Both providers support synchronous and asynchronous conversations, tools,
+structured output, vision, and streaming. Prompture preserves signed Gemini
+response parts in conversation history; callers managing driver history directly
+must copy the response's `_google_parts` onto the corresponding assistant message.
+
+Argon accepts `low`, `medium`, and `high` effort. Prompture maps `none` and
+`minimal` to `low`, and `xhigh` and `max` to `high`; it does not disable thinking.
+Explicit `generation_config.thinking_config` takes precedence. Sampling options
+(`temperature`, `top_p`, `top_k`) are omitted for this model.
+
+`completion_tokens` includes billed thinking tokens; `reasoning_tokens` reports
+that subset. Cached input receives the implicit-cache discount. The local pricing
+catalog uses $2 input / $10 output / $0.10 cached input per million tokens through
+November 30, 2026, then switches to $4 / $20 / $0.20 on December 1 (UTC), without
+requiring a restart. There is no free API tier. See [Google's pricing](https://ai.google.dev/gemini-api/docs/pricing).
+
+The catalog records the normal SDK output limit of 65,536 tokens, shared between
+thinking and the visible answer. The 1,048,576-token context includes input too.
+[Long decode](https://ai.google.dev/gemini-api/docs/generate-content/long-decode)
+requires `google-genai>=2.30.1` and a larger `max_tokens`; the baseline Google extra
+requires `>=1.56.0` for the thinking-level API.
+
 ### Prompt Caching
 
 Prompt caching cuts input-token cost on the repeated prefix to ~10% of the

prompture-1.13.12.dev2/VERSION

@@ -0,0 +1 @@
+1.13.11

{prompture-1.13.11.dev1 → prompture-1.13.12.dev2}/prompture/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.13.11.dev1'
-__version_tuple__ = version_tuple = (1, 13, 11, 'dev1')
+__version__ = version = '1.13.12.dev2'
+__version_tuple__ = version_tuple = (1, 13, 12, 'dev2')
 
 __commit_id__ = commit_id = None

{prompture-1.13.11.dev1 → prompture-1.13.12.dev2}/prompture/agents/async_conversation.py

@@ -160,6 +160,7 @@ class AsyncConversation(ToolContextMixin):
 
         # Reasoning content from last response
         self._last_reasoning: str | None = None
+        self._last_google_parts: list[dict[str, Any]] | None = None
 
         # Optional before_turn hook (sync or async callable). Fires before
         # each driver call inside the tool loop.
@@ -208,6 +209,8 @@ class AsyncConversation(ToolContextMixin):
         msg: dict[str, Any] = {"role": "assistant", "content": content}
         if self._last_reasoning:
             msg["reasoning_content"] = self._last_reasoning
+        if self._last_google_parts is not None:
+            msg["_google_parts"] = self._last_google_parts
         return msg
 
     @property
@@ -550,6 +553,7 @@ class AsyncConversation(ToolContextMixin):
         resp = await self._driver.generate_messages_with_hooks(final_msgs, merged)
         text: str = resp.get("text", "")
         self._last_reasoning = resp.get("reasoning_content")
+        self._last_google_parts = resp.get("_google_parts")
         self._accumulate_usage(resp.get("meta", {}))
         self._messages.append(self._assistant_message(text))
         return text
@@ -601,8 +605,9 @@ class AsyncConversation(ToolContextMixin):
         self._usage["total_tokens"] += delta_tokens
         self._usage["cost"] += delta_cost
         self._usage["turns"] += 1
-        if prompt_tokens:
-            self._last_prompt_tokens = prompt_tokens
+        context_prompt_tokens = meta.get("initial_prompt_tokens", prompt_tokens)
+        if context_prompt_tokens:
+            self._last_prompt_tokens = context_prompt_tokens
         logger.debug(
             "[conversation] usage delta tokens=%d cost=%.6f | running total tokens=%d cost=%.6f turns=%d",
             delta_tokens,
@@ -627,6 +632,7 @@ class AsyncConversation(ToolContextMixin):
         dispatches to the async tool execution loop.
         """
         self._last_reasoning = None
+        self._last_google_parts = None
 
         # Route to appropriate tool handling
         if self._tools:
@@ -648,6 +654,7 @@ class AsyncConversation(ToolContextMixin):
         text: str = resp.get("text", "")
         meta = resp.get("meta", {})
         self._last_reasoning = resp.get("reasoning_content")
+        self._last_google_parts = resp.get("_google_parts")
 
         user_content = self._build_content_with_images(content, images)
         self._messages.append({"role": "user", "content": user_content})
@@ -689,6 +696,7 @@ class AsyncConversation(ToolContextMixin):
 
             if not tool_calls:
                 self._last_reasoning = resp.get("reasoning_content")
+                self._last_google_parts = resp.get("_google_parts")
                 self._messages.append(self._assistant_message(text))
                 return text
 
@@ -711,6 +719,8 @@ class AsyncConversation(ToolContextMixin):
             # on subsequent requests (e.g. Moonshot reasoning models).
             if resp.get("reasoning_content") is not None:
                 assistant_msg["reasoning_content"] = resp["reasoning_content"]
+            if resp.get("_google_parts") is not None:
+                assistant_msg["_google_parts"] = resp["_google_parts"]
 
             self._messages.append(assistant_msg)
             msgs.append(assistant_msg)
@@ -749,6 +759,7 @@ class AsyncConversation(ToolContextMixin):
         :meth:`Conversation.ask_with_tool_events`.
         """
         self._last_reasoning = None
+        self._last_google_parts = None
 
         if not self._tools:
             async for chunk in self.ask_stream(content, options, images=images):
@@ -790,6 +801,7 @@ class AsyncConversation(ToolContextMixin):
 
             if not tool_calls:
                 self._last_reasoning = resp.get("reasoning_content")
+                self._last_google_parts = resp.get("_google_parts")
                 self._messages.append(self._assistant_message(text))
                 yield {"type": "text_delta", "text": text}
                 return
@@ -811,6 +823,8 @@ class AsyncConversation(ToolContextMixin):
             ]
             if resp.get("reasoning_content") is not None:
                 assistant_msg["reasoning_content"] = resp["reasoning_content"]
+            if resp.get("_google_parts") is not None:
+                assistant_msg["_google_parts"] = resp["_google_parts"]
 
             self._messages.append(assistant_msg)
             msgs.append(assistant_msg)
@@ -879,6 +893,7 @@ class AsyncConversation(ToolContextMixin):
         )
 
         self._last_reasoning = None
+        self._last_google_parts = None
 
         if not self._tools:
             async for chunk in self.ask_stream(content, options, images=images):
@@ -934,6 +949,7 @@ class AsyncConversation(ToolContextMixin):
             tool_calls_in_turn: list[dict[str, Any]] = []
             pending_tools: list[dict[str, Any]] = []
             turn_usage: dict[str, Any] = {}
+            google_parts: list[dict[str, Any]] | None = None
 
             tool_defs = self._active_tools().to_openai_format()
             stream = self._driver.generate_messages_with_tools_stream(msgs, tool_defs, merged)
@@ -965,6 +981,7 @@ class AsyncConversation(ToolContextMixin):
                             }
                         )
                     elif et == "message_stop":
+                        google_parts = getattr(event, "provider_state", {}).get("_google_parts")
                         turn_usage = dict(event.usage or {})
                         self._driver._auto_record_usage(
                             {"meta": turn_usage}, (time.perf_counter() - stream_started) * 1000
@@ -1014,6 +1031,9 @@ class AsyncConversation(ToolContextMixin):
             if full_thinking is not None:
                 assistant_msg["reasoning_content"] = full_thinking
                 self._last_reasoning = full_thinking
+            if google_parts is not None:
+                assistant_msg["_google_parts"] = google_parts
+                self._last_google_parts = google_parts
 
             self._messages.append(assistant_msg)
             msgs.append(assistant_msg)
@@ -1296,6 +1316,7 @@ class AsyncConversation(ToolContextMixin):
                     self._accumulate_usage(meta)
                     if chunk.get("reasoning_content"):
                         self._last_reasoning = chunk["reasoning_content"]
+                    self._last_google_parts = chunk.get("_google_parts")
         except Exception as exc:
             stream_error = exc
             elapsed_ms = (time.perf_counter() - t0) * 1000
@@ -1372,6 +1393,7 @@ class AsyncConversation(ToolContextMixin):
 
         self._check_budget()
         self._last_reasoning = None
+        self._last_google_parts = None
 
         merged = {**self._options, **(options or {})}
 
@@ -1436,6 +1458,7 @@ class AsyncConversation(ToolContextMixin):
         text = resp.get("text", "")
         meta = resp.get("meta", {})
         self._last_reasoning = resp.get("reasoning_content")
+        self._last_google_parts = resp.get("_google_parts")
 
         user_content = self._build_content_with_images(content, images)
         self._messages.append({"role": "user", "content": user_content})

{prompture-1.13.11.dev1 → prompture-1.13.12.dev2}/prompture/agents/conversation.py

@@ -160,6 +160,7 @@ class Conversation(ToolContextMixin):
 
         # Reasoning content from last response
         self._last_reasoning: str | None = None
+        self._last_google_parts: list[dict[str, Any]] | None = None
 
         # Optional callback fired before each driver call inside the tool
         # loop. Used by DeepAgent for summarization. The hook receives
@@ -210,6 +211,8 @@ class Conversation(ToolContextMixin):
         msg: dict[str, Any] = {"role": "assistant", "content": content}
         if self._last_reasoning:
             msg["reasoning_content"] = self._last_reasoning
+        if self._last_google_parts is not None:
+            msg["_google_parts"] = self._last_google_parts
         return msg
 
     @property
@@ -554,6 +557,7 @@ class Conversation(ToolContextMixin):
         resp = self._driver.generate_messages_with_hooks(final_msgs, merged)
         text: str = resp.get("text", "")
         self._last_reasoning = resp.get("reasoning_content")
+        self._last_google_parts = resp.get("_google_parts")
         self._accumulate_usage(resp.get("meta", {}))
         self._messages.append(self._assistant_message(text))
         return text
@@ -607,8 +611,9 @@ class Conversation(ToolContextMixin):
         self._usage["turns"] += 1
         # Track most recent prompt size so before_turn hooks know the
         # current context window without recomputing it.
-        if prompt_tokens:
-            self._last_prompt_tokens = prompt_tokens
+        context_prompt_tokens = meta.get("initial_prompt_tokens", prompt_tokens)
+        if context_prompt_tokens:
+            self._last_prompt_tokens = context_prompt_tokens
         logger.debug(
             "[conversation] usage delta tokens=%d cost=%.6f | running total tokens=%d cost=%.6f turns=%d",
             delta_tokens,
@@ -640,6 +645,7 @@ class Conversation(ToolContextMixin):
                 base64 string, or :class:`ImageContent`).
         """
         self._last_reasoning = None
+        self._last_google_parts = None
 
         # Route to appropriate tool handling
         if self._tools:
@@ -661,6 +667,7 @@ class Conversation(ToolContextMixin):
         text: str = resp.get("text", "")
         meta = resp.get("meta", {})
         self._last_reasoning = resp.get("reasoning_content")
+        self._last_google_parts = resp.get("_google_parts")
 
         # Record in history — store content with images for context
         user_content = self._build_content_with_images(content, images)
@@ -705,6 +712,7 @@ class Conversation(ToolContextMixin):
             if not tool_calls:
                 # No tool calls -> final response
                 self._last_reasoning = resp.get("reasoning_content")
+                self._last_google_parts = resp.get("_google_parts")
                 self._messages.append(self._assistant_message(text))
                 return text
 
@@ -728,6 +736,8 @@ class Conversation(ToolContextMixin):
             # on subsequent requests (e.g. Moonshot reasoning models).
             if resp.get("reasoning_content") is not None:
                 assistant_msg["reasoning_content"] = resp["reasoning_content"]
+            if resp.get("_google_parts") is not None:
+                assistant_msg["_google_parts"] = resp["_google_parts"]
 
             self._messages.append(assistant_msg)
             msgs.append(assistant_msg)
@@ -773,6 +783,7 @@ class Conversation(ToolContextMixin):
         provide real-time feedback when tools are registered.
         """
         self._last_reasoning = None
+        self._last_google_parts = None
 
         if not self._tools:
             # No tools — just stream directly
@@ -816,6 +827,7 @@ class Conversation(ToolContextMixin):
             if not tool_calls:
                 # Final response — stream it if possible
                 self._last_reasoning = resp.get("reasoning_content")
+                self._last_google_parts = resp.get("_google_parts")
                 self._messages.append(self._assistant_message(text))
                 # Yield final text as deltas (single chunk since we already have the full text)
                 yield {"type": "text_delta", "text": text}
@@ -839,6 +851,8 @@ class Conversation(ToolContextMixin):
             ]
             if resp.get("reasoning_content") is not None:
                 assistant_msg["reasoning_content"] = resp["reasoning_content"]
+            if resp.get("_google_parts") is not None:
+                assistant_msg["_google_parts"] = resp["_google_parts"]
 
             self._messages.append(assistant_msg)
             msgs.append(assistant_msg)
@@ -919,6 +933,7 @@ class Conversation(ToolContextMixin):
         )
 
         self._last_reasoning = None
+        self._last_google_parts = None
 
         if not self._tools:
             for chunk in self.ask_stream(content, options, images=images):
@@ -974,6 +989,7 @@ class Conversation(ToolContextMixin):
             tool_calls_in_turn: list[dict[str, Any]] = []
             pending_tools: list[dict[str, Any]] = []
             turn_usage: dict[str, Any] = {}
+            google_parts: list[dict[str, Any]] | None = None
             stop_reason: str = "end_turn"
 
             tool_defs = self._active_tools().to_openai_format()
@@ -1006,6 +1022,7 @@ class Conversation(ToolContextMixin):
                             }
                         )
                     elif et == "message_stop":
+                        google_parts = getattr(event, "provider_state", {}).get("_google_parts")
                         turn_usage = dict(event.usage or {})
                         self._driver._auto_record_usage(
                             {"meta": turn_usage}, (time.perf_counter() - stream_started) * 1000
@@ -1056,6 +1073,9 @@ class Conversation(ToolContextMixin):
             if full_thinking is not None:
                 assistant_msg["reasoning_content"] = full_thinking
                 self._last_reasoning = full_thinking
+            if google_parts is not None:
+                assistant_msg["_google_parts"] = google_parts
+                self._last_google_parts = google_parts
 
             self._messages.append(assistant_msg)
             msgs.append(assistant_msg)
@@ -1331,6 +1351,7 @@ class Conversation(ToolContextMixin):
                     self._accumulate_usage(meta)
                     if chunk.get("reasoning_content"):
                         self._last_reasoning = chunk["reasoning_content"]
+                    self._last_google_parts = chunk.get("_google_parts")
         except Exception as exc:
             stream_error = exc
             elapsed_ms = (time.perf_counter() - t0) * 1000
@@ -1496,6 +1517,7 @@ class Conversation(ToolContextMixin):
 
         self._check_budget()
         self._last_reasoning = None
+        self._last_google_parts = None
 
         merged = {**self._options, **(options or {})}
 
@@ -1564,6 +1586,7 @@ class Conversation(ToolContextMixin):
         text = resp.get("text", "")
         meta = resp.get("meta", {})
         self._last_reasoning = resp.get("reasoning_content")
+        self._last_google_parts = resp.get("_google_parts")
 
         # Store original content (without schema boilerplate) for cleaner context
         # Include images in history so subsequent turns can reference them

{prompture-1.13.11.dev1 → prompture-1.13.12.dev2}/prompture/agents/live_events.py

@@ -109,10 +109,12 @@ class MessageStop:
     """End of one assistant turn. ``stop_reason`` uses the shared vocabulary
     (``end_turn``, ``tool_use``, ``max_tokens``, ``content_filter``,
     ``error``); drivers preserve the provider's raw value in
-    ``usage["raw_stop_reason"]``."""
+    ``usage["raw_stop_reason"]``. ``provider_state`` carries opaque, JSON-safe
+    response data that must survive in conversation history for the next turn."""
 
     stop_reason: str
     usage: dict[str, Any] = field(default_factory=dict)
+    provider_state: dict[str, Any] = field(default_factory=dict)
     event_type: Literal["message_stop"] = field(default="message_stop", init=False)
 
 

{prompture-1.13.11.dev1 → prompture-1.13.12.dev2}/prompture/cli/cli.py

@@ -280,9 +280,11 @@ def companion(
     (their model traffic then passes through, or goes to any Prompture model),
     so the companion prefers the same port each time: 47811.
     """
+    import time
+
     from ..companion import Automations, CodingToolSource, CompanionServer, LedgerSource, running_instance
     from ..companion.memory import MemoryService
-    from ..companion.server import DEFAULT_PORT
+    from ..companion.server import DEFAULT_PORT, instance_lock
     from ..companion.tool_routing import ToolRouting
 
     existing = running_instance()
@@ -297,6 +299,21 @@ def companion(
     if existing:
         click.echo(f"Prompture companion already running at {existing['url']} (pid {existing.get('pid')}).")
         return
+    # The quick check above misses a companion that is starting or too busy to
+    # answer in time; the lock doesn't, so two never run side by side.
+    lock = instance_lock()
+    deadline = time.monotonic() + 30
+    while lock is None:
+        existing = running_instance(timeout=5.0)
+        if existing:
+            click.echo(f"Prompture companion already running at {existing['url']} (pid {existing.get('pid')}).")
+            return
+        if time.monotonic() > deadline:
+            raise click.ClickException(
+                "Another Prompture companion is running but not answering; not starting a second one."
+            )
+        time.sleep(0.5)
+        lock = instance_lock()
 
     def make(on_port: int) -> CompanionServer:
         return CompanionServer(

{prompture-1.13.11.dev1 → prompture-1.13.12.dev2}/prompture/companion/server.py

@@ -47,7 +47,7 @@ import secrets
 import threading
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
-from typing import Any
+from typing import IO, Any
 from urllib.parse import parse_qs, unquote, urlparse
 
 from .automations import AutomationError, Automations, roadmap_steps
@@ -63,6 +63,8 @@ from .tool_routing import RoutingError, ToolRouting
 logger = logging.getLogger("prompture.companion")
 
 STATE_FILE = Path.home() / ".prompture" / "companion.json"
+#: Held by the running companion, so a second one never starts next to it.
+LOCK_FILE = Path.home() / ".prompture" / "companion.lock"
 #: The port ``prompture companion`` asks for first, so routed CLIs find it at the same address.
 DEFAULT_PORT = 47811
 HEARTBEAT_SECONDS = 15.0
@@ -845,6 +847,32 @@ def running_instance(path: Path = STATE_FILE, timeout: float = 2.0) -> dict[str,
         conn.close()
 
 
+def instance_lock(path: Path = LOCK_FILE) -> IO[bytes] | None:
+    """Claim the one-companion-per-user lock; ``None`` when another process holds it.
+
+    Keep the returned file open while serving. The OS drops the lock when the
+    process ends, however it ends, so a crash never leaves it stale. Unlike
+    :func:`running_instance` this doesn't depend on a busy companion answering
+    in time, so a slow one is never mistaken for a missing one.
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fh = open(path, "a+b")  # noqa: SIM115 - held open for the life of the process
+    try:
+        if os.name == "nt":
+            import msvcrt
+
+            fh.seek(0)
+            msvcrt.locking(fh.fileno(), msvcrt.LK_NBLCK, 1)
+        else:
+            import fcntl
+
+            fcntl.flock(fh.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except OSError:
+        fh.close()
+        return None
+    return fh
+
+
 def process_alive(pid: int) -> bool:
     """Whether *pid* is a running process (best effort, no extra dependencies)."""
     if pid <= 0:

{prompture-1.13.11.dev1 → prompture-1.13.12.dev2}/prompture/drivers/_effort.py

@@ -8,11 +8,10 @@ the same thing. Each driver family puts it where its API reads it:
 * ``"openai"``: ``reasoning_effort`` on Chat Completions style APIs (OpenAI, Azure, Groq, xAI,
   OpenAI-compatible servers).
 * ``"openrouter"``: ``reasoning.effort``.
-* ``"google"``: ``thinking_config.thinking_level``, which takes only ``low`` and ``high``.
+* ``"google"``: ``thinking_config.thinking_level`` (model-dependent).
 
-The value is passed on as given, so a model that does not take a level answers with the
-provider's own error; the model catalogue lists the levels each model takes
-(``model_rates.get_model_info(...)["reasoning_options"]``).
+Explicit provider-specific fields take precedence. Google maps generic effort to
+the model's thinking levels; other providers validate the supplied value themselves.
 """
 
 from __future__ import annotations
@@ -30,12 +29,14 @@ def requested_effort(options: dict[str, Any] | None) -> str | None:
     return str(value) if value else None
 
 
-def google_thinking_level(effort: str) -> str:
-    """Gemini's two thinking levels for an effort: up to medium is ``low``, above is ``high``."""
+def google_thinking_level(effort: str, model: str = "") -> str:
+    """Map effort without sending unsupported levels to older Gemini models."""
+    if model.removeprefix("models/") == "gemini-4-argon" and effort == "medium":
+        return "medium"
     return "low" if effort in ("none", "minimal", "low", "medium") else "high"
 
 
-def apply_effort(request: dict[str, Any], options: dict[str, Any] | None, style: str) -> None:
+def apply_effort(request: dict[str, Any], options: dict[str, Any] | None, style: str, *, model: str = "") -> None:
     """Put the requested effort into ``request`` the way ``style``'s API takes it."""
     effort = requested_effort(options)
     if effort is None:
@@ -48,7 +49,7 @@ def apply_effort(request: dict[str, Any], options: dict[str, Any] | None, style:
             reasoning.setdefault("effort", effort)
     elif style == "google":
         thinking = request.setdefault("thinking_config", {})
-        if isinstance(thinking, dict):
-            thinking.setdefault("thinking_level", google_thinking_level(effort))
+        if isinstance(thinking, dict) and "thinking_budget" not in thinking:
+            thinking.setdefault("thinking_level", google_thinking_level(effort, model))
     else:
         raise ValueError(f"Unknown effort style: {style!r}")