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

mirascope/api/_generated/types/__init__.py

@@ -2,20 +2,36 @@
 
 # isort: skip_file
 
+from .already_exists_error import AlreadyExistsError
+from .already_exists_error_tag import AlreadyExistsErrorTag
+from .database_error import DatabaseError
+from .database_error_tag import DatabaseErrorTag
 from .http_api_decode_error import HttpApiDecodeError
 from .http_api_decode_error_tag import HttpApiDecodeErrorTag
 from .issue import Issue
 from .issue_tag import IssueTag
+from .not_found_error_body import NotFoundErrorBody
+from .not_found_error_tag import NotFoundErrorTag
+from .permission_denied_error import PermissionDeniedError
+from .permission_denied_error_tag import PermissionDeniedErrorTag
 from .property_key import PropertyKey
-from .property_key_tag import PropertyKeyTag
-from .property_key_tag_tag import PropertyKeyTagTag
+from .property_key_key import PropertyKeyKey
+from .property_key_key_tag import PropertyKeyKeyTag
 
 __all__ = [
+    "AlreadyExistsError",
+    "AlreadyExistsErrorTag",
+    "DatabaseError",
+    "DatabaseErrorTag",
     "HttpApiDecodeError",
     "HttpApiDecodeErrorTag",
     "Issue",
     "IssueTag",
+    "NotFoundErrorBody",
+    "NotFoundErrorTag",
+    "PermissionDeniedError",
+    "PermissionDeniedErrorTag",
     "PropertyKey",
-    "PropertyKeyTag",
-    "PropertyKeyTagTag",
+    "PropertyKeyKey",
+    "PropertyKeyKeyTag",
 ]

mirascope/api/_generated/types/already_exists_error.py

@@ -0,0 +1,24 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .already_exists_error_tag import AlreadyExistsErrorTag
+
+
+class AlreadyExistsError(UniversalBaseModel):
+    message: str
+    resource: typing.Optional[str] = None
+    tag: AlreadyExistsErrorTag
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(
+            extra="allow", frozen=True
+        )  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

mirascope/api/_generated/types/already_exists_error_tag.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+AlreadyExistsErrorTag = typing.Union[typing.Literal["AlreadyExistsError"], typing.Any]

mirascope/api/_generated/types/database_error.py

@@ -0,0 +1,24 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .database_error_tag import DatabaseErrorTag
+
+
+class DatabaseError(UniversalBaseModel):
+    message: str
+    cause: typing.Optional[typing.Optional[typing.Any]] = None
+    tag: DatabaseErrorTag
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(
+            extra="allow", frozen=True
+        )  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

mirascope/api/_generated/types/database_error_tag.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+DatabaseErrorTag = typing.Union[typing.Literal["DatabaseError"], typing.Any]

mirascope/api/_generated/types/http_api_decode_error.py

@@ -3,9 +3,7 @@
 import typing
 
 import pydantic
-import typing_extensions
 from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
-from ..core.serialization import FieldMetadata
 from .http_api_decode_error_tag import HttpApiDecodeErrorTag
 from .issue import Issue
 
@@ -17,7 +15,7 @@ class HttpApiDecodeError(UniversalBaseModel):
 
     issues: typing.List[Issue]
     message: str
