mirascope 1.18.2__py3-none-any.whl → 1.18.4__py3-none-any.whl

mirascope/core/gemini/_utils/_calculate_cost.py

@@ -2,7 +2,10 @@
 
 
 def calculate_cost(
-    input_tokens: int | float | None, output_tokens: int | float | None, model: str
+    input_tokens: int | float | None,
+    cached_tokens: int | float | None,
+    output_tokens: int | float | None,
+    model: str,
 ) -> float | None:
     """Calculate the cost of a Gemini API call.
 

mirascope/core/gemini/_utils/_convert_message_params.py

@@ -96,7 +96,7 @@ def convert_message_params(
                 elif part.type == "audio_url":
                     if part.url.startswith(("https://", "http://")):
                         audio = _load_media(part.url)
-                        audio_type = get_audio_type(audio)
+                        audio_type = f"audio/{get_audio_type(audio)}"
                         if audio_type not in [
                             "audio/wav",
                             "audio/mp3",

mirascope/core/gemini/call_response.py

@@ -122,6 +122,12 @@ class GeminiCallResponse(
         """Returns the number of input tokens."""
         return None
 
+    @computed_field
+    @property
+    def cached_tokens(self) -> None:
+        """Returns the number of cached tokens."""
+        return None
+
     @computed_field
     @property
     def output_tokens(self) -> None:
@@ -132,7 +138,9 @@ class GeminiCallResponse(
     @property
     def cost(self) -> float | None:
         """Returns the cost of the call."""
-        return calculate_cost(self.input_tokens, self.output_tokens, self.model)
+        return calculate_cost(
+            self.input_tokens, self.cached_tokens, self.output_tokens, self.model
+        )
 
     @computed_field
     @cached_property
@@ -140,7 +148,6 @@ class GeminiCallResponse(
         """Returns the models's response as a message parameter."""
         return {"role": "model", "parts": self.response.parts}  # pyright: ignore [reportReturnType]
 
-    @computed_field
     @cached_property
     def tools(self) -> list[GeminiTool] | None:
         """Returns the list of tools for the 0th candidate's 0th content part."""
