mirascope 2.0.0a3__py3-none-any.whl → 2.0.0a4__py3-none-any.whl

mirascope/llm/providers/openai/responses/_utils/encode.py

@@ -40,8 +40,11 @@ from .....messages import AssistantMessage, Message, UserMessage
 from .....tools import FORMAT_TOOL_NAME, AnyToolSchema, BaseToolkit
 from ....base import Params, _utils as _base_utils
 from ...model_id import OpenAIModelId, model_name
-from ...model_info import NON_REASONING_MODELS
-from ...shared import _utils as _shared_utils
+from ...model_info import (
+    MODELS_WITHOUT_JSON_OBJECT_SUPPORT,
+    MODELS_WITHOUT_JSON_SCHEMA_SUPPORT,
+    NON_REASONING_MODELS,
+)
 
 
 class ResponseCreateKwargs(TypedDict, total=False):
@@ -197,7 +200,7 @@ def _convert_tool_to_function_tool_param(tool: AnyToolSchema) -> FunctionToolPar
     """Convert a Mirascope ToolSchema to OpenAI Responses FunctionToolParam."""
     schema_dict = tool.parameters.model_dump(by_alias=True, exclude_none=True)
     schema_dict["type"] = "object"
-    _shared_utils.ensure_additional_properties_false(schema_dict)
+    _base_utils.ensure_additional_properties_false(schema_dict)
 
     return FunctionToolParam(
         type="function",
@@ -220,7 +223,7 @@ def _create_strict_response_format(
         ResponseFormatTextJSONSchemaConfigParam for strict structured outputs
     """
     schema = format.schema.copy()
-    _shared_utils.ensure_additional_properties_false(schema)
+    _base_utils.ensure_additional_properties_false(schema)
 
     response_format: ResponseFormatTextJSONSchemaConfigParam = {
         "type": "json_schema",
@@ -294,9 +297,7 @@ def encode_request(
     tools = tools.tools if isinstance(tools, BaseToolkit) else tools or []
     openai_tools = [_convert_tool_to_function_tool_param(tool) for tool in tools]
 
-    model_supports_strict = (
-        model_id not in _shared_utils.MODELS_WITHOUT_JSON_SCHEMA_SUPPORT
-    )
+    model_supports_strict = model_id not in MODELS_WITHOUT_JSON_SCHEMA_SUPPORT
     default_mode = "strict" if model_supports_strict else "tool"
 
     format = resolve_format(format, default_mode=default_mode)
@@ -323,8 +324,7 @@ def encode_request(
                     name=FORMAT_TOOL_NAME,
                 )
         elif (
-            format.mode == "json"
-            and model_id not in _shared_utils.MODELS_WITHOUT_JSON_OBJECT_SUPPORT
+            format.mode == "json" and model_id not in MODELS_WITHOUT_JSON_OBJECT_SUPPORT
         ):
             kwargs["text"] = {"format": ResponseFormatJSONObject(type="json_object")}
 

mirascope/llm/providers/openai/responses/provider.py

@@ -1,7 +1,6 @@
 """OpenAI Responses API client implementation."""
 
 from collections.abc import Sequence
-from typing import Literal
 from typing_extensions import Unpack
 
 from openai import AsyncOpenAI, OpenAI
@@ -45,14 +44,10 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         *,
         api_key: str | None = None,
         base_url: str | None = None,
-        wrapped_by_openai_provider: bool = False,
     ) -> None:
         """Initialize the OpenAI Responses client."""
         self.client = OpenAI(api_key=api_key, base_url=base_url)
         self.async_client = AsyncOpenAI(api_key=api_key, base_url=base_url)
-        self.active_provider_id: Literal["openai", "openai:responses"] = (
-            "openai" if wrapped_by_openai_provider else "openai:responses"
-        )
 
     def _call(
         self,
@@ -85,14 +80,14 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
 
         openai_response = self.client.responses.create(**kwargs)
 
-        assistant_message, finish_reason = _utils.decode_response(
-            openai_response, model_id, self.active_provider_id
+        assistant_message, finish_reason, usage = _utils.decode_response(
+            openai_response, model_id, self.id
         )
         provider_model_name = model_name(model_id, "responses")
 
         return Response(
             raw=openai_response,
-            provider_id=self.active_provider_id,
+            provider_id=self.id,
             model_id=model_id,
             provider_model_name=provider_model_name,
             params=params,
@@ -100,6 +95,7 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             input_messages=messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
+            usage=usage,
             format=format,
         )
 
@@ -134,14 +130,14 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
 
         openai_response = await self.async_client.responses.create(**kwargs)
 
-        assistant_message, finish_reason = _utils.decode_response(
-            openai_response, model_id, self.active_provider_id
+        assistant_message, finish_reason, usage = _utils.decode_response(
+            openai_response, model_id, self.id
         )
         provider_model_name = model_name(model_id, "responses")
 
         return AsyncResponse(
             raw=openai_response,
-            provider_id=self.active_provider_id,
+            provider_id=self.id,
             model_id=model_id,
             provider_model_name=provider_model_name,
             params=params,
@@ -149,6 +145,7 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             input_messages=messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
+            usage=usage,
             format=format,
         )
 
@@ -192,7 +189,7 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         provider_model_name = model_name(model_id, "responses")
 
         return StreamResponse(
-            provider_id=self.active_provider_id,
+            provider_id=self.id,
             model_id=model_id,
             provider_model_name=provider_model_name,
             params=params,
@@ -242,7 +239,7 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         provider_model_name = model_name(model_id, "responses")
 
         return AsyncStreamResponse(
-            provider_id=self.active_provider_id,
+            provider_id=self.id,
             model_id=model_id,
             provider_model_name=provider_model_name,
             params=params,
@@ -287,14 +284,14 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
 
         openai_response = self.client.responses.create(**kwargs)
 
-        assistant_message, finish_reason = _utils.decode_response(
-            openai_response, model_id, self.active_provider_id
+        assistant_message, finish_reason, usage = _utils.decode_response(
+            openai_response, model_id, self.id
         )
         provider_model_name = model_name(model_id, "responses")
 
         return ContextResponse(
             raw=openai_response,
-            provider_id=self.active_provider_id,
+            provider_id=self.id,
             model_id=model_id,
             provider_model_name=provider_model_name,
             params=params,
@@ -302,6 +299,7 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             input_messages=messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
+            usage=usage,
             format=format,
         )
 
@@ -340,14 +338,14 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
 
         openai_response = await self.async_client.responses.create(**kwargs)
 
-        assistant_message, finish_reason = _utils.decode_response(
-            openai_response, model_id, self.active_provider_id
+        assistant_message, finish_reason, usage = _utils.decode_response(
+            openai_response, model_id, self.id
         )
         provider_model_name = model_name(model_id, "responses")
 
         return AsyncContextResponse(
             raw=openai_response,
-            provider_id=self.active_provider_id,
+            provider_id=self.id,
             model_id=model_id,
             provider_model_name=provider_model_name,
             params=params,
@@ -355,6 +353,7 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             input_messages=messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
+            usage=usage,
             format=format,
         )
 
@@ -402,7 +401,7 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         provider_model_name = model_name(model_id, "responses")
 
         return ContextStreamResponse(
-            provider_id=self.active_provider_id,
+            provider_id=self.id,
             model_id=model_id,
             provider_model_name=provider_model_name,
             params=params,
@@ -459,7 +458,7 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         provider_model_name = model_name(model_id, "responses")
 
         return AsyncContextStreamResponse(
-            provider_id=self.active_provider_id,
+            provider_id=self.id,
             model_id=model_id,
             provider_model_name=provider_model_name,
             params=params,

mirascope/llm/providers/provider_id.py

@@ -4,10 +4,20 @@ from typing import Literal, TypeAlias, get_args
 
 KnownProviderId: TypeAlias = Literal[
     "anthropic",  # Anthropic provider via AnthropicProvider
+    "anthropic-beta",  # Anthropic beta provider via AnthropicBetaProvider
     "google",  # Google provider via GoogleProvider
-    "openai",  # OpenAI provider via OpenAIProvider
     "mlx",  # Local inference powered by `mlx-lm`, via MLXProvider
+    "ollama",  # Ollama provider via OllamaProvider
+    "openai",  # OpenAI provider via OpenAIProvider (prefers Responses routing when available)
+    "together",  # Together AI provider via TogetherProvider
 ]
 KNOWN_PROVIDER_IDS = get_args(KnownProviderId)
 
 ProviderId = KnownProviderId | str
+
+OpenAICompletionsCompatibleProviderId: TypeAlias = Literal[
+    "ollama",  # Ollama (OpenAI-compatible)
+    "openai",  # OpenAI via OpenAIProvider (routes to completions)
+    "openai:completions",  # OpenAI Completions API directly
+    "together",  # Together AI (OpenAI-compatible)
+]

mirascope/llm/providers/provider_registry.py

@@ -16,8 +16,10 @@ PROVIDER_REGISTRY: dict[str, Provider] = {}
 DEFAULT_AUTO_REGISTER_SCOPES: dict[str, ProviderId] = {
     "anthropic/": "anthropic",
     "google/": "google",
-    "openai/": "openai",
     "mlx-community/": "mlx",
+    "ollama/": "ollama",
+    "openai/": "openai",
+    "together/": "together",
 }
 
 

mirascope/llm/providers/together/__init__.py

@@ -0,0 +1,19 @@
+"""Together AI provider implementation."""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .provider import TogetherProvider
+else:
+    try:
+        from .provider import TogetherProvider
+    except ImportError:  # pragma: no cover
+        from .._missing_import_stubs import (
+            create_provider_stub,
+        )
+
+        TogetherProvider = create_provider_stub("openai", "TogetherProvider")
+
+__all__ = [
+    "TogetherProvider",
+]

mirascope/llm/providers/together/provider.py

@@ -0,0 +1,40 @@
+"""Together AI provider implementation."""
+
+from typing import ClassVar
+
+from ..openai.completions.base_provider import BaseOpenAICompletionsProvider
+
+
+class TogetherProvider(BaseOpenAICompletionsProvider):
+    """Provider for Together AI's OpenAI-compatible API.
+
+    Inherits from BaseOpenAICompletionsProvider with Together-specific configuration:
+    - Uses Together AI's API endpoint
+    - Requires TOGETHER_API_KEY
+
+    Usage:
+        Register the provider with model ID prefixes you want to use:
+
+        ```python
+        import llm
+
+        # Register for meta-llama models
+        llm.register_provider("together", "meta-llama/")
+
+        # Now you can use meta-llama models directly
+        @llm.call("meta-llama/Llama-3.3-70B-Instruct-Turbo")
+        def my_prompt():
+            return [llm.messages.user("Hello!")]
+        ```
+    """
+
+    id: ClassVar[str] = "together"
+    default_scope: ClassVar[str | list[str]] = []
+    default_base_url: ClassVar[str | None] = "https://api.together.xyz/v1"
+    api_key_env_var: ClassVar[str] = "TOGETHER_API_KEY"
+    api_key_required: ClassVar[bool] = True
+    provider_name: ClassVar[str | None] = "Together"
+
+    def _model_name(self, model_id: str) -> str:
+        """Return the model ID as-is for Together API."""
+        return model_id

mirascope/llm/responses/__init__.py

@@ -27,6 +27,7 @@ from .streams import (
     ThoughtStream,
     ToolCallStream,
 )
+from .usage import Usage, UsageDeltaChunk
 
 __all__ = [
     "AsyncChunkIterator",
@@ -53,5 +54,7 @@ __all__ = [
     "TextStream",
     "ThoughtStream",
     "ToolCallStream",
+    "Usage",
+    "UsageDeltaChunk",
     "_utils",
 ]

mirascope/llm/responses/base_response.py

@@ -9,6 +9,7 @@ from ..messages import AssistantMessage, Message
 from ..tools import FORMAT_TOOL_NAME, ToolkitT
 from .finish_reason import FinishReason
 from .root_response import RootResponse
+from .usage import Usage
 
 if TYPE_CHECKING:
     from ..providers import ModelId, Params, ProviderId
@@ -30,6 +31,7 @@ class BaseResponse(RootResponse[ToolkitT, FormattableT]):
         input_messages: Sequence[Message],
         assistant_message: AssistantMessage,
         finish_reason: FinishReason | None,
+        usage: Usage | None,
     ) -> None:
         """Initialize a Response.
 
@@ -45,6 +47,7 @@ class BaseResponse(RootResponse[ToolkitT, FormattableT]):
             input_messages: The message history before the final assistant message.
             assistant_message: The final assistant message containing the response content.
             finish_reason: The reason why the LLM finished generating a response.
+            usage: Token usage statistics for the response.
         """
         self.raw = raw
         self.provider_id = provider_id
@@ -53,6 +56,7 @@ class BaseResponse(RootResponse[ToolkitT, FormattableT]):
         self.params = params
         self.toolkit = toolkit
         self.finish_reason = finish_reason
+        self.usage = usage
         self.format = format
 
         # Process content in the assistant message, organizing it by type and

mirascope/llm/responses/base_stream_response.py

@@ -36,6 +36,7 @@ from .streams import (
     ThoughtStream,
     ToolCallStream,
 )
+from .usage import Usage, UsageDeltaChunk
 
 if TYPE_CHECKING:
     from ..providers import ModelId, Params, ProviderId
@@ -76,7 +77,11 @@ class RawMessageChunk:
 
 
 StreamResponseChunk: TypeAlias = (
-    AssistantContentChunk | FinishReasonChunk | RawStreamEventChunk | RawMessageChunk
+    AssistantContentChunk
+    | FinishReasonChunk
+    | RawStreamEventChunk
+    | RawMessageChunk
+    | UsageDeltaChunk
 )
 
 ChunkIterator: TypeAlias = Iterator[StreamResponseChunk]
@@ -165,6 +170,7 @@ class BaseStreamResponse(
         format: Format[FormattableT] | None = None,
         input_messages: Sequence[Message],
         chunk_iterator: ChunkIteratorT,
+        usage: Usage | None = None,
     ) -> None:
         """Initialize the BaseStreamResponse.
 
@@ -177,6 +183,7 @@ class BaseStreamResponse(
             toolkit: Toolkit containing all the tools used to generate the response.
             format: The `Format` for the expected structured output format (or None).
             input_messages: The input messages that were sent to the LLM
+            usage: Token usage statistics for the response.
 
         The BaseStreamResponse will process the tuples to build the chunks and raw lists
         as the stream is consumed.
@@ -187,6 +194,7 @@ class BaseStreamResponse(
         self.provider_model_name = provider_model_name
         self.params = params
         self.toolkit = toolkit
+        self.usage = usage
         self.format = format
 
         # Internal-only lists which we mutate (append) during chunk processing
@@ -475,6 +483,14 @@ class BaseSyncStreamResponse(BaseStreamResponse[ChunkIterator, ToolkitT, Formatt
                 self._assistant_message.raw_message = chunk.raw_message
             elif chunk.type == "finish_reason_chunk":
                 self.finish_reason = chunk.finish_reason
+            elif chunk.type == "usage_delta_chunk":
+                if self.usage is None:
+                    self.usage = Usage()
+                self.usage.input_tokens += chunk.input_tokens
+                self.usage.output_tokens += chunk.output_tokens
+                self.usage.cache_read_tokens += chunk.cache_read_tokens
+                self.usage.cache_write_tokens += chunk.cache_write_tokens
+                self.usage.reasoning_tokens += chunk.reasoning_tokens
             else:
                 yield self._handle_chunk(chunk)
 
@@ -648,6 +664,14 @@ class BaseAsyncStreamResponse(
                 self._assistant_message.raw_message = chunk.raw_message
             elif chunk.type == "finish_reason_chunk":
                 self.finish_reason = chunk.finish_reason
+            elif chunk.type == "usage_delta_chunk":
+                if self.usage is None:
+                    self.usage = Usage()
+                self.usage.input_tokens += chunk.input_tokens
+                self.usage.output_tokens += chunk.output_tokens
+                self.usage.cache_read_tokens += chunk.cache_read_tokens
+                self.usage.cache_write_tokens += chunk.cache_write_tokens
+                self.usage.reasoning_tokens += chunk.reasoning_tokens
             else:
                 yield self._handle_chunk(chunk)
 

mirascope/llm/responses/finish_reason.py

@@ -15,6 +15,7 @@ class FinishReason(str, Enum):
 
     MAX_TOKENS = "max_tokens"
     REFUSAL = "refusal"
+    CONTEXT_LENGTH_EXCEEDED = "context_length_exceeded"
 
 
 @dataclass(kw_only=True)

mirascope/llm/responses/response.py

@@ -21,6 +21,7 @@ from ..tools import (
 from ..types import Jsonable
 from .base_response import BaseResponse
 from .finish_reason import FinishReason
+from .usage import Usage
 
 if TYPE_CHECKING:
     from ..providers import ModelId, Params, ProviderId
@@ -42,6 +43,7 @@ class Response(BaseResponse[Toolkit, FormattableT]):
         input_messages: Sequence[Message],
         assistant_message: AssistantMessage,
         finish_reason: FinishReason | None,
+        usage: Usage | None,
     ) -> None:
         """Initialize a `Response`."""
         toolkit = tools if isinstance(tools, Toolkit) else Toolkit(tools=tools)
@@ -56,6 +58,7 @@ class Response(BaseResponse[Toolkit, FormattableT]):
             input_messages=input_messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
+            usage=usage,
         )
 
     def execute_tools(self) -> Sequence[ToolOutput[Jsonable]]:
@@ -113,6 +116,7 @@ class AsyncResponse(BaseResponse[AsyncToolkit, FormattableT]):
         input_messages: Sequence[Message],
         assistant_message: AssistantMessage,
         finish_reason: FinishReason | None,
+        usage: Usage | None,
     ) -> None:
         """Initialize an `AsyncResponse`."""
         toolkit = (
@@ -129,6 +133,7 @@ class AsyncResponse(BaseResponse[AsyncToolkit, FormattableT]):
             input_messages=input_messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
+            usage=usage,
         )
 
     async def execute_tools(self) -> Sequence[ToolOutput[Jsonable]]:
@@ -195,6 +200,7 @@ class ContextResponse(
         input_messages: Sequence[Message],
         assistant_message: AssistantMessage,
         finish_reason: FinishReason | None,
+        usage: Usage | None,
     ) -> None:
         """Initialize a `ContextResponse`."""
         toolkit = (
@@ -211,6 +217,7 @@ class ContextResponse(
             input_messages=input_messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
+            usage=usage,
         )
 
     def execute_tools(self, ctx: Context[DepsT]) -> Sequence[ToolOutput[Jsonable]]:
@@ -283,6 +290,7 @@ class AsyncContextResponse(
         input_messages: Sequence[Message],
         assistant_message: AssistantMessage,
         finish_reason: FinishReason | None,
+        usage: Usage | None,
     ) -> None:
         """Initialize an `AsyncContextResponse`."""
         toolkit = (
@@ -301,6 +309,7 @@ class AsyncContextResponse(
             input_messages=input_messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
+            usage=usage,
         )
 
     async def execute_tools(

mirascope/llm/responses/root_response.py

@@ -11,6 +11,7 @@ from ..messages import Message
 from ..tools import ToolkitT
 from . import _utils
 from .finish_reason import FinishReason
+from .usage import Usage
 
 if TYPE_CHECKING:
     from ..models import Model
@@ -55,12 +56,15 @@ class RootResponse(Generic[ToolkitT, FormattableT], ABC):
     """
     finish_reason: FinishReason | None
     """The reason why the LLM finished generating a response, if set.
-    
+
     `finish_reason` is only set if the response did not finish generating normally,
     e.g. `FinishReason.MAX_TOKENS` if the model ran out of tokens before completing.
     When the response generates normally, `response.finish_reason` will be `None`.
     """
 
+    usage: Usage | None
+    """Token usage statistics for this response, if available."""
+
     format: Format[FormattableT] | None
     """The `Format` describing the structured response format, if available."""
 

mirascope/llm/responses/usage.py

@@ -0,0 +1,95 @@
+"""Provider-agnostic usage statistics for LLM API calls."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Literal
+
+
+@dataclass(kw_only=True)
+class UsageDeltaChunk:
+    """A chunk containing incremental token usage information from a streaming response.
+
+    This represents a delta/increment in usage statistics as they arrive during streaming.
+    Multiple UsageDeltaChunks are accumulated to produce the final Usage object.
+    """
+
+    type: Literal["usage_delta_chunk"] = "usage_delta_chunk"
+
+    input_tokens: int = 0
+    """Delta in input tokens."""
+
+    output_tokens: int = 0
+    """Delta in output tokens."""
+
+    cache_read_tokens: int = 0
+    """Delta in cache read tokens."""
+
+    cache_write_tokens: int = 0
+    """Delta in cache write tokens."""
+
+    reasoning_tokens: int = 0
+    """Delta in reasoning/thinking tokens."""
+
+
+@dataclass(kw_only=True)
+class Usage:
+    """Token usage statistics from an LLM API call.
+
+    This abstraction captures common usage metrics across providers while preserving
+    access to the raw provider-specific usage data.
+    """
+
+    input_tokens: int = 0
+    """The number of input tokens used.
+
+    This includes ALL input tokens, including cache read and write tokens.
+
+    Will be 0 if not reported by the provider.
+    """
+
+    output_tokens: int = 0
+    """The number of output tokens used.
+
+    This includes ALL output tokens, including `reasoning_tokens` that may not be
+    in the user's visible output, or other "hidden" tokens.
+
+    Will be 0 if not reported by the provider.
+    """
+
+    cache_read_tokens: int = 0
+    """The number of tokens read from cache (prompt caching).
+
+    These are input tokens that were read from cache. Cache read tokens are generally
+    much less expensive than regular input tokens.
+
+    Will be 0 if not reported by the provider or if caching was not used.
+    """
+
+    cache_write_tokens: int = 0
+    """The number of tokens written to cache (cache creation).
+
+    These are input tokens that were written to cache, for future reuse and retrieval.
+    Cache write tokens are generally more expensive than uncached input tokens,
+    but may lead to cost savings down the line when they are re-read as cache_read_tokens.
+
+    Will be 0 if not reported by the provider or if caching was not used.
+    """
+
+    reasoning_tokens: int = 0
+    """The number of tokens used for reasoning/thinking.
+
+    Reasoning tokens are a subset of output_tokens that were generated as part of the model's
+    interior reasoning process. They are billed as output tokens, though they are generally
+    not shown to the user.
+
+    Will be 0 if not reported by the provider or if the model does not support reasoning.
+    """
+
+    raw: Any = None
+    """The raw usage object from the provider."""
+
+    @property
+    def total_tokens(self) -> int:
+        """The total number of tokens used (input + output)."""
+        return self.input_tokens + self.output_tokens

{mirascope-2.0.0a3.dist-info → mirascope-2.0.0a4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mirascope
-Version: 2.0.0a3
+Version: 2.0.0a4
 Summary: LLM abstractions that aren't obstructions
 Project-URL: Homepage, https://mirascope.com
 Project-URL: Documentation, https://mirascope.com/docs/mirascope/v2
@@ -51,7 +51,7 @@ Requires-Dist: httpx>=0.27.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: typing-extensions>=4.10.0
 Provides-Extra: all
-Requires-Dist: anthropic<1.0,>=0.72.0; extra == 'all'
+Requires-Dist: anthropic<1.0,>=0.75.0; extra == 'all'
 Requires-Dist: google-genai<2,>=1.48.0; extra == 'all'
 Requires-Dist: libcst>=1.8.6; extra == 'all'
 Requires-Dist: mcp<2,>=1.0.0; extra == 'all'
@@ -70,7 +70,7 @@ Requires-Dist: pillow<11,>=10.4.0; extra == 'all'
 Requires-Dist: proto-plus>=1.24.0; extra == 'all'
 Requires-Dist: pydantic-settings>=2.12.0; extra == 'all'
 Provides-Extra: anthropic
-Requires-Dist: anthropic<1.0,>=0.72.0; extra == 'anthropic'
+Requires-Dist: anthropic<1.0,>=0.75.0; extra == 'anthropic'
 Provides-Extra: api
 Requires-Dist: pydantic-settings>=2.12.0; extra == 'api'
 Provides-Extra: google