-    tag: typing_extensions.Annotated[HttpApiDecodeErrorTag, FieldMetadata(alias="_tag")]
+    tag: HttpApiDecodeErrorTag
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(

mirascope/api/_generated/types/issue.py

@@ -3,9 +3,7 @@
 import typing
 
 import pydantic
-import typing_extensions
 from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
-from ..core.serialization import FieldMetadata
 from .issue_tag import IssueTag
 from .property_key import PropertyKey
 
@@ -15,9 +13,7 @@ class Issue(UniversalBaseModel):
     Represents an error encountered while parsing a value to match the schema
     """
 
-    tag: typing_extensions.Annotated[IssueTag, FieldMetadata(alias="_tag")] = (
-        pydantic.Field()
-    )
+    tag: IssueTag = pydantic.Field()
     """
     The tag identifying the type of parse issue
     """

mirascope/api/_generated/types/not_found_error_body.py

@@ -0,0 +1,24 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .not_found_error_tag import NotFoundErrorTag
+
+
+class NotFoundErrorBody(UniversalBaseModel):
+    message: str
+    resource: typing.Optional[str] = None
+    tag: NotFoundErrorTag
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(
+            extra="allow", frozen=True
+        )  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

mirascope/api/_generated/types/not_found_error_tag.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+NotFoundErrorTag = typing.Union[typing.Literal["NotFoundError"], typing.Any]

mirascope/api/_generated/types/permission_denied_error.py

@@ -0,0 +1,24 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .permission_denied_error_tag import PermissionDeniedErrorTag
+
+
+class PermissionDeniedError(UniversalBaseModel):
+    message: str
+    resource: typing.Optional[str] = None
+    tag: PermissionDeniedErrorTag
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(
+            extra="allow", frozen=True
+        )  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

mirascope/api/_generated/types/permission_denied_error_tag.py

@@ -0,0 +1,7 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+PermissionDeniedErrorTag = typing.Union[
+    typing.Literal["PermissionDeniedError"], typing.Any
+]

mirascope/api/_generated/types/property_key.py

@@ -2,6 +2,6 @@
 
 import typing
 
-from .property_key_tag import PropertyKeyTag
+from .property_key_key import PropertyKeyKey
 
-PropertyKey = typing.Union[str, float, PropertyKeyTag]
+PropertyKey = typing.Union[str, float, PropertyKeyKey]

mirascope/api/_generated/types/{property_key_tag.py → property_key_key.py}

@@ -3,18 +3,16 @@
 import typing
 
 import pydantic
-import typing_extensions
 from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
-from ..core.serialization import FieldMetadata
-from .property_key_tag_tag import PropertyKeyTagTag
+from .property_key_key_tag import PropertyKeyKeyTag
 
 
-class PropertyKeyTag(UniversalBaseModel):
+class PropertyKeyKey(UniversalBaseModel):
     """
     an object to be decoded into a globally shared symbol
     """
 
-    tag: typing_extensions.Annotated[PropertyKeyTagTag, FieldMetadata(alias="_tag")]
+    tag: PropertyKeyKeyTag
     key: str
 
     if IS_PYDANTIC_V2:

mirascope/api/_generated/types/{property_key_tag_tag.py → property_key_key_tag.py}

@@ -2,4 +2,4 @@
 
 import typing
 
-PropertyKeyTagTag = typing.Union[typing.Literal["symbol"], typing.Any]
+PropertyKeyKeyTag = typing.Union[typing.Literal["symbol"], typing.Any]

mirascope/llm/__init__.py

@@ -117,6 +117,8 @@ from .responses import (
     TextStream,
     ThoughtStream,
     ToolCallStream,
+    Usage,
+    UsageDeltaChunk,
 )
 from .tools import (
     AsyncContextTool,
@@ -219,6 +221,8 @@ __all__ = [
     "ToolOutput",
     "Toolkit",
     "URLImageSource",
+    "Usage",
+    "UsageDeltaChunk",
     "UserContent",
     "UserContentPart",
     "UserMessage",

mirascope/llm/providers/__init__.py

@@ -9,28 +9,34 @@ from .google import GoogleModelId, GoogleProvider
 from .load_provider import load, load_provider
 from .mlx import MLXModelId, MLXProvider
 from .model_id import ModelId
+from .ollama import OllamaProvider
 from .openai import (
     OpenAIModelId,
     OpenAIProvider,
 )
+from .openai.completions import BaseOpenAICompletionsProvider
 from .provider_id import KNOWN_PROVIDER_IDS, ProviderId
 from .provider_registry import get_provider_for_model, register_provider
+from .together import TogetherProvider
 
 __all__ = [
     "KNOWN_PROVIDER_IDS",
     "AnthropicModelId",
     "AnthropicProvider",
+    "BaseOpenAICompletionsProvider",
     "BaseProvider",
     "GoogleModelId",
     "GoogleProvider",
     "MLXModelId",
     "MLXProvider",
     "ModelId",
+    "OllamaProvider",
     "OpenAIModelId",
     "OpenAIProvider",
     "Params",
     "Provider",
     "ProviderId",
+    "TogetherProvider",
     "get_provider_for_model",
     "load",
     "load_provider",

mirascope/llm/providers/anthropic/__init__.py

@@ -3,22 +3,27 @@
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from .beta_provider import AnthropicBetaProvider
     from .model_id import AnthropicModelId
     from .provider import AnthropicProvider
 else:
     try:
+        from .beta_provider import AnthropicBetaProvider
         from .model_id import AnthropicModelId
         from .provider import AnthropicProvider
     except ImportError:  # pragma: no cover
         from .._missing_import_stubs import (
-            create_import_error_stub,
             create_provider_stub,
         )
 
+        AnthropicBetaProvider = create_provider_stub(
+            "anthropic", "AnthropicBetaProvider"
+        )
         AnthropicProvider = create_provider_stub("anthropic", "AnthropicProvider")
         AnthropicModelId = str
 
 __all__ = [
+    "AnthropicBetaProvider",
     "AnthropicModelId",
     "AnthropicProvider",
 ]

mirascope/llm/providers/anthropic/_utils/__init__.py

@@ -1,13 +1,23 @@
-from .decode import (
-    decode_async_stream,
-    decode_response,
-    decode_stream,
+"""Shared Anthropic utilities."""
+
+from .decode import decode_async_stream, decode_response, decode_stream
+from .encode import (
+    DEFAULT_FORMAT_MODE,
+    DEFAULT_MAX_TOKENS,
+    AnthropicImageMimeType,
+    encode_image_mime_type,
+    encode_request,
+    process_params,
 )
-from .encode import encode_request
 
 __all__ = [
+    "DEFAULT_FORMAT_MODE",
+    "DEFAULT_MAX_TOKENS",
+    "AnthropicImageMimeType",
     "decode_async_stream",
     "decode_response",
     "decode_stream",
+    "encode_image_mime_type",
     "encode_request",
+    "process_params",
 ]

mirascope/llm/providers/anthropic/_utils/beta_decode.py

@@ -0,0 +1,271 @@
+"""Beta Anthropic response decoding."""
+
+import json
+from typing import Any, TypeAlias, cast
+
+from anthropic.lib.streaming._beta_messages import (
+    BetaAsyncMessageStreamManager,
+    BetaMessageStreamManager,
+)
+from anthropic.types.beta import (
+    BetaContentBlock,
+    BetaRawMessageStreamEvent,
+    BetaRedactedThinkingBlockParam,
+    BetaTextBlockParam,
+    BetaThinkingBlockParam,
+    BetaToolUseBlockParam,
+)
+from anthropic.types.beta.parsed_beta_message import ParsedBetaMessage
+
+from ....content import (
+    AssistantContentPart,
+    Text,
+    TextChunk,
+    TextEndChunk,
+    TextStartChunk,
+    Thought,
+    ThoughtChunk,
+    ThoughtEndChunk,
+    ThoughtStartChunk,
+    ToolCall,
+    ToolCallChunk,
+    ToolCallEndChunk,
+    ToolCallStartChunk,
+)
+from ....messages import AssistantMessage
+from ....responses import (
+    AsyncChunkIterator,
+    ChunkIterator,
+    FinishReason,
+    FinishReasonChunk,
+    RawMessageChunk,
+    RawStreamEventChunk,
+    Usage,
+    UsageDeltaChunk,
+)
+from ..model_id import model_name
+from .decode import decode_usage
+
+BETA_FINISH_REASON_MAP = {
+    "max_tokens": FinishReason.MAX_TOKENS,
+    "refusal": FinishReason.REFUSAL,
+    "model_context_window_exceeded": FinishReason.CONTEXT_LENGTH_EXCEEDED,
+}
+
+
+def _decode_beta_assistant_content(content: BetaContentBlock) -> AssistantContentPart:
+    """Convert Beta content block to mirascope AssistantContentPart."""
+    if content.type == "text":
+        return Text(text=content.text)
+    elif content.type == "tool_use":
+        return ToolCall(
+            id=content.id,
+            name=content.name,
+            args=json.dumps(content.input),
+        )
+    elif content.type == "thinking":
+        return Thought(thought=content.thinking)
+    else:
+        raise NotImplementedError(
+            f"Support for beta content type `{content.type}` is not yet implemented."
+        )
+
+
+def beta_decode_response(
+    response: ParsedBetaMessage[Any],
+    model_id: str,
+) -> tuple[AssistantMessage, FinishReason | None, Usage]:
+    """Convert Beta message to mirascope AssistantMessage and usage."""
+    assistant_message = AssistantMessage(
+        content=[_decode_beta_assistant_content(part) for part in response.content],
+        provider_id="anthropic",
+        model_id=model_id,
+        provider_model_name=model_name(model_id),
+        raw_message={
+            "role": response.role,
+            "content": [
+                part.model_dump(exclude_none=True) for part in response.content
+            ],
+        },
+    )
+    finish_reason = (
+        BETA_FINISH_REASON_MAP.get(response.stop_reason)
+        if response.stop_reason
+        else None
+    )
+    usage = decode_usage(response.usage)
+    return assistant_message, finish_reason, usage
+
+
+BetaContentBlockParam: TypeAlias = (
+    BetaTextBlockParam
+    | BetaThinkingBlockParam
+    | BetaToolUseBlockParam
+    | BetaRedactedThinkingBlockParam
+)
+
+
+class _BetaChunkProcessor:
+    """Processes Beta stream events and maintains state across events."""
+
+    def __init__(self) -> None:
+        self.current_block_param: BetaContentBlockParam | None = None
+        self.accumulated_tool_json: str = ""
+        self.accumulated_blocks: list[BetaContentBlockParam] = []
+
+    def process_event(self, event: BetaRawMessageStreamEvent) -> ChunkIterator:
+        """Process a single Beta event and yield the appropriate content chunks."""
+        yield RawStreamEventChunk(raw_stream_event=event)
+
+        if event.type == "content_block_start":
+            content_block = event.content_block
+
+            if content_block.type == "text":
+                self.current_block_param = {
+                    "type": "text",
+                    "text": content_block.text,
+                }
+                yield TextStartChunk()
+            elif content_block.type == "tool_use":
+                self.current_block_param = {
+                    "type": "tool_use",
+                    "id": content_block.id,
+                    "name": content_block.name,
+                    "input": {},
+                }
+                self.accumulated_tool_json = ""
+                yield ToolCallStartChunk(
+                    id=content_block.id,
+                    name=content_block.name,
+                )
+            elif content_block.type == "thinking":
+                self.current_block_param = {
+                    "type": "thinking",
+                    "thinking": "",
+                    "signature": "",
+                }
+                yield ThoughtStartChunk()
+            elif content_block.type == "redacted_thinking":  # pragma: no cover
+                self.current_block_param = {
+                    "type": "redacted_thinking",
+                    "data": content_block.data,
+                }
+            else:
+                raise NotImplementedError(
+                    f"Support for beta content block type `{content_block.type}` "
+                    "is not yet implemented."
+                )
+
+        elif event.type == "content_block_delta":
+            if self.current_block_param is None:  # pragma: no cover
+                raise RuntimeError("Received delta without a current block")
+
+            delta = event.delta
+            if delta.type == "text_delta":
+                if self.current_block_param["type"] != "text":  # pragma: no cover
+                    raise RuntimeError(
+                        f"Received text_delta for {self.current_block_param['type']} block"
+                    )
+                self.current_block_param["text"] += delta.text
+                yield TextChunk(delta=delta.text)
+            elif delta.type == "input_json_delta":
+                if self.current_block_param["type"] != "tool_use":  # pragma: no cover
+                    raise RuntimeError(
+                        f"Received input_json_delta for {self.current_block_param['type']} block"
+                    )
+                self.accumulated_tool_json += delta.partial_json
+                yield ToolCallChunk(delta=delta.partial_json)
+            elif delta.type == "thinking_delta":
+                if self.current_block_param["type"] != "thinking":  # pragma: no cover
+                    raise RuntimeError(
+                        f"Received thinking_delta for {self.current_block_param['type']} block"
+                    )
+                self.current_block_param["thinking"] += delta.thinking
+                yield ThoughtChunk(delta=delta.thinking)
+            elif delta.type == "signature_delta":
+                if self.current_block_param["type"] != "thinking":  # pragma: no cover
+                    raise RuntimeError(
+                        f"Received signature_delta for {self.current_block_param['type']} block"
+                    )
+                self.current_block_param["signature"] += delta.signature
+            else:
+                raise RuntimeError(
+                    f"Received unsupported delta type: {delta.type}"
+                )  # pragma: no cover
+
+        elif event.type == "content_block_stop":
+            if self.current_block_param is None:  # pragma: no cover
+                raise RuntimeError("Received stop without a current block")
+
+            block_type = self.current_block_param["type"]
+
+            if block_type == "text":
+                yield TextEndChunk()
+            elif block_type == "tool_use":
+                if self.current_block_param["type"] != "tool_use":  # pragma: no cover
+                    raise RuntimeError(
+                        f"Block type mismatch: stored {self.current_block_param['type']}, expected tool_use"
+                    )
+                self.current_block_param["input"] = (
+                    json.loads(self.accumulated_tool_json)
+                    if self.accumulated_tool_json
+                    else {}
+                )
+                yield ToolCallEndChunk()
+            elif block_type == "thinking":
+                yield ThoughtEndChunk()
+            else:
+                raise NotImplementedError
+
+            self.accumulated_blocks.append(self.current_block_param)
+            self.current_block_param = None
+
+        elif event.type == "message_delta":
+            if event.delta.stop_reason:
+                finish_reason = BETA_FINISH_REASON_MAP.get(event.delta.stop_reason)
+                if finish_reason is not None:
+                    yield FinishReasonChunk(finish_reason=finish_reason)
+
+            # Emit usage delta
+            usage = event.usage
+            yield UsageDeltaChunk(
+                input_tokens=usage.input_tokens or 0,
+                output_tokens=usage.output_tokens,
+                cache_read_tokens=usage.cache_read_input_tokens or 0,
+                cache_write_tokens=usage.cache_creation_input_tokens or 0,
+                reasoning_tokens=0,
+            )
+
+    def raw_message_chunk(self) -> RawMessageChunk:
+        return RawMessageChunk(
+            raw_message=cast(
+                dict[str, Any],
+                {
+                    "role": "assistant",
+                    "content": self.accumulated_blocks,
+                },
+            )
+        )
+
+
+def beta_decode_stream(
+    beta_stream_manager: BetaMessageStreamManager[Any],
+) -> ChunkIterator:
+    """Returns a ChunkIterator converted from a Beta MessageStreamManager."""
+    processor = _BetaChunkProcessor()
+    with beta_stream_manager as stream:
+        for event in stream._raw_stream:  # pyright: ignore[reportPrivateUsage]
+            yield from processor.process_event(event)
+    yield processor.raw_message_chunk()
+
+
+async def beta_decode_async_stream(
+    beta_stream_manager: BetaAsyncMessageStreamManager[Any],
+) -> AsyncChunkIterator:
+    """Returns an AsyncChunkIterator converted from a Beta MessageStreamManager."""
+    processor = _BetaChunkProcessor()
+    async with beta_stream_manager as stream:
+        async for event in stream._raw_stream:  # pyright: ignore[reportPrivateUsage]
+            for item in processor.process_event(event):
+                yield item
+    yield processor.raw_message_chunk()