mirascope 2.1.1__py3-none-any.whl → 2.2.0__py3-none-any.whl

mirascope/llm/retries/utils.py

@@ -0,0 +1,159 @@
+"""Utility functions for retry logic."""
+
+import random
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, TypeVar
+
+from ..exceptions import RetriesExhausted
+from .retry_config import RetryConfig
+
+if TYPE_CHECKING:
+    from ..models import Model
+    from .retry_models import RetryModel
+
+
+def get_retry_model_from_context(stored_retry_model: "RetryModel") -> "RetryModel":
+    """Get the RetryModel to use, checking context for overrides.
+
+    If a model is set in context (via `llm.model()` or `llm.retry_model()`),
+    that model is used instead, wrapped with this response's retry config.
+
+    Args:
+        stored_retry_model: The RetryModel stored on the response.
+
+    Returns:
+        Either the context model (wrapped in RetryModel if needed) or the stored model.
+    """
+    from ..models import model_from_context
+    from .retry_models import RetryModel
+
+    context_model = model_from_context()
+    if context_model is not None:
+        if isinstance(context_model, RetryModel):
+            return context_model
+        return RetryModel(context_model, stored_retry_model.retry_config)
+    return stored_retry_model
+
+
+_ResultT = TypeVar("_ResultT")
+
+
+@dataclass
+class RetryFailure:
+    """A failed attempt to call a model.
+
+    Attributes:
+        model: The model that was tried.
+        exception: The exception that was raised.
+    """
+
+    model: "Model"
+    exception: BaseException
+
+
+def calculate_delay(config: RetryConfig, attempt_for_model: int) -> float:
+    """Calculate the delay before the next retry attempt.
+
+    Args:
+        config: The retry configuration with backoff settings.
+        attempt_for_model: The retry attempt number for this model (1-indexed).
+
+    Returns:
+        The delay in seconds, with exponential backoff, capped at max_delay,
+        and optionally with jitter applied.
+    """
+    # Calculate base delay with exponential backoff
+    delay = config.initial_delay * (
+        config.backoff_multiplier ** (attempt_for_model - 1)
+    )
+
+    # Cap at max_delay
+    delay = min(delay, config.max_delay)
+
+    # Apply jitter if configured
+    if config.jitter > 0:
+        jitter_range = delay * config.jitter
+        delay = delay + random.uniform(-jitter_range, jitter_range)
+        # Ensure delay doesn't go negative
+        delay = max(0, delay)
+
+    return delay
+
+
+def with_retry(
+    fn: Callable[["Model"], _ResultT],
+    retry_model: "RetryModel",
+) -> tuple[_ResultT, list[RetryFailure], "RetryModel"]:
+    """Execute a function with retry logic across the RetryModel's models.
+
+    Tries the active model first, then fallbacks. Each model gets its own
+    full retry budget. Returns an updated RetryModel with the successful
+    model set as active.
+
+    Args:
+        fn: Function that takes a Model and returns a result.
+        retry_model: The RetryModel containing models and retry config.
+
+    Returns:
+        A tuple of (result, failures, updated_retry_model).
+        failures contains all failed attempts before success.
+        The updated_retry_model has the successful model as active.
+
+    Raises:
+        Exception: The last exception encountered if all models exhaust retries.
+    """
+    config = retry_model.retry_config
+    failures: list[RetryFailure] = []
+
+    for variant in retry_model.variants():
+        model = variant.get_active_model()
+        try:
+            result = fn(model)
+            return result, failures, variant
+        except config.retry_on as e:
+            failures.append(RetryFailure(model=model, exception=e))
+
+    # All models exhausted
+    if failures:
+        raise RetriesExhausted(failures)
+    raise AssertionError("Unreachable: no models provided")  # pragma: no cover
+
+
+async def with_retry_async(
+    fn: Callable[["Model"], Awaitable[_ResultT]],
+    retry_model: "RetryModel",
+) -> tuple[_ResultT, list[RetryFailure], "RetryModel"]:
+    """Execute an async function with retry logic across the RetryModel's models.
+
+    Tries the active model first, then fallbacks. Each model gets its own
+    full retry budget. Returns an updated RetryModel with the successful
+    model set as active.
+
+    Args:
+        fn: Async function that takes a Model and returns a result.
+        retry_model: The RetryModel containing models and retry config.
+
+    Returns:
+        A tuple of (result, failures, updated_retry_model).
+        failures contains all failed attempts before success.
+        The updated_retry_model has the successful model as active.
+
+    Raises:
+        Exception: The last exception encountered if all models exhaust retries.
+    """
+    config = retry_model.retry_config
+    failures: list[RetryFailure] = []
+
+    async for variant in retry_model.variants_async():
+        model = variant.get_active_model()
+        try:
+            result = await fn(model)
+            return result, failures, variant
+        except config.retry_on as e:
+            failures.append(RetryFailure(model=model, exception=e))
+
+    # All models exhausted
+    if failures:
+        raise RetriesExhausted(failures)
+    raise AssertionError("Unreachable: no models provided")  # pragma: no cover

