mirascope 2.0.0__py3-none-any.whl → 2.0.0a0__py3-none-any.whl

mirascope/llm/{models → clients/base}/params.py

@@ -2,8 +2,6 @@
 
 from typing import TypedDict
 
-from .thinking_config import ThinkingConfig
-
 
 class Params(TypedDict, total=False):
     """Common parameters shared across LLM providers.
@@ -25,8 +23,8 @@ class Params(TypedDict, total=False):
 
     top_p: float
     """Nucleus sampling parameter (0.0 to 1.0).
-
-    Tokens are selected from the most to least probable until the sum of their
+    
+    Tokens are selected from the most to least probable until the sum of their 
     probabilities equals this value. Use a lower value for less random responses and a
     higher value for more random responses.
     """
@@ -43,7 +41,7 @@ class Params(TypedDict, total=False):
 
     seed: int
     """Random seed for reproducibility.
-
+    
     When ``seed`` is fixed to a specific number, the model makes a best
     effort to provide the same response for repeated requests.
 
@@ -52,21 +50,44 @@ class Params(TypedDict, total=False):
 
     stop_sequences: list[str]
     """Stop sequences to end generation.
-
+    
     The model will stop generating text if one of these strings is encountered in the
     response.
     """
 
-    thinking: ThinkingConfig | None
-    """Configuration for extended reasoning/thinking.
+    thinking: bool
+    """Configures whether the model should use thinking.
+    
+    Thinking is a process where the model spends additional tokens thinking about the
+    prompt before generating a response. You may configure thinking either by passing
+    a bool to enable or disable it.
+
+    If `params.thinking` is `True`, then thinking and thought summaries will be enabled
+    (if supported by the model/provider), with a default budget for thinking tokens.
+
+    If `params.thinking` is `False`, then thinking will be wholly disabled, assuming
+    the model allows this (some models, e.g. `google:gemini-2.5-pro`, do not allow
+    disabling thinking).
+
+    If `params.thinking` is unset (or `None`), then we will use provider-specific default
+    behavior for the chosen model.
+    """
+
+    encode_thoughts_as_text: bool
+    """Configures whether `Thought` content should be re-encoded as text for model consumption.
+    
+    If `True`, then when an `AssistantMessage` contains `Thoughts` and is being passed back
+    to an LLM, those `Thoughts` will be encoded as `Text`, so that the assistant can read
+    those thoughts. That ensures the assistant has access to (at least the summarized output of)
+    its reasoning process, and contrasts with provider default behaviors which may ignore
+    prior thoughts, particularly if tool calls are not involved.
+
+    When `True`, we will always re-encode Mirascope messages being passed to the provider,
+    rather than reusing raw provider response content. This may disable provider-specific
+    behavior like cached reasoning tokens.
 
-    Pass a `ThinkingConfig` to configure thinking behavior. The `level` field controls
-    whether thinking is enabled and how much reasoning to use. Level may be one of
-    "minimal", "low", "medium", or "high". If level is unset, then thinking is enabled
-    with a provider-specific default level.
+    If `False`, then `Thoughts` will not be encoded as text, and whether reasoning context
+    is available to the model depends entirely on the provider's behavior. 
 
