mirascope 1.19.0__py3-none-any.whl → 1.20.1__py3-none-any.whl

mirascope/core/{vertex/_utils/_calculate_cost.py → costs/_vertex_calculate_cost.py}

@@ -1,12 +1,11 @@
 """Calculate the cost of a completion using the Vertex AI Gemini API, considering context window size."""
 
+from ..base.types import CostMetadata
+
 
 def calculate_cost(
-    input_chars: int | float | None,
-    cached_chars: int | float | None,
-    output_chars: int | float | None,
+    metadata: CostMetadata,
     model: str = "gemini-1.5-pro",
-    context_length: int = 0,
 ) -> float | None:
     """Calculate the cost of a completion using the Vertex AI Gemini API.
 
@@ -19,6 +18,8 @@ def calculate_cost(
 
     Note: Prices are per 1k characters. Gemini 1.0 Pro only supports up to 32K context window.
     """
+
+    context_length = metadata.context_length or 0
     pricing = {
         "gemini-1.5-flash": {
             "prompt_short": 0.000_018_75,
@@ -40,7 +41,7 @@ def calculate_cost(
         },
     }
 
-    if input_chars is None or output_chars is None:
+    if metadata.input_tokens is None or metadata.output_tokens is None:
         return None
 
     try:
@@ -59,8 +60,8 @@ def calculate_cost(
         "completion_long" if use_long_context else "completion_short"
     ]
 
-    prompt_cost = (input_chars / 1000) * prompt_price
-    completion_cost = (output_chars / 1000) * completion_price
+    prompt_cost = (metadata.input_tokens / 1000) * prompt_price
+    completion_cost = (metadata.output_tokens / 1000) * completion_price
     total_cost = prompt_cost + completion_cost
 
     return total_cost

mirascope/core/{xai/_utils/_calculate_cost.py → costs/_xai_calculate_cost.py}

@@ -1,10 +1,10 @@
 """Calculate the cost of a Grok API call."""
 
+from ..base.types import CostMetadata
+
 
 def calculate_cost(
-    input_tokens: int | float | None,
-    cached_tokens: int | float | None,
-    output_tokens: int | float | None,
+    metadata: CostMetadata,
     model: str,
 ) -> float | None:
     """Calculate the cost of an xAI Grok API call.
@@ -81,11 +81,11 @@ def calculate_cost(
         },
     }
 
-    if input_tokens is None or output_tokens is None:
+    if metadata.input_tokens is None or metadata.output_tokens is None:
         return None
 
-    if cached_tokens is None:
-        cached_tokens = 0
+    if metadata.cached_tokens is None:
+        metadata.cached_tokens = 0
 
     try:
         model_pricing = pricing[model]
@@ -96,9 +96,9 @@ def calculate_cost(
     cached_price = model_pricing["cached"]
     completion_price = model_pricing["completion"]
 
-    prompt_cost = input_tokens * prompt_price
-    cached_cost = cached_tokens * cached_price
-    completion_cost = output_tokens * completion_price
+    prompt_cost = metadata.input_tokens * prompt_price
+    cached_cost = metadata.cached_tokens * cached_price
+    completion_cost = metadata.output_tokens * completion_price
     total_cost = prompt_cost + cached_cost + completion_cost
 
     return total_cost

mirascope/core/costs/calculate_cost.py

@@ -0,0 +1,86 @@
+"""Cost calculation utilities for LLM API calls."""
+
+from __future__ import annotations
+
+from ..base.types import CostMetadata, Provider
+from ._anthropic_calculate_cost import (
+    calculate_cost as anthropic_calculate_cost,
+)
+from ._azure_calculate_cost import calculate_cost as azure_calculate_cost
+from ._bedrock_calculate_cost import calculate_cost as bedrock_calculate_cost
+from ._cohere_calculate_cost import calculate_cost as cohere_calculate_cost
+from ._gemini_calculate_cost import calculate_cost as gemini_calculate_cost
+from ._google_calculate_cost import calculate_cost as google_calculate_cost
+from ._groq_calculate_cost import calculate_cost as groq_calculate_cost
+from ._litellm_calculate_cost import calculate_cost as litellm_calculate_cost
+from ._mistral_calculate_cost import calculate_cost as mistral_calculate_cost
+from ._openai_calculate_cost import calculate_cost as openai_calculate_cost
+from ._vertex_calculate_cost import calculate_cost as vertex_calculate_cost
+from ._xai_calculate_cost import calculate_cost as xai_calculate_cost
+
+
+def calculate_cost(
+    provider: Provider,
+    model: str,
+    metadata: CostMetadata | None = None,
+) -> float | None:
+    """Calculate the cost for an LLM API call.
+
+    This function routes to the appropriate provider-specific cost calculation function,
+    preserving existing behavior while providing a unified interface.
+
+    Args:
+        provider: The LLM provider (e.g., "openai", "anthropic")
+        model: The model name (e.g., "gpt-4", "claude-3-opus")
+        metadata: Additional metadata required for cost calculation
+
+    Returns:
+        The calculated cost in USD or None if unable to calculate
+    """
+
+    # Initialize empty metadata if none provided
+    if metadata is None:
+        metadata = CostMetadata()
+
+    # Set default values
+    if metadata.cached_tokens is None:
+        metadata.cached_tokens = 0
+
+    # Route to provider-specific implementations
+    if provider == "openai":
+        return openai_calculate_cost(metadata, model)
+
+    elif provider == "anthropic":
+        return anthropic_calculate_cost(metadata, model)
+
+    elif provider == "azure":
+        return azure_calculate_cost(metadata, model)
+
+    elif provider == "bedrock":
+        return bedrock_calculate_cost(metadata, model)
+
+    elif provider == "cohere":
+        return cohere_calculate_cost(metadata, model)
+
+    elif provider == "gemini":
+        return gemini_calculate_cost(metadata, model)
+
+    elif provider == "google":
+        return google_calculate_cost(metadata, model)
+
+    elif provider == "groq":
+        return groq_calculate_cost(metadata, model)
+
+    elif provider == "mistral":
+        return mistral_calculate_cost(metadata, model)
+
+    elif provider == "vertex":
+        return vertex_calculate_cost(metadata, model)
+
+    elif provider == "xai":
+        return xai_calculate_cost(metadata, model)
+
+    elif provider == "litellm":
+        return litellm_calculate_cost(metadata, model)
+    else:
+        raise ValueError(f"Unsupported provider: {provider}")

mirascope/core/gemini/_utils/__init__.py

@@ -1,13 +1,11 @@
 """Gemini utilities for decorator factories."""
 
-from ._calculate_cost import calculate_cost
 from ._convert_message_params import convert_message_params
 from ._get_json_output import get_json_output
 from ._handle_stream import handle_stream, handle_stream_async
 from ._setup_call import setup_call
 
 __all__ = [
-    "calculate_cost",
     "convert_message_params",
     "get_json_output",
     "handle_stream",

mirascope/core/gemini/call_response.py

@@ -17,8 +17,7 @@ from pydantic import computed_field
 
 from .. import BaseMessageParam
 from ..base import BaseCallResponse, transform_tool_outputs
-from ..base.types import FinishReason
-from ._utils import calculate_cost
+from ..base.types import CostMetadata, FinishReason
 from ._utils._convert_finish_reason_to_common_finish_reasons import (
     _convert_finish_reasons_to_common_finish_reasons,
 )
@@ -134,14 +133,6 @@ class GeminiCallResponse(
         """Returns the number of output tokens."""
         return None
 
-    @computed_field
-    @property
-    def cost(self) -> float | None:
-        """Returns the cost of the call."""
-        return calculate_cost(
-            self.input_tokens, self.cached_tokens, self.output_tokens, self.model
-        )
-
     @computed_field
     @cached_property
     def message_param(self) -> ContentDict:
@@ -213,3 +204,9 @@ class GeminiCallResponse(
         if not self.user_message_param:
             return None
         return GeminiMessageParamConverter.from_provider([self.user_message_param])[0]
+
+    @computed_field
+    @property
+    def cost_metadata(self) -> CostMetadata:
+        """Get metadata required for cost calculation."""
+        return super().cost_metadata

mirascope/core/gemini/call_response_chunk.py

@@ -7,7 +7,7 @@ from google.ai.generativelanguage import Candidate
 from google.generativeai.types import GenerateContentResponse
 
 from ..base import BaseCallResponseChunk
-from ..base.types import FinishReason
+from ..base.types import CostMetadata, FinishReason
 from ._utils._convert_finish_reason_to_common_finish_reasons import (
     _convert_finish_reasons_to_common_finish_reasons,
 )
@@ -88,6 +88,11 @@ class GeminiCallResponseChunk(
         """Returns the number of output tokens."""
         return None
 
+    @property
+    def cost_metadata(self) -> CostMetadata:
+        """Returns the cost metadata."""
+        return super().cost_metadata
+
     @property
     def common_finish_reasons(self) -> list[FinishReason] | None:
         return _convert_finish_reasons_to_common_finish_reasons(

mirascope/core/gemini/stream.py

@@ -22,7 +22,7 @@ from google.generativeai.types import (
 from google.generativeai.types.content_types import PartType
 
 from ..base.stream import BaseStream
-from ._utils import calculate_cost
+from ..base.types import CostMetadata
 from .call_params import GeminiCallParams
 from .call_response import GeminiCallResponse
 from .call_response_chunk import GeminiCallResponseChunk
@@ -66,13 +66,6 @@ class GeminiStream(
 
     _provider = "gemini"
 
-    @property
-    def cost(self) -> float | None:
-        """Returns the cost of the call."""
-        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
     ) -> ContentDict:
@@ -121,3 +114,7 @@ class GeminiStream(
             start_time=self.start_time,
             end_time=self.end_time,
         )
+
+    @property
+    def cost_metadata(self) -> CostMetadata:
+        return super().cost_metadata

mirascope/core/google/_utils/__init__.py

@@ -1,13 +1,11 @@
 """Google utilities for decorator factories."""
 
-from ._calculate_cost import calculate_cost
 from ._convert_message_params import convert_message_params
 from ._get_json_output import get_json_output
 from ._handle_stream import handle_stream, handle_stream_async
 from ._setup_call import setup_call
 
 __all__ = [
-    "calculate_cost",
     "convert_message_params",
     "get_json_output",
     "handle_stream",

mirascope/core/google/_utils/_setup_call.py

@@ -176,5 +176,24 @@ def setup_call(
             client.models.generate_content, client.models.generate_content_stream
         )
     )
-
-    return create, prompt_template, messages, tool_types, call_kwargs
+    if client.vertexai:
+        if isinstance(dynamic_config, dict):
+            metadata = dynamic_config.get("metadata", {})
+            tags = metadata.get("tags", set())
+            tags.add("use_vertex_ai")
+            metadata["tags"] = tags
+            dynamic_config["metadata"] = metadata
+        else:
+            metadata = getattr(fn, "_metadata", {})
+            tags = metadata.get("tags", set())
+            tags.add("use_vertex_ai")
+            metadata["tags"] = tags
+            fn._metadata = metadata
+
+    return (
+        create,
+        prompt_template,
+        messages,
+        tool_types,
+        call_kwargs,
+    )

mirascope/core/google/call_response.py

@@ -21,8 +21,7 @@ from pydantic import computed_field
 
 from .. import BaseMessageParam
 from ..base import BaseCallResponse, transform_tool_outputs
-from ..base.types import FinishReason
-from ._utils import calculate_cost
+from ..base.types import CostMetadata, FinishReason, GoogleMetadata
 from ._utils._convert_finish_reason_to_common_finish_reasons import (
     _convert_finish_reasons_to_common_finish_reasons,
 )
@@ -145,14 +144,6 @@ class GoogleCallResponse(
             else None
         )
 
-    @computed_field
-    @property
-    def cost(self) -> float | None:
-        """Returns the cost of the call."""
-        return calculate_cost(
-            self.input_tokens, self.cached_tokens, self.output_tokens, self.model
-        )
-
     @computed_field
     @cached_property
     def message_param(self) -> ContentDict:
@@ -228,3 +219,11 @@ class GoogleCallResponse(
         if not self.user_message_param:
             return None
         return GoogleMessageParamConverter.from_provider([self.user_message_param])[0]
+
+    @property
+    def cost_metadata(self) -> CostMetadata:
+        cost_metadata = super().cost_metadata
+        cost_metadata.google = GoogleMetadata(
+            use_vertex_ai="use_vertex_ai" in self.metadata.get("tags", [])
+        )
+        return cost_metadata

mirascope/core/google/call_response_chunk.py

@@ -11,7 +11,7 @@ from google.genai.types import (
     GenerateContentResponseUsageMetadata,
 )
 
-from mirascope.core.base.types import FinishReason
+from mirascope.core.base.types import CostMetadata, FinishReason
 
 from ..base import BaseCallResponseChunk
 from ._utils._convert_finish_reason_to_common_finish_reasons import (
@@ -98,6 +98,11 @@ class GoogleCallResponseChunk(
         """Returns the number of output tokens."""
         return self.usage.candidates_token_count if self.usage else None
 
+    @property
+    def cost_metadata(self) -> CostMetadata:
+        """Returns the cost metadata."""
+        return super().cost_metadata
+
     @property
     def common_finish_reasons(self) -> list[FinishReason] | None:
         return _convert_finish_reasons_to_common_finish_reasons(

mirascope/core/google/stream.py

@@ -20,7 +20,7 @@ from google.genai.types import (
 )
 
 from ..base.stream import BaseStream
-from ._utils import calculate_cost
+from ..base.types import CostMetadata
 from .call_params import GoogleCallParams
 from .call_response import GoogleCallResponse
 from .call_response_chunk import GoogleCallResponseChunk
@@ -64,13 +64,6 @@ class GoogleStream(
 
     _provider = "google"
 
-    @property
-    def cost(self) -> float | None:
-        """Returns the cost of the call."""
-        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
     ) -> ContentDict:
@@ -144,3 +137,7 @@ class GoogleStream(
             start_time=self.start_time,
             end_time=self.end_time,
         )
+
+    @property
+    def cost_metadata(self) -> CostMetadata:
+        return super().cost_metadata

mirascope/core/groq/_utils/__init__.py

@@ -1,13 +1,11 @@
 """Groq utilities for decorator factories."""
 
-from ._calculate_cost import calculate_cost
 from ._convert_message_params import convert_message_params
 from ._get_json_output import get_json_output
 from ._handle_stream import handle_stream, handle_stream_async
 from ._setup_call import setup_call
 
 __all__ = [
-    "calculate_cost",
     "convert_message_params",
     "get_json_output",
     "handle_stream",

mirascope/core/groq/call_response.py

@@ -19,8 +19,7 @@ from pydantic import SerializeAsAny, computed_field
 
 from .. import BaseMessageParam
 from ..base import BaseCallResponse, transform_tool_outputs
-from ..base.types import FinishReason
-from ._utils import calculate_cost
+from ..base.types import CostMetadata, FinishReason, ImageMetadata
 from ._utils._message_param_converter import GroqMessageParamConverter
 from .call_params import GroqCallParams
 from .dynamic_config import AsyncGroqDynamicConfig, GroqDynamicConfig
@@ -110,14 +109,6 @@ class GroqCallResponse(
         """Returns the number of output tokens."""
         return self.usage.completion_tokens if self.usage else None
 
-    @computed_field
-    @property
-    def cost(self) -> float | None:
-        """Returns the cost of the call."""
-        return calculate_cost(
-            self.input_tokens, self.cached_tokens, self.output_tokens, self.model
-        )
-
     @computed_field
     @cached_property
     def message_param(self) -> SerializeAsAny[ChatCompletionAssistantMessageParam]:
@@ -195,3 +186,24 @@ class GroqCallResponse(
         if not self.user_message_param:
             return None
         return GroqMessageParamConverter.from_provider([self.user_message_param])[0]
+
+    @property
+    def cost_metadata(self) -> CostMetadata:
+        cost_metadata = super().cost_metadata
+        image_metadata = []
+
+        for message in self.messages:
+            if "content" not in message:
+                continue
+            content = message["content"]
+
+            if not isinstance(content, list):
+                continue
+            for part in content:
+                # Check if this part is an image_url
+                if isinstance(part, dict) and part.get("type") == "image_url":
+                    # Only count the image if it has a URL
+                    image_metadata.append(ImageMetadata(width=0, height=0))
+
+        cost_metadata.images = image_metadata
+        return cost_metadata

mirascope/core/groq/call_response_chunk.py

@@ -10,6 +10,7 @@ from groq.types.chat.chat_completion import Choice
 from groq.types.completion_usage import CompletionUsage
 
 from ..base import BaseCallResponseChunk
+from ..base.types import CostMetadata
 
 FinishReason = Choice.__annotations__["finish_reason"]
 
@@ -93,6 +94,11 @@ class GroqCallResponseChunk(BaseCallResponseChunk[ChatCompletionChunk, FinishRea
             return self.usage.completion_tokens
         return None
 
+    @property
+    def cost_metadata(self) -> CostMetadata:
+        """Returns the cost metadata."""
+        return super().cost_metadata
+
     @property
     def common_finish_reasons(self) -> list[FinishReason] | None:
         return cast(list[FinishReason], self.finish_reasons)

mirascope/core/groq/stream.py

@@ -17,7 +17,7 @@ from groq.types.chat.chat_completion_message import ChatCompletionMessage
 from groq.types.completion_usage import CompletionUsage
 
 from ..base.stream import BaseStream
-from ._utils import calculate_cost
+from ..base.types import CostMetadata
 from .call_params import GroqCallParams
 from .call_response import GroqCallResponse
 from .call_response_chunk import GroqCallResponseChunk
@@ -63,13 +63,6 @@ class GroqStream(
 
     _provider = "groq"
 
-    @property
-    def cost(self) -> float | None:
-        """Returns the cost of the call."""
-        return calculate_cost(
-            self.input_tokens, self.cached_tokens, self.output_tokens, self.model
-        )
-
     def _construct_message_param(
         self,
         tool_calls: list[ChatCompletionMessageToolCallParam] | None = None,
@@ -136,3 +129,7 @@ class GroqStream(
             start_time=self.start_time,
             end_time=self.end_time,
         )
+
+    @property
+    def cost_metadata(self) -> CostMetadata:
+        return super().cost_metadata

mirascope/core/litellm/call_response.py

@@ -3,9 +3,9 @@
 usage docs: learn/calls.md#handling-responses
 """
 
-from litellm.cost_calculator import completion_cost
 from pydantic import computed_field
 
+from ..base.types import CostMetadata
 from ..openai import OpenAICallResponse
 
 
@@ -20,6 +20,5 @@ class LiteLLMCallResponse(OpenAICallResponse):
 
     @computed_field
     @property
-    def cost(self) -> float | None:
-        """Returns the cost of the call."""
-        return completion_cost(self.response)
+    def cost_metadata(self) -> CostMetadata:
+        return CostMetadata(cost=self.response._hidden_params["response_cost"])  # pyright: ignore [reportAttributeAccessIssue]

mirascope/core/litellm/stream.py

@@ -6,8 +6,10 @@ usage docs: learn/streams.md
 from collections.abc import AsyncGenerator, Generator
 
 from litellm import Choices, Message
+from litellm.cost_calculator import completion_cost
 from litellm.types.utils import ModelResponse
 
+from ..base.types import CostMetadata
 from ..openai import OpenAIStream, OpenAITool
 from .call_response import LiteLLMCallResponse
 from .call_response_chunk import LiteLLMCallResponseChunk
@@ -34,35 +36,41 @@ class LiteLLMStream(OpenAIStream):
         return super().__aiter__()  # pyright: ignore [reportReturnType] # pragma: no cover
 
     @property
-    def cost(self) -> float | None:
-        """Returns the cost of the call."""
+    def cost_metadata(self) -> CostMetadata:
+        """Returns metadata needed for cost calculation."""
         response = self.construct_call_response()
-        return response.cost
+        return CostMetadata(
+            cost=response.cost,
+        )
 
     def construct_call_response(self) -> LiteLLMCallResponse:
         openai_call_response = super().construct_call_response()
         openai_response = openai_call_response.response
+        model_response = ModelResponse(
+            id=openai_response.id,
+            choices=[
+                Choices(
+                    finish_reason=choice.finish_reason,
+                    index=choice.index,
+                    message=Message(**choice.message.model_dump()),
+                    logprobs=choice.logprobs,
+                )
+                for choice in openai_response.choices
+            ],
+            created=openai_response.created,
+            model=openai_response.model,
+            object=openai_response.object,
+            system_fingerprint=openai_response.system_fingerprint,
+            usage=openai_response.usage.model_dump() if openai_response.usage else None,
+        )
+        model_response._hidden_params["response_cost"] = completion_cost(
+            model=self.model,
+            messages=openai_call_response.messages,
+            completion=openai_call_response.content,
+        )
         response = LiteLLMCallResponse(
             metadata=openai_call_response.metadata,
-            response=ModelResponse(
-                id=openai_response.id,
-                choices=[
-                    Choices(
-                        finish_reason=choice.finish_reason,
-                        index=choice.index,
-                        message=Message(**choice.message.model_dump()),
-                        logprobs=choice.logprobs,
-                    )
-                    for choice in openai_response.choices
-                ],
-                created=openai_response.created,
-                model=openai_response.model,
-                object=openai_response.object,
-                system_fingerprint=openai_response.system_fingerprint,
-                usage=openai_response.usage.model_dump()
-                if openai_response.usage
-                else None,
-            ),  # pyright: ignore [reportArgumentType]
+            response=model_response,  # pyright: ignore [reportArgumentType]
             tool_types=openai_call_response.tool_types,
             prompt_template=openai_call_response.prompt_template,
             fn_args=openai_call_response.fn_args,

mirascope/core/mistral/_utils/__init__.py

@@ -1,13 +1,11 @@
 """Mistral utilities for decorator factories."""
 
-from ._calculate_cost import calculate_cost
 from ._convert_message_params import convert_message_params
 from ._get_json_output import get_json_output
 from ._handle_stream import handle_stream, handle_stream_async
 from ._setup_call import setup_call
 
 __all__ = [
-    "calculate_cost",
     "convert_message_params",
     "get_json_output",
     "handle_stream",

mirascope/core/mistral/call_response.py

@@ -19,8 +19,7 @@ from pydantic import computed_field
 
 from .. import BaseMessageParam
 from ..base import BaseCallResponse, transform_tool_outputs
-from ..base.types import FinishReason
-from ._utils import calculate_cost
+from ..base.types import CostMetadata, FinishReason
 from ._utils._convert_finish_reason_to_common_finish_reasons import (
     _convert_finish_reasons_to_common_finish_reasons,
 )
@@ -119,14 +118,6 @@ class MistralCallResponse(
         """Returns the number of output tokens."""
         return self.usage.completion_tokens
 
-    @computed_field
-    @property
-    def cost(self) -> float | None:
-        """Returns the cost of the call."""
-        return calculate_cost(
-            self.input_tokens, self.cached_tokens, self.output_tokens, self.model
-        )
-
     @computed_field
     @cached_property
     def message_param(self) -> AssistantMessage:
@@ -200,3 +191,9 @@ class MistralCallResponse(
         if not self.user_message_param:
             return None
         return MistralMessageParamConverter.from_provider([self.user_message_param])[0]
+
+    @computed_field
+    @property
+    def cost_metadata(self) -> CostMetadata:
+        """Get metadata required for cost calculation."""
+        return super().cost_metadata