mirascope/ops/_internal/versioned_calls.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass, field
-from typing import Concatenate, Generic
+from typing import Concatenate, Generic, cast, overload
 from typing_extensions import TypeIs
 
 from ...llm.calls import AsyncCall, AsyncContextCall, Call, ContextCall
@@ -238,23 +238,61 @@ class VersionedCall(_BaseVersionedCall, Generic[P, FormattableT]):
         )
         self._compute_closure(self._call, self.call, self.stream)
 
+    @overload
+    def __call__(
+        self: VersionedCall[P, None], *args: P.args, **kwargs: P.kwargs
+    ) -> Response: ...
+
+    @overload
+    def __call__(
+        self: VersionedCall[P, FormattableT], *args: P.args, **kwargs: P.kwargs
+    ) -> Response[FormattableT]: ...
+
     def __call__(
         self, *args: P.args, **kwargs: P.kwargs
     ) -> Response | Response[FormattableT]:
         """Call the versioned function and return Response directly."""
         return self.call(*args, **kwargs)
 
+    @overload
+    def wrapped(
+        self: VersionedCall[P, None], *args: P.args, **kwargs: P.kwargs
+    ) -> VersionedResult[Response]: ...
+
+    @overload
+    def wrapped(
+        self: VersionedCall[P, FormattableT], *args: P.args, **kwargs: P.kwargs
+    ) -> VersionedResult[Response[FormattableT]]: ...
+
     def wrapped(
         self, *args: P.args, **kwargs: P.kwargs
-    ) -> VersionedResult[Response | Response[FormattableT]]:
+    ) -> VersionedResult[Response] | VersionedResult[Response[FormattableT]]:
         """Call the versioned function and return a wrapped Response."""
-        return self.call.wrapped(*args, **kwargs)
+        return cast(
+            "VersionedResult[Response] | VersionedResult[Response[FormattableT]]",
+            self.call.wrapped(*args, **kwargs),
+        )
+
+    @overload
+    def wrapped_stream(
+        self: VersionedCall[P, None], *args: P.args, **kwargs: P.kwargs
+    ) -> VersionedResult[StreamResponse]: ...
+
+    @overload
+    def wrapped_stream(
+        self: VersionedCall[P, FormattableT], *args: P.args, **kwargs: P.kwargs
+    ) -> VersionedResult[StreamResponse[FormattableT]]: ...
 
     def wrapped_stream(
         self, *args: P.args, **kwargs: P.kwargs
-    ) -> VersionedResult[StreamResponse | StreamResponse[FormattableT]]:
+    ) -> (
+        VersionedResult[StreamResponse] | VersionedResult[StreamResponse[FormattableT]]
+    ):
         """Stream the versioned function and return a wrapped StreamResponse."""
-        return self.stream.wrapped(*args, **kwargs)
+        return cast(
+            "VersionedResult[StreamResponse] | VersionedResult[StreamResponse[FormattableT]]",
+            self.stream.wrapped(*args, **kwargs),
+        )
 
 
 @dataclass(kw_only=True)
@@ -308,23 +346,65 @@ class VersionedAsyncCall(_BaseVersionedCall, Generic[P, FormattableT]):
         )
         self._compute_closure(self._call, self.call, self.stream)
 
+    @overload
+    async def __call__(
+        self: VersionedAsyncCall[P, None], *args: P.args, **kwargs: P.kwargs
+    ) -> AsyncResponse: ...
+
+    @overload
+    async def __call__(
+        self: VersionedAsyncCall[P, FormattableT], *args: P.args, **kwargs: P.kwargs
+    ) -> AsyncResponse[FormattableT]: ...
+
     async def __call__(
         self, *args: P.args, **kwargs: P.kwargs
     ) -> AsyncResponse | AsyncResponse[FormattableT]:
         """Call the versioned function and return AsyncResponse directly."""
         return await self.call(*args, **kwargs)
 
+    @overload
+    async def wrapped(
+        self: VersionedAsyncCall[P, None], *args: P.args, **kwargs: P.kwargs
+    ) -> AsyncVersionedResult[AsyncResponse]: ...
+
+    @overload
+    async def wrapped(
+        self: VersionedAsyncCall[P, FormattableT], *args: P.args, **kwargs: P.kwargs
+    ) -> AsyncVersionedResult[AsyncResponse[FormattableT]]: ...
+
     async def wrapped(
         self, *args: P.args, **kwargs: P.kwargs
-    ) -> AsyncVersionedResult[AsyncResponse | AsyncResponse[FormattableT]]:
+    ) -> (
+        AsyncVersionedResult[AsyncResponse]
+        | AsyncVersionedResult[AsyncResponse[FormattableT]]
+    ):
         """Call the versioned function and return a wrapped Response."""