-    `ThinkingConfig` can also include `encode_thoughts_as_text`, which is an advanced
-    feature for providing past thoughts back to the model as text content. This is
-    primarily useful for making thoughts transferable when passing a conversation
-    to a different model or provider than the one that generated the thinking.
+    Defaults to `False` if unset.
     """

mirascope/llm/clients/google/__init__.py

@@ -0,0 +1,6 @@
+"""Google client implementation."""
+
+from .clients import GoogleClient, client, get_client
+from .model_ids import GoogleModelId
+
+__all__ = ["GoogleClient", "GoogleModelId", "client", "get_client"]

mirascope/llm/{providers/openai/responses → clients/google}/_utils/__init__.py

@@ -1,4 +1,3 @@
-from ....base._utils import get_include_thoughts
 from .decode import (
     decode_async_stream,
     decode_response,
@@ -11,5 +10,4 @@ __all__ = [
     "decode_response",
     "decode_stream",
     "encode_request",
-    "get_include_thoughts",
 ]

mirascope/llm/{providers → clients}/google/_utils/decode.py

@@ -29,10 +29,8 @@ from ....responses import (
     FinishReasonChunk,
     RawMessageChunk,
     RawStreamEventChunk,
-    Usage,
-    UsageDeltaChunk,
 )
-from ..model_id import GoogleModelId, model_name
+from ..model_ids import GoogleModelId
 from .encode import UNKNOWN_TOOL_ID
 
 GOOGLE_FINISH_REASON_MAP = {
@@ -45,30 +43,6 @@ GOOGLE_FINISH_REASON_MAP = {
 }
 
 
-def _decode_usage(
-    usage: genai_types.GenerateContentResponseUsageMetadata | None,
-) -> Usage | None:
-    """Convert Google UsageMetadata to Mirascope Usage."""
-    if (
-        usage is None
-        or usage.prompt_token_count is None
-        or usage.candidates_token_count is None
-    ):  # pragma: no cover
-        return None
-
-    reasoning_tokens = usage.thoughts_token_count or 0
-    output_tokens = usage.candidates_token_count + reasoning_tokens
-
-    return Usage(
-        input_tokens=usage.prompt_token_count,
-        output_tokens=output_tokens,
-        cache_read_tokens=usage.cached_content_token_count or 0,
-        cache_write_tokens=0,
-        reasoning_tokens=usage.thoughts_token_count or 0,
-        raw=usage,
-    )
-
-
 def _decode_content_part(part: genai_types.Part) -> AssistantContentPart | None:
     """Returns an `AssistantContentPart` (or `None`) decoded from a google `Part`"""
     if part.thought and part.text:
@@ -114,7 +88,7 @@ def _decode_candidate_content(
     candidate: genai_types.Candidate,
 ) -> Sequence[AssistantContentPart]:
     """Returns a sequence of `AssistantContentPart` decoded from a google `Candidate`"""
-    content_parts: list[AssistantContentPart] = []
+    content_parts = []
     if candidate.content and candidate.content.parts:
         for part in candidate.content.parts:
             decoded_part = _decode_content_part(part)
@@ -124,20 +98,15 @@ def _decode_candidate_content(
 
 
 def decode_response(
-    response: genai_types.GenerateContentResponse,
-    model_id: GoogleModelId,
-    *,
-    include_thoughts: bool,
-) -> tuple[AssistantMessage, FinishReason | None, Usage | None]:
-    """Returns an `AssistantMessage`, `FinishReason`, and `Usage` extracted from a `GenerateContentResponse`"""
+    response: genai_types.GenerateContentResponse, model_id: GoogleModelId
+) -> tuple[AssistantMessage, FinishReason | None]:
+    """Returns an `AssistantMessage` and `FinishReason` extracted from a `GenerateContentResponse`"""
     content: Sequence[AssistantContentPart] = []
     candidate_content: genai_types.Content | None = None
     finish_reason: FinishReason | None = None
 
     if response.candidates and (candidate := response.candidates[0]):
         content = _decode_candidate_content(candidate)
-        if not include_thoughts:
-            content = [part for part in content if part.type != "thought"]
         candidate_content = candidate.content
         if candidate.finish_reason:
             finish_reason = GOOGLE_FINISH_REASON_MAP.get(candidate.finish_reason)
@@ -146,26 +115,21 @@ def decode_response(
 
     assistant_message = AssistantMessage(
         content=content,
-        provider_id="google",
+        provider="google",
         model_id=model_id,
-        provider_model_name=model_name(model_id),
         raw_message=candidate_content.model_dump(),
     )
 
-    usage = _decode_usage(response.usage_metadata)
-    return assistant_message, finish_reason, usage
+    return assistant_message, finish_reason
 
 
 class _GoogleChunkProcessor:
     """Processes Google stream chunks and maintains state across chunks."""
 
-    def __init__(self, *, include_thoughts: bool) -> None:
+    def __init__(self) -> None:
         self.current_content_type: Literal["text", "tool_call", "thought"] | None = None
         self.accumulated_parts: list[genai_types.Part] = []
         self.reconstructed_content = genai_types.Content(parts=[])
-        # Track previous cumulative usage to compute deltas
-        self.prev_usage = Usage()
-        self.include_thoughts = include_thoughts
 
     def process_chunk(
         self, chunk: genai_types.GenerateContentResponse
@@ -180,34 +144,27 @@ class _GoogleChunkProcessor:
         for part in candidate.content.parts:
             self.accumulated_parts.append(part)
             if self.current_content_type == "thought" and not part.thought:
-                if self.include_thoughts:
-                    yield ThoughtEndChunk()
+                yield ThoughtEndChunk()
                 self.current_content_type = None
-            elif (
-                self.current_content_type == "text" and not part.text
-            ):  # pragma: no cover
-                yield TextEndChunk()
-                self.current_content_type = None
-            elif (
-                self.current_content_type == "tool_call" and not part.function_call
-            ):  # pragma: no cover
+            elif self.current_content_type == "text" and not part.text:
+                yield TextEndChunk()  # pragma: no cover
+                self.current_content_type = None  # pragma: no cover
+            elif self.current_content_type == "tool_call" and not part.function_call:
                 # In testing, Gemini never emits tool calls and text in the same message
                 # (even when specifically asked in system and user prompt), so
                 # the following code is uncovered but included for completeness
-                yield ToolCallEndChunk(id=UNKNOWN_TOOL_ID)
-                self.current_content_type = None
+                yield ToolCallEndChunk()  # pragma: no cover
+                self.current_content_type = None  # pragma: no cover
 
             if part.thought:
                 if self.current_content_type is None:
-                    if self.include_thoughts:
-                        yield ThoughtStartChunk()
+                    yield ThoughtStartChunk()
                     self.current_content_type = "thought"
                 if not part.text:
                     raise ValueError(
                         "Inside thought part with no text content"
                     )  # pragma: no cover
-                if self.include_thoughts:
-                    yield ThoughtChunk(delta=part.text)
+                yield ThoughtChunk(delta=part.text)
 
             elif part.text:
                 if self.current_content_type is None:
@@ -222,29 +179,23 @@ class _GoogleChunkProcessor:
                         "Required name missing on Google function call"
                     )  # pragma: no cover
 
-                tool_id = function_call.id or UNKNOWN_TOOL_ID
-                self.current_content_type = "tool_call"
-
                 yield ToolCallStartChunk(
-                    id=tool_id,
+                    id=function_call.id or UNKNOWN_TOOL_ID,
                     name=function_call.name,
                 )
 
                 yield ToolCallChunk(
-                    id=tool_id,
                     delta=json.dumps(function_call.args)
                     if function_call.args
                     else "{}",
                 )
-                yield ToolCallEndChunk(id=tool_id)
-                self.current_content_type = None
+                yield ToolCallEndChunk()
 
         if candidate.finish_reason:
             if self.current_content_type == "text":
                 yield TextEndChunk()
             elif self.current_content_type == "thought":
-                if self.include_thoughts:  # pragma: no cover
-                    yield ThoughtEndChunk()
+                yield ThoughtEndChunk()  # pragma: no cover
             elif self.current_content_type is not None:
                 raise NotImplementedError
 
@@ -254,29 +205,6 @@ class _GoogleChunkProcessor:
             if finish_reason is not None:
                 yield FinishReasonChunk(finish_reason=finish_reason)
 
-        # Emit usage delta if usage metadata is present
-        if chunk.usage_metadata:
-            usage_metadata = chunk.usage_metadata
-            current_input = usage_metadata.prompt_token_count or 0
-            current_output = usage_metadata.candidates_token_count or 0
-            current_cache_read = usage_metadata.cached_content_token_count or 0
-            current_reasoning = usage_metadata.thoughts_token_count or 0
-
-            yield UsageDeltaChunk(
-                input_tokens=current_input - self.prev_usage.input_tokens,
-                output_tokens=current_output - self.prev_usage.output_tokens,
-                cache_read_tokens=current_cache_read
-                - self.prev_usage.cache_read_tokens,
-                cache_write_tokens=0,
-                reasoning_tokens=current_reasoning - self.prev_usage.reasoning_tokens,
-            )
-
-            # Update previous usage
-            self.prev_usage.input_tokens = current_input
-            self.prev_usage.output_tokens = current_output
-            self.prev_usage.cache_read_tokens = current_cache_read
-            self.prev_usage.reasoning_tokens = current_reasoning
-
     def raw_message_chunk(self) -> RawMessageChunk:
         content = genai_types.Content(role="model", parts=self.accumulated_parts)
         return RawMessageChunk(raw_message=content.model_dump())
@@ -284,11 +212,9 @@ class _GoogleChunkProcessor:
 
 def decode_stream(
     google_stream: Iterator[genai_types.GenerateContentResponse],
-    *,
-    include_thoughts: bool,
 ) -> ChunkIterator:
     """Returns a ChunkIterator converted from a Google stream."""
-    processor = _GoogleChunkProcessor(include_thoughts=include_thoughts)
+    processor = _GoogleChunkProcessor()
     for chunk in google_stream:
         yield from processor.process_chunk(chunk)
     yield processor.raw_message_chunk()
@@ -296,11 +222,9 @@ def decode_stream(
 
 async def decode_async_stream(
     google_stream: AsyncIterator[genai_types.GenerateContentResponse],
-    *,
-    include_thoughts: bool,
 ) -> AsyncChunkIterator:
     """Returns an AsyncChunkIterator converted from a Google async stream."""
-    processor = _GoogleChunkProcessor(include_thoughts=include_thoughts)
+    processor = _GoogleChunkProcessor()
     async for chunk in google_stream:
         for item in processor.process_chunk(chunk):
             yield item

mirascope/llm/{providers → clients}/google/_utils/encode.py

@@ -1,13 +1,10 @@
 """Google message encoding and request preparation."""
 
-from __future__ import annotations
-
 import base64
 import json
 from collections.abc import Sequence
 from functools import lru_cache
-from typing import TYPE_CHECKING, Any, TypedDict, cast
-from typing_extensions import Required
+from typing import Any, cast
 
 from google.genai import types as genai_types
 
@@ -16,116 +13,19 @@ from ....exceptions import FeatureNotSupportedError
 from ....formatting import (
     Format,
     FormattableT,
-    OutputParser,
+    _utils as _formatting_utils,
     resolve_format,
 )
 from ....messages import AssistantMessage, Message, UserMessage
-from ....tools import FORMAT_TOOL_NAME, AnyToolSchema, BaseToolkit
-from ...base import _utils as _base_utils
-from ..model_id import GoogleModelId, model_name
-from ..model_info import MODELS_WITHOUT_STRUCTURED_OUTPUT_AND_TOOLS_SUPPORT
-
-if TYPE_CHECKING:
-    from ....models import Params, ThinkingConfig, ThinkingLevel
+from ....tools import FORMAT_TOOL_NAME, BaseToolkit, ToolSchema
+from ...base import BaseKwargs, Params, _utils as _base_utils
+from ..model_ids import GoogleModelId
 
 UNKNOWN_TOOL_ID = "google_unknown_tool_id"
 
-# Thinking level to a float multiplier % of max tokens (for 2.5 models using budget)
-THINKING_LEVEL_TO_BUDGET_MULTIPLIER: dict[ThinkingLevel, float] = {
-    "none": 0,
-    "minimal": 0.1,
-    "low": 0.2,
-    "medium": 0.4,
-    "high": 0.6,
-    "max": 0.8,
-}
-
-# Gemini 3 Pro supports only LOW or HIGH
-# https://ai.google.dev/gemini-api/docs/gemini-3#thinking_level
-THINKING_LEVEL_FOR_GEMINI_3_PRO: dict[ThinkingLevel, genai_types.ThinkingLevel] = {
-    "default": genai_types.ThinkingLevel.THINKING_LEVEL_UNSPECIFIED,
-    "none": genai_types.ThinkingLevel.LOW,
-    "minimal": genai_types.ThinkingLevel.LOW,
-    "low": genai_types.ThinkingLevel.LOW,
-    "medium": genai_types.ThinkingLevel.HIGH,
-    "high": genai_types.ThinkingLevel.HIGH,
-    "max": genai_types.ThinkingLevel.HIGH,
-}
-
-# Gemini 3 Flash supports MINIMAL, LOW, MEDIUM, HIGH
-# https://ai.google.dev/gemini-api/docs/gemini-3#thinking_level
-THINKING_LEVEL_FOR_GEMINI_3_FLASH: dict[ThinkingLevel, genai_types.ThinkingLevel] = {
-    "default": genai_types.ThinkingLevel.THINKING_LEVEL_UNSPECIFIED,
-    "none": genai_types.ThinkingLevel.MINIMAL,
-    "minimal": genai_types.ThinkingLevel.MINIMAL,
-    "low": genai_types.ThinkingLevel.LOW,
-    "medium": genai_types.ThinkingLevel.MEDIUM,
-    "high": genai_types.ThinkingLevel.HIGH,
-    "max": genai_types.ThinkingLevel.HIGH,
-}
-
-
-def google_thinking_config(
-    thinking_config: ThinkingConfig,
-    max_tokens: int | None,
-    model_id: GoogleModelId,
-) -> genai_types.ThinkingConfigDict:
-    """Compute Google thinking configuration based on model version.
-
-    Args:
-        thinking_config: The ThinkingConfig from params
-        max_tokens: Max output tokens (used to compute budget for 2.5 models)
-        model_id: The Google model ID to determine version
-
-    Returns:
-        ThinkingConfigDict with either thinking_level or thinking_budget set.
-
-    Notes:
-        - Gemini 2.5 models use thinking_budget (token count)
-        - Gemini 3.0 Pro supports thinking_level "low" or "high"
-        - Gemini 3.0 Flash supports thinking_level "minimal", "low", "medium", "high"
-
-    See: https://ai.google.dev/gemini-api/docs/gemini-3#thinking_level
-    """
-    level: ThinkingLevel = thinking_config.get("level", "default")
-    include_thoughts = thinking_config.get("include_thoughts")
-
-    result = genai_types.ThinkingConfigDict()
-
-    if "gemini-3-flash" in model_id:
-        result["thinking_level"] = THINKING_LEVEL_FOR_GEMINI_3_FLASH.get(
-            level, genai_types.ThinkingLevel.THINKING_LEVEL_UNSPECIFIED
-        )
-    elif "gemini-3-pro" in model_id:
-        result["thinking_level"] = THINKING_LEVEL_FOR_GEMINI_3_PRO.get(
-            level, genai_types.ThinkingLevel.THINKING_LEVEL_UNSPECIFIED
-        )
-    else:  # Fall back to 2.5-style budgets
-        # 2.5 models use thinking_budget
-        if level == "default":
-            budget = -1  # Dynamic budget
-        elif level == "none":
-            budget = 0  # Disable thinking
-        else:
-            # Compute budget as percentage of max_tokens
-            if max_tokens is None:
-                max_tokens = 16000
-            multiplier = THINKING_LEVEL_TO_BUDGET_MULTIPLIER.get(level, 0.4)
-            budget = int(multiplier * max_tokens)
-
-        result["thinking_budget"] = budget
-    if include_thoughts is not None:
-        result["include_thoughts"] = include_thoughts
-
-    return result
 
-
-class GoogleKwargs(TypedDict, total=False):
-    """Kwargs for Google's generate_content method."""
-
-    model: Required[str]
-    contents: Required[genai_types.ContentListUnionDict]
-    config: genai_types.GenerateContentConfigDict
+class GoogleKwargs(BaseKwargs, genai_types.GenerateContentConfigDict):
+    """Google's `GenerateContentConfigDict` typed dict, subclassing BaseKwargs for type safety."""
 
 
 def _resolve_refs(
@@ -152,7 +52,7 @@ def _encode_content(
     content: Sequence[ContentPart], encode_thoughts: bool
 ) -> list[genai_types.PartDict]:
     """Returns a list of google `PartDicts` converted from a sequence of Mirascope `ContentPart`s"""
-    result: list[genai_types.PartDict] = []
+    result = []
 
     for part in content:
         if part.type == "text":
@@ -199,7 +99,7 @@ def _encode_content(
                     function_response=genai_types.FunctionResponseDict(
                         id=part.id if part.id != UNKNOWN_TOOL_ID else None,
                         name=part.name,
-                        response={"output": str(part.result)},
+                        response={"output": str(part.value)},
                     )
                 )
             )