@@ -157,7 +164,6 @@ class GeminiCallResponse(
 
         return extracted_tools
 
-    @computed_field
     @cached_property
     def tool(self) -> GeminiTool | None:
         """Returns the 0th tool for the 0th candidate's 0th content part.

mirascope/core/gemini/call_response_chunk.py

@@ -78,6 +78,11 @@ class GeminiCallResponseChunk(
         """Returns the number of input tokens."""
         return None
 
+    @property
+    def cached_tokens(self) -> None:
+        """Returns the number of cached tokens."""
+        return None
+
     @property
     def output_tokens(self) -> None:
         """Returns the number of output tokens."""

mirascope/core/gemini/stream.py

@@ -69,7 +69,9 @@ class GeminiStream(
     @property
     def cost(self) -> float | None:
         """Returns the cost of the call."""
-        return calculate_cost(self.input_tokens, self.output_tokens, self.model)
+        return calculate_cost(
+            self.input_tokens, self.cached_tokens, self.output_tokens, self.model
+        )
 
     def _construct_message_param(
         self, tool_calls: list[FunctionCall] | None = None, content: str | None = None

mirascope/core/google/__init__.py

@@ -17,13 +17,13 @@ from .tool import GoogleTool
 GoogleMessageParam: TypeAlias = ContentDict | FunctionResponse | BaseMessageParam
 
 __all__ = [
-    "call",
-    "GoogleDynamicConfig",
     "GoogleCallParams",
     "GoogleCallResponse",
     "GoogleCallResponseChunk",
+    "GoogleDynamicConfig",
     "GoogleMessageParam",
     "GoogleStream",
     "GoogleTool",
+    "call",
     "google_call",
 ]

mirascope/core/google/_utils/_calculate_cost.py

@@ -2,7 +2,10 @@
 
 
 def calculate_cost(
-    input_tokens: int | float | None, output_tokens: int | float | None, model: str
+    input_tokens: int | float | None,
+    cached_tokens: int | float | None,
+    output_tokens: int | float | None,
+    model: str,
 ) -> float | None:
     """Calculate the cost of a Google API call.
 
@@ -10,16 +13,31 @@ def calculate_cost(
 
     Pricing (per 1M tokens):
 
-    Model                   Input (<128K)    Output (<128K)    Input (>128K)    Output (>128K)
-    gemini-2.0-flash       $0.10            $0.40            $0.10            $0.40
-    gemini-2.0-flash-lite  $0.075           $0.30            $0.075           $0.30
-    gemini-1.5-flash       $0.075           $0.30            $0.15            $0.60
-    gemini-1.5-flash-8b    $0.0375          $0.15            $0.075           $0.30
-    gemini-1.5-pro         $1.25            $5.00            $2.50            $10.00
-    gemini-1.0-pro         $0.50            $1.50            $0.50            $1.50
+    Model                                 Input (<128K)    Output (<128K)   Input (>128K)    Output (>128K)   Cached
+    gemini-2.0-pro                        $1.25            $5.00            $2.50            $10.00           $0.625
+    gemini-2.0-pro-preview-1206           $1.25            $5.00            $2.50            $10.00           $0.625
+    gemini-2.0-flash                      $0.10            $0.40            $0.10            $0.40            $0.0375
+    gemini-2.0-flash-latest               $0.10            $0.40            $0.10            $0.40            $0.0375
+    gemini-2.0-flash-001                  $0.10            $0.40            $0.10            $0.40            $0.0375
+    gemini-2.0-flash-lite                 $0.075           $0.30            $0.075           $0.30            $0.0375
+    gemini-2.0-flash-lite-preview-02-05   $0.075           $0.30            $0.075           $0.30            $0.0375
+    gemini-1.5-pro                        $1.25            $5.00            $2.50            $10.00           $0.625
+    gemini-1.5-pro-latest                 $1.25            $5.00            $2.50            $10.00           $0.625
+    gemini-1.5-pro-001                    $1.25            $5.00            $2.50            $10.00           $0.625
+    gemini-1.5-pro-002                    $1.25            $5.00            $2.50            $10.00           $0.625
+    gemini-1.5-flash                      $0.075           $0.30            $0.15            $0.60            $0.0375
+    gemini-1.5-flash-latest               $0.075           $0.30            $0.15            $0.60            $0.0375
+    gemini-1.5-flash-001                  $0.075           $0.30            $0.15            $0.60            $0.0375
+    gemini-1.5-flash-002                  $0.075           $0.30            $0.15            $0.60            $0.0375
+    gemini-1.5-flash-8b                   $0.0375          $0.15            $0.075           $0.30            $0.025
+    gemini-1.5-flash-8b-latest            $0.0375          $0.15            $0.075           $0.30            $0.025
+    gemini-1.5-flash-8b-001               $0.0375          $0.15            $0.075           $0.30            $0.025
+    gemini-1.5-flash-8b-002               $0.0375          $0.15            $0.075           $0.30            $0.025
+    gemini-1.0-pro                        $0.50            $1.50            $0.50            $1.50            $0.00
 
     Args:
         input_tokens: Number of input tokens
+        cached_tokens: Number of cached tokens
         output_tokens: Number of output tokens
         model: Model name to use for pricing calculation
 
@@ -27,47 +45,154 @@ def calculate_cost(
         Total cost in USD or None if invalid input
     """
     pricing = {
+        "gemini-2.0-pro": {
+            "prompt_short": 0.000_001_25,
+            "completion_short": 0.000_005,
+            "prompt_long": 0.000_002_5,
+            "completion_long": 0.000_01,
+            "cached": 0.000_000_625,
+        },
+        "gemini-2.0-pro-preview-1206": {
+            "prompt_short": 0.000_001_25,
+            "completion_short": 0.000_005,
+            "prompt_long": 0.000_002_5,
+            "completion_long": 0.000_01,
+            "cached": 0.000_000_625,
+        },
         "gemini-2.0-flash": {
             "prompt_short": 0.000_000_10,
             "completion_short": 0.000_000_40,
             "prompt_long": 0.000_000_10,
             "completion_long": 0.000_000_40,
+            "cached": 0.000_000_037_5,
+        },
+        "gemini-2.0-flash-latest": {
+            "prompt_short": 0.000_000_10,
+            "completion_short": 0.000_000_40,
+            "prompt_long": 0.000_000_10,
+            "completion_long": 0.000_000_40,
+            "cached": 0.000_000_037_5,
+        },
+        "gemini-2.0-flash-001": {
+            "prompt_short": 0.000_000_10,
+            "completion_short": 0.000_000_40,
+            "prompt_long": 0.000_000_10,
+            "completion_long": 0.000_000_40,
+            "cached": 0.000_000_037_5,
         },
         "gemini-2.0-flash-lite": {
             "prompt_short": 0.000_000_075,
             "completion_short": 0.000_000_30,
             "prompt_long": 0.000_000_075,
             "completion_long": 0.000_000_30,
+            "cached": 0.000_000_037_5,
+        },
+        "gemini-2.0-flash-lite-preview-02-05": {
+            "prompt_short": 0.000_000_075,
+            "completion_short": 0.000_000_30,
+            "prompt_long": 0.000_000_075,
+            "completion_long": 0.000_000_30,
+            "cached": 0.000_000_037_5,
+        },
+        "gemini-1.5-pro": {
+            "prompt_short": 0.000_001_25,
+            "completion_short": 0.000_005,
+            "prompt_long": 0.000_002_5,
+            "completion_long": 0.000_01,
+            "cached": 0.000_000_625,
+        },
+        "gemini-1.5-pro-latest": {
+            "prompt_short": 0.000_001_25,
+            "completion_short": 0.000_005,
+            "prompt_long": 0.000_002_5,
+            "completion_long": 0.000_01,
+            "cached": 0.000_000_625,
+        },
+        "gemini-1.5-pro-001": {
+            "prompt_short": 0.000_001_25,
+            "completion_short": 0.000_005,
+            "prompt_long": 0.000_002_5,
+            "completion_long": 0.000_01,
+            "cached": 0.000_000_625,
+        },
+        "gemini-1.5-pro-002": {
+            "prompt_short": 0.000_001_25,
+            "completion_short": 0.000_005,
+            "prompt_long": 0.000_002_5,
+            "completion_long": 0.000_01,
+            "cached": 0.000_000_625,
         },
         "gemini-1.5-flash": {
             "prompt_short": 0.000_000_075,
             "completion_short": 0.000_000_30,
             "prompt_long": 0.000_000_15,
             "completion_long": 0.000_000_60,
+            "cached": 0.000_000_037_5,
+        },
+        "gemini-1.5-flash-latest": {
+            "prompt_short": 0.000_000_075,
+            "completion_short": 0.000_000_30,
+            "prompt_long": 0.000_000_15,
+            "completion_long": 0.000_000_60,
+            "cached": 0.000_000_037_5,
+        },
+        "gemini-1.5-flash-001": {
+            "prompt_short": 0.000_000_075,
+            "completion_short": 0.000_000_30,
+            "prompt_long": 0.000_000_15,
+            "completion_long": 0.000_000_60,
+            "cached": 0.000_000_037_5,
+        },
+        "gemini-1.5-flash-002": {
+            "prompt_short": 0.000_000_075,
+            "completion_short": 0.000_000_30,
+            "prompt_long": 0.000_000_15,
+            "completion_long": 0.000_000_60,
+            "cached": 0.000_000_037_5,
         },
         "gemini-1.5-flash-8b": {
             "prompt_short": 0.000_000_037_5,
             "completion_short": 0.000_000_15,
             "prompt_long": 0.000_000_075,
             "completion_long": 0.000_000_30,
+            "cached": 0.000_000_025,
         },
-        "gemini-1.5-pro": {
-            "prompt_short": 0.000_001_25,
-            "completion_short": 0.000_005,
-            "prompt_long": 0.000_002_5,
-            "completion_long": 0.000_01,
+        "gemini-1.5-flash-8b-latest": {
+            "prompt_short": 0.000_000_037_5,
+            "completion_short": 0.000_000_15,
+            "prompt_long": 0.000_000_075,
+            "completion_long": 0.000_000_30,
+            "cached": 0.000_000_025,
+        },
+        "gemini-1.5-flash-8b-001": {
+            "prompt_short": 0.000_000_037_5,
+            "completion_short": 0.000_000_15,
+            "prompt_long": 0.000_000_075,
+            "completion_long": 0.000_000_30,
+            "cached": 0.000_000_025,
+        },
+        "gemini-1.5-flash-8b-002": {
+            "prompt_short": 0.000_000_037_5,
+            "completion_short": 0.000_000_15,
+            "prompt_long": 0.000_000_075,
+            "completion_long": 0.000_000_30,
+            "cached": 0.000_000_025,
         },
         "gemini-1.0-pro": {
             "prompt_short": 0.000_000_5,
             "completion_short": 0.000_001_5,
             "prompt_long": 0.000_000_5,
             "completion_long": 0.000_001_5,
+            "cached": 0.000_000,
         },
     }
 
     if input_tokens is None or output_tokens is None:
         return None
 
+    if cached_tokens is None:
+        cached_tokens = 0
+
     try:
         model_pricing = pricing[model]
     except KeyError:
@@ -77,12 +202,14 @@ def calculate_cost(
     use_long_context = input_tokens > 128_000
 
     prompt_price = model_pricing["prompt_long" if use_long_context else "prompt_short"]
+    cached_price = model_pricing["cached"]
     completion_price = model_pricing[
         "completion_long" if use_long_context else "completion_short"
     ]
 
     prompt_cost = input_tokens * prompt_price
+    cached_cost = cached_tokens * cached_price
     completion_cost = output_tokens * completion_price
-    total_cost = prompt_cost + completion_cost
+    total_cost = prompt_cost + cached_cost + completion_cost
 
     return total_cost

mirascope/core/google/_utils/_convert_message_params.py

@@ -1,21 +1,37 @@
 """Utility for converting `BaseMessageParam` to `ContentsType`"""
 
+import asyncio
 import base64
 import io
+from concurrent.futures import ThreadPoolExecutor
 
-import PIL.Image
 from google.genai import Client
-from google.genai.types import BlobDict, ContentDict, FileDataDict, PartDict
+from google.genai.types import (
+    BlobDict,
+    ContentDict,
+    FileDataDict,
+    PartDict,
+)
 
 from ...base import BaseMessageParam
-from ...base._utils import get_audio_type
+from ...base._utils import get_audio_type, get_image_type
 from ...base._utils._parse_content_template import _load_media
+from ._validate_media_type import _check_audio_media_type, _check_image_media_type
 
 
-def convert_message_params(
+def _over_file_size_limit(size: int) -> bool:
+    """Check if the total file size exceeds the limit (10mb).
+
+    Google limit is 20MB but base64 adds 33% to the size.
+    """
+    return size > 10 * 1024 * 1024  # 10MB
+
+
+async def _convert_message_params_async(
     message_params: list[BaseMessageParam | ContentDict], client: Client
 ) -> list[ContentDict]:
     converted_message_params = []
+    total_payload_size = 0
     for message_param in message_params:
         if not isinstance(message_param, BaseMessageParam):
             converted_message_params.append(message_param)
@@ -39,139 +55,108 @@ def convert_message_params(
             )
         else:
             converted_content = []
-            for part in content:
+            must_upload: dict[int, BlobDict] = {}
+            for index, part in enumerate(content):
                 if part.type == "text":
                     converted_content.append(PartDict(text=part.text))
                 elif part.type == "image":
-                    if part.media_type not in [
-                        "image/jpeg",
-                        "image/png",
-                        "image/webp",
-                        "image/heic",
-                        "image/heif",
-                    ]:
-                        raise ValueError(
-                            f"Unsupported image media type: {part.media_type}. "
-                            "Google currently only supports JPEG, PNG, WebP, HEIC, "
-                            "and HEIF images."
-                        )
-                    converted_content.append(
-                        PartDict(
-                            inline_data=BlobDict(
-                                data=part.image, mime_type=part.media_type
-                            )
-                        )
-                    )
+                    _check_image_media_type(part.media_type)
+                    blob_dict = BlobDict(data=part.image, mime_type=part.media_type)
+                    converted_content.append(PartDict(inline_data=blob_dict))
+                    image_size = len(part.image)
+                    total_payload_size += image_size
+                    if _over_file_size_limit(total_payload_size):
+                        must_upload[index] = blob_dict
+                        total_payload_size -= image_size
                 elif part.type == "image_url":
                     if (
-                        part.url.startswith(("https://", "http://"))
-                        and "generativelanguage.googleapis.com" not in part.url
+                        client.vertexai
+                        or not part.url.startswith(("https://", "http://"))
+                        or "generativelanguage.googleapis.com" in part.url
                     ):
-                        downloaded_image = io.BytesIO(_load_media(part.url))
-                        image = PIL.Image.open(downloaded_image)
-                        media_type = (
-                            PIL.Image.MIME[image.format]
-                            if image.format
-                            else "image/unknown"
-                        )
-                        if media_type not in [
-                            "image/jpeg",
-                            "image/png",
-                            "image/webp",
-                            "image/heic",
-                            "image/heif",
-                        ]:
-                            raise ValueError(
-                                f"Unsupported image media type: {media_type}. "
-                                "Google currently only supports JPEG, PNG, WebP, HEIC, "
-                                "and HEIF images."
+                        converted_content.append(
+                            PartDict(
+                                file_data=FileDataDict(
+                                    file_uri=part.url, mime_type=None
+                                )
                             )
-                        if client.vertexai:
-                            uri = part.url
-                        else:
-                            downloaded_image.seek(0)
-                            file_ref = client.files.upload(
-                                file=downloaded_image, config={"mime_type": media_type}
-                            )
-                            uri = file_ref.uri
-                            media_type = file_ref.mime_type
+                        )
                     else:
-                        uri = part.url
-                        media_type = None
-
-                    converted_content.append(
-                        PartDict(
-                            file_data=FileDataDict(file_uri=uri, mime_type=media_type)
+                        downloaded_image = _load_media(part.url)
+                        media_type = f"image/{get_image_type(downloaded_image)}"
+                        _check_image_media_type(media_type)
+                        blob_dict = BlobDict(
+                            data=downloaded_image, mime_type=media_type
                         )
-                    )
+                        converted_content.append(PartDict(inline_data=blob_dict))
+                        image_size = len(downloaded_image)
+                        total_payload_size += image_size
+                        if _over_file_size_limit(total_payload_size):
+                            must_upload[index] = blob_dict
+                            total_payload_size -= image_size
                 elif part.type == "audio":
-                    if part.media_type not in [
-                        "audio/wav",
-                        "audio/mp3",
-                        "audio/aiff",
-                        "audio/aac",
-                        "audio/ogg",
-                        "audio/flac",
-                    ]:
-                        raise ValueError(
-                            f"Unsupported audio media type: {part.media_type}. "
-                            "Google currently only supports WAV, MP3, AIFF, AAC, OGG, "
-                            "and FLAC audio file types."
-                        )
-                    converted_content.append(
-                        PartDict(
-                            inline_data=BlobDict(
-                                data=part.audio
-                                if isinstance(part.audio, bytes)
-                                else base64.b64decode(part.audio),
-                                mime_type=part.media_type,
-                            )
-                        )
+                    _check_audio_media_type(part.media_type)
+                    audio_data = (
+                        part.audio
+                        if isinstance(part.audio, bytes)
+                        else base64.b64decode(part.audio)
                     )
+                    blob_dict = BlobDict(data=audio_data, mime_type=part.media_type)
+                    converted_content.append(PartDict(inline_data=blob_dict))
+                    audio_size = len(audio_data)
+                    total_payload_size += audio_size
+                    if _over_file_size_limit(total_payload_size):
+                        must_upload[index] = blob_dict
+                        total_payload_size -= audio_size
                 elif part.type == "audio_url":
                     if (
-                        part.url.startswith(("https://", "http://"))
-                        and "generativelanguage.googleapis.com" not in part.url
+                        client.vertexai
+                        or not part.url.startswith(("https://", "http://"))
+                        or "generativelanguage.googleapis.com" in part.url
                     ):
-                        downloaded_audio = _load_media(part.url)
-                        audio_type = get_audio_type(downloaded_audio)
-                        if audio_type not in [
-                            "audio/wav",
-                            "audio/mp3",
-                            "audio/aiff",
-                            "audio/aac",
-                            "audio/ogg",
-                            "audio/flac",
-                        ]:
-                            raise ValueError(
-                                f"Unsupported audio media type: {audio_type}. "
-                                "Google currently only supports WAV, MP3, AIFF, AAC, OGG, "
-                                "and FLAC audio file types."
+                        converted_content.append(
+                            PartDict(
+                                file_data=FileDataDict(
+                                    file_uri=part.url, mime_type=None
+                                )
                             )
-                        if client.vertexai:
-                            uri = part.url
-                        else:
-                            downloaded_audio = io.BytesIO(downloaded_audio)
-                            downloaded_audio.seek(0)
-                            file_ref = client.files.upload(
-                                file=downloaded_audio, config={"mime_type": audio_type}
-                            )
-                            uri = file_ref.uri
-                            media_type = file_ref.mime_type
+                        )
                     else:
-                        uri = part.url
-                        audio_type = None
-
-                    converted_content.append(
-                        PartDict(
-                            file_data=FileDataDict(file_uri=uri, mime_type=audio_type)
+                        downloaded_audio = _load_media(part.url)
+                        media_type = f"audio/{get_audio_type(downloaded_audio)}"
+                        _check_audio_media_type(media_type)
+                        blob_dict = BlobDict(
+                            data=downloaded_audio, mime_type=media_type
                         )
-                    )
+                        converted_content.append(PartDict(inline_data=blob_dict))
+                        audio_size = len(downloaded_audio)
+                        total_payload_size += audio_size
+                        if _over_file_size_limit(total_payload_size):
+                            must_upload[index] = blob_dict
+                            total_payload_size -= audio_size
                 else:
                     raise ValueError(
                         "Google currently only supports text, image, and audio parts. "
                         f"Part provided: {part.type}"
                     )
+
+            if must_upload:
+                indices, blob_dicts = zip(*must_upload.items(), strict=True)
+                upload_tasks = [
+                    client.aio.files.upload(
+                        file=io.BytesIO(blob_dict["data"]),
+                        config={"mime_type": blob_dict.get("mime_type", None)},
+                    )
+                    for blob_dict in blob_dicts
+                ]
+                file_refs = await asyncio.gather(*upload_tasks)
+                for index, file_ref in zip(indices, file_refs, strict=True):
+                    converted_content[index] = PartDict(
+                        file_data=FileDataDict(
+                            file_uri=file_ref.uri, mime_type=file_ref.mime_type
+                        )
+                    )
+
             converted_message_params.append(
                 {
                     "role": role if role == "user" else "model",
@@ -179,3 +164,23 @@ def convert_message_params(
                 }
             )
     return converted_message_params
+
+
+def convert_message_params(
+    message_params: list[BaseMessageParam | ContentDict], client: Client
+) -> list[ContentDict]:
+    """Convert message params to Google's ContentDict format.
+
+    If called from sync context, uses asyncio.run().
+    If called from async context, uses the current event loop.
+    """
+    try:
+        asyncio.get_running_loop()
+        with ThreadPoolExecutor(max_workers=1) as executor:
+            future = executor.submit(
+                asyncio.run, _convert_message_params_async(message_params, client)
+            )
+            return future.result()
+    except RuntimeError:
+        ...
+    return asyncio.run(_convert_message_params_async(message_params, client))