-        return await self.call.wrapped(*args, **kwargs)
+        return cast(
+            "AsyncVersionedResult[AsyncResponse] | AsyncVersionedResult[AsyncResponse[FormattableT]]",
+            await self.call.wrapped(*args, **kwargs),
+        )
+
+    @overload
+    async def wrapped_stream(
+        self: VersionedAsyncCall[P, None], *args: P.args, **kwargs: P.kwargs
+    ) -> AsyncVersionedResult[AsyncStreamResponse]: ...
+
+    @overload
+    async def wrapped_stream(
+        self: VersionedAsyncCall[P, FormattableT], *args: P.args, **kwargs: P.kwargs
+    ) -> AsyncVersionedResult[AsyncStreamResponse[FormattableT]]: ...
 
     async def wrapped_stream(
         self, *args: P.args, **kwargs: P.kwargs
-    ) -> AsyncVersionedResult[AsyncStreamResponse | AsyncStreamResponse[FormattableT]]:
+    ) -> (
+        AsyncVersionedResult[AsyncStreamResponse]
+        | AsyncVersionedResult[AsyncStreamResponse[FormattableT]]
+    ):
         """Stream the versioned function and return a wrapped StreamResponse."""
-        return await self.stream.wrapped(*args, **kwargs)
+        return cast(
+            "AsyncVersionedResult[AsyncStreamResponse] | AsyncVersionedResult[AsyncStreamResponse[FormattableT]]",
+            await self.stream.wrapped(*args, **kwargs),
+        )
 
 
 @dataclass(kw_only=True)
@@ -381,18 +461,66 @@ class VersionedContextCall(_BaseVersionedCall, Generic[P, DepsT, FormattableT]):
         )
         self._compute_closure(self._call, self._call_versioned, self._stream_versioned)
 