@@ -221,7 +121,7 @@ def _encode_message(
     """Returns a Google `ContentDict` converted from a Mirascope `Message`"""
     if (
         message.role == "assistant"
-        and message.provider_id == "google"
+        and message.provider == "google"
         and message.model_id == model_id
         and message.raw_message
         and not encode_thoughts
@@ -244,7 +144,7 @@ def _encode_messages(
 
 @lru_cache(maxsize=128)
 def _convert_tool_to_function_declaration(
-    tool: AnyToolSchema,
+    tool: ToolSchema,
 ) -> genai_types.FunctionDeclarationDict:
     """Convert a single Mirascope tool to Google FunctionDeclaration format with caching."""
     schema_dict = tool.parameters.model_dump(by_alias=True, exclude_none=True)
@@ -270,25 +170,21 @@ def encode_request(
     *,
     model_id: GoogleModelId,
     messages: Sequence[Message],
-    tools: Sequence[AnyToolSchema] | BaseToolkit[AnyToolSchema] | None,
-    format: type[FormattableT]
-    | Format[FormattableT]
-    | OutputParser[FormattableT]
-    | None,
+    tools: Sequence[ToolSchema] | BaseToolkit | None,
+    format: type[FormattableT] | Format[FormattableT] | None,
     params: Params,
-) -> tuple[Sequence[Message], Format[FormattableT] | None, GoogleKwargs]:
+) -> tuple[
+    Sequence[Message],
+    Format[FormattableT] | None,
+    genai_types.ContentListUnionDict,
+    GoogleKwargs,
+]:
     """Prepares a request for the genai `Client.models.generate_content` method."""
-    if not model_id.startswith("google/"):  # pragma: no cover
-        raise ValueError(f"Model ID must start with 'google/' prefix, got: {model_id}")
-
-    google_config: genai_types.GenerateContentConfigDict = (
-        genai_types.GenerateContentConfigDict()
-    )
-    encode_thoughts_as_text = False
-    google_model_name = model_name(model_id)
+    google_config: GoogleKwargs = GoogleKwargs()
+    encode_thoughts = False
 
     with _base_utils.ensure_all_params_accessed(
-        params=params, provider_id="google"
+        params=params, provider="google"
     ) as param_accessor:
         if param_accessor.temperature is not None:
             google_config["temperature"] = param_accessor.temperature
@@ -303,54 +199,39 @@ def encode_request(
         if param_accessor.stop_sequences is not None:
             google_config["stop_sequences"] = param_accessor.stop_sequences
         if param_accessor.thinking is not None:
-            thinking_config = param_accessor.thinking
-
-            # Compute thinking config based on model version
-            google_config["thinking_config"] = google_thinking_config(
-                thinking_config, param_accessor.max_tokens, model_id
-            )
-
-            # Handle encode_thoughts_as_text from ThinkingConfig
-            if thinking_config.get("encode_thoughts_as_text"):
-                encode_thoughts_as_text = True
+            if param_accessor.thinking:
+                google_config["thinking_config"] = genai_types.ThinkingConfigDict(
+                    thinking_budget=-1,  # automatic budget
+                    include_thoughts=True,
+                )
+            else:
+                google_config["thinking_config"] = genai_types.ThinkingConfigDict(
+                    include_thoughts=False, thinking_budget=0
+                )
+        if param_accessor.encode_thoughts_as_text:
+            encode_thoughts = True
 
     tools = tools.tools if isinstance(tools, BaseToolkit) else tools or []
-
-    if _base_utils.has_strict_tools(tools):
-        raise FeatureNotSupportedError(
-            feature="strict tools",
-            provider_id="google",
-            model_id=model_id,
-            message="Google does not support strict mode for tools. "
-            "Set strict=False on your tools or omit the strict parameter.",
-        )
-
     google_tools: list[genai_types.ToolDict] = []
 
-    allows_strict_mode_with_tools = (
-        google_model_name not in MODELS_WITHOUT_STRUCTURED_OUTPUT_AND_TOOLS_SUPPORT
+    format = resolve_format(
+        format,
+        # Google does not support strict outputs when tools are present
+        # (Gemini 2.5 will error, 2.0 and below will ignore tools)
+        default_mode="strict" if not tools else "tool",
     )
-    # Older google models do not allow strict mode when using tools; if so, we use tool
-    # mode when tools are present by default for compatibility. Otherwise, prefer strict mode.
-    default_mode = "tool" if tools and not allows_strict_mode_with_tools else "strict"
-    format = resolve_format(format, default_mode=default_mode)
     if format is not None:
-        if (
-            format.mode in ("strict", "json")
-            and tools
-            and not allows_strict_mode_with_tools
-        ):
+        if format.mode in ("strict", "json") and tools:
             raise FeatureNotSupportedError(
                 feature=f"formatting_mode:{format.mode} with tools",
-                provider_id="google",
-                model_id=model_id,
+                provider="google",
             )
 
         if format.mode == "strict":
             google_config["response_mime_type"] = "application/json"
             google_config["response_schema"] = format.schema
         elif format.mode == "tool":
-            format_tool_schema = format.create_tool_schema()
+            format_tool_schema = _formatting_utils.create_tool_schema(format)
             format_tool = _convert_tool_to_function_declaration(format_tool_schema)
             google_tools.append(
                 genai_types.ToolDict(function_declarations=[format_tool])
@@ -390,12 +271,9 @@ def encode_request(
     if system_message_content:
         google_config["system_instruction"] = system_message_content
 
-    kwargs = GoogleKwargs(
-        model=model_name(model_id),
-        contents=_encode_messages(
-            remaining_messages, model_id, encode_thoughts_as_text
-        ),
-        config=google_config,
+    return (
+        messages,
+        format,
+        _encode_messages(remaining_messages, model_id, encode_thoughts),
+        google_config,
     )
-
-    return messages, format, kwargs