+    @overload
+    def call(
+        self: VersionedContextCall[P, DepsT, None],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> ContextResponse[DepsT, None]: ...
+
+    @overload
+    def call(
+        self: VersionedContextCall[P, DepsT, FormattableT],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> ContextResponse[DepsT, FormattableT]: ...
+
     def call(
         self, ctx: Context[DepsT], *args: P.args, **kwargs: P.kwargs
     ) -> ContextResponse[DepsT, None] | ContextResponse[DepsT, FormattableT]:
         """Call the versioned function and return ContextResponse directly."""
         return self._call_versioned(ctx, *args, **kwargs)
 
+    @overload
+    def __call__(
+        self: VersionedContextCall[P, DepsT, None],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> ContextResponse[DepsT, None]: ...
+
+    @overload
+    def __call__(
+        self: VersionedContextCall[P, DepsT, FormattableT],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> ContextResponse[DepsT, FormattableT]: ...
+
     def __call__(
         self, ctx: Context[DepsT], *args: P.args, **kwargs: P.kwargs
     ) -> ContextResponse[DepsT, None] | ContextResponse[DepsT, FormattableT]:
         """Call the versioned function and return ContextResponse directly."""
         return self.call(ctx, *args, **kwargs)
 
+    @overload
+    def stream(
+        self: VersionedContextCall[P, DepsT, None],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> ContextStreamResponse[DepsT, None]: ...
+
+    @overload
+    def stream(
+        self: VersionedContextCall[P, DepsT, FormattableT],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> ContextStreamResponse[DepsT, FormattableT]: ...
+
     def stream(
         self, ctx: Context[DepsT], *args: P.args, **kwargs: P.kwargs
     ) -> (
@@ -401,6 +529,22 @@ class VersionedContextCall(_BaseVersionedCall, Generic[P, DepsT, FormattableT]):
         """Stream the versioned function and return a ContextStreamResponse."""
         return self._stream_versioned(ctx, *args, **kwargs)
 
+    @overload
+    def wrapped(
+        self: VersionedContextCall[P, DepsT, None],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> VersionedResult[ContextResponse[DepsT, None]]: ...
+
+    @overload
+    def wrapped(
+        self: VersionedContextCall[P, DepsT, FormattableT],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> VersionedResult[ContextResponse[DepsT, FormattableT]]: ...
+
     def wrapped(
         self, ctx: Context[DepsT], *args: P.args, **kwargs: P.kwargs
     ) -> VersionedResult[
@@ -409,6 +553,22 @@ class VersionedContextCall(_BaseVersionedCall, Generic[P, DepsT, FormattableT]):
         """Call the versioned function and return a wrapped Response."""
         return self._call_versioned.wrapped(ctx, *args, **kwargs)
 
+    @overload
+    def wrapped_stream(
+        self: VersionedContextCall[P, DepsT, None],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> VersionedResult[ContextStreamResponse[DepsT, None]]: ...
+
+    @overload
+    def wrapped_stream(
+        self: VersionedContextCall[P, DepsT, FormattableT],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> VersionedResult[ContextStreamResponse[DepsT, FormattableT]]: ...
+
     def wrapped_stream(
         self, ctx: Context[DepsT], *args: P.args, **kwargs: P.kwargs
     ) -> VersionedResult[
@@ -473,18 +633,66 @@ class VersionedAsyncContextCall(_BaseVersionedCall, Generic[P, DepsT, Formattabl
         )
         self._compute_closure(self._call, self._call_versioned, self._stream_versioned)
 
+    @overload
+    async def call(
+        self: VersionedAsyncContextCall[P, DepsT, None],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncContextResponse[DepsT, None]: ...
+
+    @overload
+    async def call(
+        self: VersionedAsyncContextCall[P, DepsT, FormattableT],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncContextResponse[DepsT, FormattableT]: ...
+
     async def call(
         self, ctx: Context[DepsT], *args: P.args, **kwargs: P.kwargs
     ) -> AsyncContextResponse[DepsT, None] | AsyncContextResponse[DepsT, FormattableT]:
         """Call the versioned function and return AsyncContextResponse directly."""
         return await self._call_versioned(ctx, *args, **kwargs)
 
+    @overload
+    async def __call__(
+        self: VersionedAsyncContextCall[P, DepsT, None],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncContextResponse[DepsT, None]: ...
+
+    @overload
+    async def __call__(
+        self: VersionedAsyncContextCall[P, DepsT, FormattableT],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncContextResponse[DepsT, FormattableT]: ...
+
     async def __call__(
         self, ctx: Context[DepsT], *args: P.args, **kwargs: P.kwargs
     ) -> AsyncContextResponse[DepsT, None] | AsyncContextResponse[DepsT, FormattableT]:
         """Call the versioned function and return AsyncContextResponse directly."""
         return await self.call(ctx, *args, **kwargs)
 
+    @overload
+    async def stream(
+        self: VersionedAsyncContextCall[P, DepsT, None],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncContextStreamResponse[DepsT, None]: ...
+
+    @overload
+    async def stream(
+        self: VersionedAsyncContextCall[P, DepsT, FormattableT],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncContextStreamResponse[DepsT, FormattableT]: ...
+
     async def stream(
         self, ctx: Context[DepsT], *args: P.args, **kwargs: P.kwargs
     ) -> (
@@ -494,6 +702,22 @@ class VersionedAsyncContextCall(_BaseVersionedCall, Generic[P, DepsT, Formattabl
         """Stream the versioned function and return an AsyncContextStreamResponse."""
         return await self._stream_versioned(ctx, *args, **kwargs)
 
+    @overload
+    async def wrapped(
+        self: VersionedAsyncContextCall[P, DepsT, None],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncVersionedResult[AsyncContextResponse[DepsT, None]]: ...
+
+    @overload
+    async def wrapped(
+        self: VersionedAsyncContextCall[P, DepsT, FormattableT],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncVersionedResult[AsyncContextResponse[DepsT, FormattableT]]: ...
+
     async def wrapped(
         self, ctx: Context[DepsT], *args: P.args, **kwargs: P.kwargs
     ) -> AsyncVersionedResult[
@@ -502,6 +726,22 @@ class VersionedAsyncContextCall(_BaseVersionedCall, Generic[P, DepsT, Formattabl
         """Call the versioned function and return a wrapped Response."""
         return await self._call_versioned.wrapped(ctx, *args, **kwargs)
 
+    @overload
+    async def wrapped_stream(
+        self: VersionedAsyncContextCall[P, DepsT, None],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncVersionedResult[AsyncContextStreamResponse[DepsT, None]]: ...
+
+    @overload
+    async def wrapped_stream(
+        self: VersionedAsyncContextCall[P, DepsT, FormattableT],
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncVersionedResult[AsyncContextStreamResponse[DepsT, FormattableT]]: ...
+
     async def wrapped_stream(
         self, ctx: Context[DepsT], *args: P.args, **kwargs: P.kwargs
     ) -> AsyncVersionedResult[

mirascope/ops/_internal/versioned_functions.py

@@ -270,6 +270,7 @@ class VersionedFunction(_BaseVersionedFunction[P, R], BaseSyncTracedFunction[P,
                 signature=self.closure.signature,
                 signature_hash=self.closure.signature_hash,
                 name=self.name or self.closure.name,
+                language="python",
                 description=self.closure.docstring,
                 tags=list(self.tags) if self.tags else None,
                 metadata=cast(dict[str, str | None], self.metadata)
@@ -344,6 +345,7 @@ class AsyncVersionedFunction(
                 signature=self.closure.signature,
                 signature_hash=self.closure.signature_hash,
                 name=self.name or self.closure.name,
+                language="python",
                 description=self.closure.docstring,
                 tags=list(self.tags) if self.tags else None,
                 metadata=cast(dict[str, str | None], self.metadata)

{mirascope-2.1.1.dist-info → mirascope-2.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mirascope
-Version: 2.1.1
+Version: 2.2.0
 Summary: Every frontier LLM. One unified interface.
 Project-URL: Homepage, https://mirascope.com
 Project-URL: Documentation, https://mirascope.com/docs/mirascope/v2

{mirascope-2.1.1.dist-info → mirascope-2.2.0.dist-info}/RECORD

@@ -8,7 +8,7 @@ mirascope/api/_generated/README.md,sha256=7-B_qhXCHaXKX9FPG-G112hKmXM64uM6eNqmSd
 mirascope/api/_generated/__init__.py,sha256=NL-bCeIoDl0-VavSWKQpN_WAXlIxh4VJb1zrFfFWdfI,16952
 mirascope/api/_generated/client.py,sha256=Xh_VGnnbdZaSUpWzjGWu-1lwoZ_6isz9eU-BATjo_vs,8775
 mirascope/api/_generated/environment.py,sha256=eKhvb5ZF3qzJj2OtEI7E9STAquQ1VivYLdmHRc4hFV4,262
-mirascope/api/_generated/reference.md,sha256=GvMROs5SFqtQQIHH31FLkpLgOznJI9BadG-dfq2GNNQ,54335
+mirascope/api/_generated/reference.md,sha256=QHYOhEYd2WU8RHtMLcJ2wpNXAfHlKi4KnwQtjl66i0Q,54410
 mirascope/api/_generated/annotations/__init__.py,sha256=z1rsEyNXWcegCIeC-Y2P9TBI0fVbNs1FohqSJiqrK84,987
 mirascope/api/_generated/annotations/client.py,sha256=rikFtCmou4D4hSZqtaxFnIc7ZKMt86XztUyh4pMcXII,13818
 mirascope/api/_generated/annotations/raw_client.py,sha256=EEC2Rr5KT_WmLn9aFgQxApnxHGl3MdOOcoYAti4syhE,54205
@@ -72,23 +72,23 @@ mirascope/api/_generated/errors/service_unavailable_error.py,sha256=gLGMVEFuS7rz
 mirascope/api/_generated/errors/too_many_requests_error.py,sha256=uOvzFzeCaBzFI-uENVev0OmDJHLjNTHVQSxxffjnjp0,413
 mirascope/api/_generated/errors/unauthorized_error.py,sha256=d5MEGAcmZ65n2bx1WAVa4goJ2q7uugy6YZyGCs_zHoM,400
 mirascope/api/_generated/functions/__init__.py,sha256=oLjCzn-MKrHIxGV5z2elOK4dG4esHoJwMQFRjbEK7r4,1381
-mirascope/api/_generated/functions/client.py,sha256=vLykxRH6HVXeG7D7YPFmU6ttSRXZlTSNDb-hXtABCaM,16462
-mirascope/api/_generated/functions/raw_client.py,sha256=6eqPk4YI7o1X4L-tQ3n2RZkCkag3gKiTADH3vW_Pww0,72462
+mirascope/api/_generated/functions/client.py,sha256=j-zalqXnjyqv5wOBlChkG0p5wy0fjs4yU_JzYG8k7aY,16688
+mirascope/api/_generated/functions/raw_client.py,sha256=7gac4zL5i7s5Qsw0wT9hHFK7h4wM2yWHLBAq_Y9IYp4,72632
 mirascope/api/_generated/functions/types/__init__.py,sha256=ePNVxcxuQxjPllnMOXAB-4pVo1uW2aaX_NPv4EPR3hQ,2155
 mirascope/api/_generated/functions/types/functions_create_request_dependencies_value.py,sha256=A-bx9nZE0aYoNLuLo6xQYe2GvvUq76ZiBfdJOZ31n2c,603
-mirascope/api/_generated/functions/types/functions_create_response.py,sha256=-NIC1-HuzDHpAfnM4bYgSb1V3EkffqJ3Ud_Mi1LH_iQ,1642
+mirascope/api/_generated/functions/types/functions_create_response.py,sha256=XvhaneMVKHNp9V9WYtMiRbASCp8kRN4e3WjhFDPx__M,1775
 mirascope/api/_generated/functions/types/functions_create_response_dependencies_value.py,sha256=uH0JsZ4QbarNF1eiVT_go8GbMVndHeBRPe7MOemlpJc,604
-mirascope/api/_generated/functions/types/functions_find_by_hash_response.py,sha256=yjm77Q3bPditf4xK7tVIPR9DkYWoGtt2nAup8px42EE,1676
+mirascope/api/_generated/functions/types/functions_find_by_hash_response.py,sha256=teRk8SrU2nSxNeLKdhDjsUbF0acaFutUnYzGEWm0zGc,1793
 mirascope/api/_generated/functions/types/functions_find_by_hash_response_dependencies_value.py,sha256=ZrhLgxa2vDThOc9AgLjSiYMjFBQfLaT-6hRvNgx6pog,608
-mirascope/api/_generated/functions/types/functions_get_by_env_response.py,sha256=IdmzapxETNVX9ATkfl7VK2V7ZOO3ULXipA7UWGNPUW4,1767
+mirascope/api/_generated/functions/types/functions_get_by_env_response.py,sha256=ot7ESVeqtHimuyXenjwxEM-Y0BfGwNob0ekt0FEdUXM,1785
 mirascope/api/_generated/functions/types/functions_get_by_env_response_dependencies_value.py,sha256=Z1BTN_3xh_VKtQj872eirU5o6dAbmUhv7bzjzKddhas,628
-mirascope/api/_generated/functions/types/functions_get_response.py,sha256=JLyHjIuf4tWSX6KNjt9_mobSZC9pUuGfwLFOno3i6pw,1630
+mirascope/api/_generated/functions/types/functions_get_response.py,sha256=sZfNT1NAVCk--OUvaeDCQWngUncWy30nf2kwdV1lYdM,1763
 mirascope/api/_generated/functions/types/functions_get_response_dependencies_value.py,sha256=OiD6Z39V4cDImDRILIfQfgVlMH3idJz9RQ8p5jG6DWE,601
 mirascope/api/_generated/functions/types/functions_list_by_env_response.py,sha256=DnFTgOg7jP_WkghF8FCJM9zDE8SrUgGzQUW7NhSfJYc,735
-mirascope/api/_generated/functions/types/functions_list_by_env_response_functions_item.py,sha256=zO2mD0td0OJQdPxWJHmdEJqgdhzSENS90ApQxKDrtAM,1860
+mirascope/api/_generated/functions/types/functions_list_by_env_response_functions_item.py,sha256=OGuqKYlGJbVdp9BMNEQCMtZgobAgvX62FYrfSPm1cQI,1878
 mirascope/api/_generated/functions/types/functions_list_by_env_response_functions_item_dependencies_value.py,sha256=hE_610_LWn5YVoxRiwbW1KHBTR9a3Fp1eFYIPhFdSjY,642
 mirascope/api/_generated/functions/types/functions_list_response.py,sha256=QFrlBjZugHKQ6oL1bqSvyhg1Tal6ZQG1ZW9rEN8PPMA,682
-mirascope/api/_generated/functions/types/functions_list_response_functions_item.py,sha256=oPJKwQdKo8M0vXVA333SLMI9M-LfpohjEfEn3ktMjl4,1711
+mirascope/api/_generated/functions/types/functions_list_response_functions_item.py,sha256=OiZIwM598UzwytXS8a4b7FgesabKUGkP3_iOtJKonWM,1843
 mirascope/api/_generated/functions/types/functions_list_response_functions_item_dependencies_value.py,sha256=wPsajRsxnZ1Ut9dxmnMWOibrJ38IwiR0v-_6x9_P4Dg,615
 mirascope/api/_generated/health/__init__.py,sha256=UN1u0qzFG8zDGf3CABrpMNNEP467lQZKLQfTOpkwm2E,215
 mirascope/api/_generated/health/client.py,sha256=iqLicxinxNofeZfFkQVOv9Xv0o37amPQbDawA3UCVO8,2520
@@ -265,10 +265,10 @@ mirascope/api/_generated/types/subscription_past_due_error.py,sha256=a-1Rb33jN_p
 mirascope/api/_generated/types/subscription_past_due_error_tag.py,sha256=ghRiStRa--el9MUbcTwhfYKdhj60cqf08DIqZYUArFg,185
 mirascope/api/_generated/types/unauthorized_error_body.py,sha256=0k725xKXRagfrb1HJoygl87SQvZdd6WEU2ACrDbt694,618
 mirascope/api/_generated/types/unauthorized_error_tag.py,sha256=sx-QdNmQjboMaPni2EVKoorYvWk5OmHHlT5-IBiFhQw,165
-mirascope/llm/__init__.py,sha256=AeP8Lghi-EFgStXshoqO_MCgYtE8UyxpJ41CyCSyebA,6234
-mirascope/llm/exceptions.py,sha256=hYc8A8A6unqPaB9GmvdlWIEUso4NWlR7lXELEVVyGFc,10839
+mirascope/llm/__init__.py,sha256=Lj4Goc1m5GLQPGSFujYjlskTwc73gpj6SjTjPwUG24A,7173
+mirascope/llm/exceptions.py,sha256=Xj0RjkXb17FoGMC3YvGR6j2bVel_OMGPXh_qHwgzV-U,13120
 mirascope/llm/calls/__init__.py,sha256=aA-IoOlXdmhVybHTj_fGx1jDlIL-a7ed7xncO2aMIJY,293
-mirascope/llm/calls/calls.py,sha256=g71njIpo5hWvNCnSsDeT8c3l-IaAes01iKrwMyPIYlY,12089
+mirascope/llm/calls/calls.py,sha256=ckHpAJzLSlnw5d3vIpKO_jaHhlcar-5FaY5OWEjhvRw,12807
 mirascope/llm/calls/decorator.py,sha256=dPD04bfpvJueZWcJ4H7LY-a63U-RYQ7VRnv0M3BKxqI,8945
 mirascope/llm/content/__init__.py,sha256=4a5UaoiF8OKfXS9j7INFvOnU7bkNpacpiZ6IlLgC6Lc,1926
 mirascope/llm/content/audio.py,sha256=W6liY1PuQ0pF91eDBnNKW52dr-G7-vnd-rhlSqebx9Y,5311
@@ -300,7 +300,7 @@ mirascope/llm/models/thinking_config.py,sha256=CkFOkw-fjDlsZbHJbV68v4yRwb5o6miVx
 mirascope/llm/prompts/__init__.py,sha256=rOtSiZvw6vsJl7vCFWzKZnm3haNhnLtPRzPfdbgoH7U,727
 mirascope/llm/prompts/_utils.py,sha256=42hTqm8PuLpDOz4Mi59kaUou43qeo5R-9703l8cciSg,1018
 mirascope/llm/prompts/decorator.py,sha256=lwGfPokTxaeiJlHby4vsN09DII8Rd4piThNWwtoGmoc,6921
-mirascope/llm/prompts/prompts.py,sha256=-HFdzebMOmp5Yy7fPfVSADdLZVVnhzo6g7cEfgeLa8M,16019
+mirascope/llm/prompts/prompts.py,sha256=kNhvMOyCrVRQ4WFrwgMw5FBRQxkBjkPfLEC8G0Ui2UI,16936
 mirascope/llm/prompts/protocols.py,sha256=auopJnLAfOognCFVVnXrvb4zFj3102Ofi2iVHfublM0,2242
 mirascope/llm/providers/__init__.py,sha256=nGCTJsF0vbWiD6r4D4nkfTGWfMB23k0eV_HHRVkFdG8,2093
 mirascope/llm/providers/model_id.py,sha256=qr7RKkP_3Blgxjzw_HvQVJLM1aTzsP-jVFsycz0itI8,292
@@ -370,11 +370,20 @@ mirascope/llm/responses/_utils.py,sha256=0_vuY5qcFD91sF2uCOM1PxJse5vP6pEPedEFqKA
 mirascope/llm/responses/base_response.py,sha256=Se0tf3hIB8Y7cBvAeLJEctA-w-pdLIHOURBn023m51s,4269
 mirascope/llm/responses/base_stream_response.py,sha256=YujpLwk0T0Mi98p7OPlsmuuBKfXyuyEcTpMReQQWB_8,33363
 mirascope/llm/responses/finish_reason.py,sha256=Az5OY6pfZoOPEpzVnl07AqZPz5ZC-w4YKwpUPbFJGdM,798
-mirascope/llm/responses/response.py,sha256=sFwHQ8sko-jpJ8L6tRMOgXPHMY7sJ0ww2QcpISUUPFY,12357
+mirascope/llm/responses/response.py,sha256=0EVH8FSMnH_4xPzJR18BUJxsY24d2QMLKOdi6HDkslY,20878
 mirascope/llm/responses/root_response.py,sha256=LXAMDgI29UF8VYv0a76IfZkiQnebpTPFDkgJR8zFdZo,9246
-mirascope/llm/responses/stream_response.py,sha256=CX9wLZ_80BKJ6M-Ukku4aSbtC5lRgE9evFsxk7-8y54,23933
+mirascope/llm/responses/stream_response.py,sha256=JRewzc3AzdoEBuc6Er3IhiAesEZJG8X7tDTkKWalBfo,33086
 mirascope/llm/responses/streams.py,sha256=TmEFvLVEWHfVYplik61yUWisxe8JGbaZdh7yC7e-axI,10789
 mirascope/llm/responses/usage.py,sha256=OvPhe9TpSnxNu2fhH2nCTPDrNTZFtT2_MEhpzVLmw_s,4376
+mirascope/llm/retries/__init__.py,sha256=AT7y9az-OYGPhz2aJUggaRC2uy_ETXRrQqGXiiBDl-Y,1415
+mirascope/llm/retries/retry_calls.py,sha256=XMvozSh0W8dZh6QFT_DCNNznEcUYZcZdrTAyKnB2JoQ,5492
+mirascope/llm/retries/retry_config.py,sha256=ppKeMyCLVVqAt49WsF7H4CieKPxm7tTZb3uBWM0_6HU,6349
+mirascope/llm/retries/retry_decorator.py,sha256=fJicq_I2g1-5BhbhD9_8joCJsrR5LFhRtQXPv2idTzM,7634
+mirascope/llm/retries/retry_models.py,sha256=_lC3YsiPrvynpFbUVyRBte8yn05CDsvt6fkvQyacKnE,43763
+mirascope/llm/retries/retry_prompts.py,sha256=E1ldVxJp3u1A7qpWO6vb2aTdHm0R3bV3DWlYDQq8fWI,7394
+mirascope/llm/retries/retry_responses.py,sha256=NeTz4q3fIE2Mttk8pBxnvk9ok_fpMNtLgvCJETCXzrE,12561
+mirascope/llm/retries/retry_stream_responses.py,sha256=DhPlbIlzdnLy9JaMCaiEKWiqx0K4TgOGovQnr_ffIZ4,21885
+mirascope/llm/retries/utils.py,sha256=ravA7Ex_Lb_PoE5Hwej8QWCiBG0DyVeczcWYOWdiQbo,5168
 mirascope/llm/tools/__init__.py,sha256=4Rrnl0GBdZrw3KqACLoDLWqDer32DuU6VKJmN4sjzRo,1515
 mirascope/llm/tools/_utils.py,sha256=mUi6vUEwYuwu8W9FCQcQ_9h_VE_U-Y3Y2UQ2YptPZL4,1171
 mirascope/llm/tools/decorator.py,sha256=2ZTvYH0jrft0E3BdQ2BB9Okyb72JOIqQvBkLWmWuo7w,5663
@@ -404,8 +413,8 @@ mirascope/ops/_internal/traced_functions.py,sha256=lPN8c-lzHY-BxhhbcDpKC7JQtvgnm
 mirascope/ops/_internal/tracing.py,sha256=RzHBc-yEbj3Z_Kjobh26FWDSnF6AGbRCsb0JXBSzPdc,10244
 mirascope/ops/_internal/types.py,sha256=5B1RgChTEbGkLZvdoX8XA2vMKn4bS8BczjGDElxmugI,412
 mirascope/ops/_internal/utils.py,sha256=uGGKuAToxUUlkiqcmZIAICCAtmQay_fQ_ciVWF6jcIQ,4907
-mirascope/ops/_internal/versioned_calls.py,sha256=7oePDEuf98ph6yrHKJmXSagc1mGz5sdTTJgQnB2CyHM,18445
-mirascope/ops/_internal/versioned_functions.py,sha256=g_m-szx6NiBmwxakygNDnJTOyOQN-cVEgsUZZXLFh0w,13528
+mirascope/ops/_internal/versioned_calls.py,sha256=4l5S3oiDEL7sH8qatbS4no-FxOgBCGzXp9LVXics9uc,25759
+mirascope/ops/_internal/versioned_functions.py,sha256=__lnbjJEjkrU_0mAqUZXeFzqfWmeYlSDrb5xIwLKG9o,13598
 mirascope/ops/_internal/versioning.py,sha256=MxiezWrGUPiLZxZnwwXDFTR7EMrfTHR7rmd14TuDCL8,8286
 mirascope/ops/_internal/exporters/__init__.py,sha256=3PUd75TczW_8bUImcWgddWyoRmygGf6T_jL7Jo3t_sY,608
 mirascope/ops/_internal/exporters/exporters.py,sha256=9RUKKgtKCxrhh-9H0eaYdG_LApmirmvRZjNIlhr3tGA,14043
@@ -431,7 +440,7 @@ mirascope/ops/_internal/instrumentation/providers/anthropic.py,sha256=P3NgIKg9zt
 mirascope/ops/_internal/instrumentation/providers/base.py,sha256=7jl37MhcDCfWMWkkUqgdqATv0OQIggk8t9JSlCOlNFo,6072
 mirascope/ops/_internal/instrumentation/providers/google_genai.py,sha256=1QtxjyCrM5vjXEW0TVdpzdYJuHB8YKsqY8EQEWnIn3o,2948
 mirascope/ops/_internal/instrumentation/providers/openai.py,sha256=mVXebcl8bwRvFfOVXfiX4uxo5X_uqIOXgttkifIGCZg,2638
-mirascope-2.1.1.dist-info/METADATA,sha256=OL-o1nh_DIYVQsSNFkWFKyImdZ9NF_JZxjj1CXkgroY,9719
-mirascope-2.1.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-mirascope-2.1.1.dist-info/licenses/LICENSE,sha256=MxD-HQ4YHSi2YqZ3UH2MsjclZbesds6j5it4O2IWyJs,1072
-mirascope-2.1.1.dist-info/RECORD,,
+mirascope-2.2.0.dist-info/METADATA,sha256=nUt1SVcAx9DNeTaMEcAnAUjcb2Kwq1iSDssGFAU6NGk,9719
+mirascope-2.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mirascope-2.2.0.dist-info/licenses/LICENSE,sha256=MxD-HQ4YHSi2YqZ3UH2MsjclZbesds6j5it4O2IWyJs,1072
+mirascope-2.2.0.dist-info/RECORD,,