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

mirascope/llm/agents/agent.py

@@ -1,97 +0,0 @@
-"""The `Agent` class for LLM agents."""
-
-from abc import ABC
-from collections.abc import Sequence
-from dataclasses import dataclass
-from typing import Generic
-
-from ..context import Context, DepsT
-from ..formatting import FormattableT
-from ..messages import UserContent
-from ..models import Model
-from ..responses import AsyncResponse, AsyncStreamResponse, Response, StreamResponse
-from ..tools import AsyncContextTool, AsyncTool, ContextTool, Tool
-
-
-@dataclass
-class BaseAgent(Generic[DepsT, FormattableT], ABC):
-    """Agent class for generating responses using LLMs with tools."""
-
-    ctx: Context[DepsT]
-    """The context for the agent, such as the history of messages."""
-
-    format: type[FormattableT] | None
-    """The response format for the generated response."""
-
-    model: Model
-    """The default model the agent will use if not specified through context."""
-
-
-@dataclass
-class Agent(BaseAgent[DepsT, FormattableT]):
-    """Agent class for generating responses using LLMs with tools."""
-
-    tools: Sequence[Tool | ContextTool[DepsT]] | None
-    """The tools available to the agent, if any."""
-
-    def __call__(
-        self,
-        content: UserContent,
-        *,
-        ctx: Context[DepsT] | None = None,
-    ) -> Response[FormattableT]:
-        """Generates a response by running the agent loop."""
-        raise NotImplementedError()
-
-    def call(
-        self,
-        content: UserContent,
-        *,
-        ctx: Context[DepsT] | None = None,
-    ) -> Response[FormattableT]:
-        """Generates a response by running the agent loop."""
-        raise NotImplementedError()
-
-    def stream(
-        self,
-        content: UserContent,
-        *,
-        ctx: Context[DepsT] | None = None,
-    ) -> StreamResponse[FormattableT]:
-        """Streams the response generated by running the agent loop."""
-        raise NotImplementedError()
-
-
-@dataclass
-class AsyncAgent(BaseAgent[DepsT, FormattableT]):
-    """Asynchronous agent class for generating responses using LLMs with tools."""
-
-    tools: Sequence[AsyncTool | AsyncContextTool[DepsT]] | None
-    """The tools available to the agent, if any."""
-
-    async def __call__(
-        self,
-        content: UserContent,
-        *,
-        ctx: Context[DepsT] | None = None,
-    ) -> AsyncResponse[FormattableT]:
-        """Generates a response by running the agent loop asynchronously."""
-        raise NotImplementedError()
-
-    async def call(
-        self,
-        content: UserContent,
-        *,
-        ctx: Context[DepsT] | None = None,
-    ) -> AsyncResponse[FormattableT]:
-        """Generates a response by running the agent loop asynchronously."""
-        raise NotImplementedError()
-
-    async def stream(
-        self,
-        content: UserContent,
-        *,
-        ctx: Context[DepsT] | None = None,
-    ) -> AsyncStreamResponse[FormattableT]:
-        """Streams the response generated by running the agent loop asynchronously."""
-        raise NotImplementedError()

mirascope/llm/agents/agent_template.py

@@ -1,45 +0,0 @@
-from typing import Generic, overload
-
-from ..context import DepsT
-from ..formatting import FormattableT
-from .agent import Agent, AsyncAgent
-
-
-class AgentTemplate(Generic[DepsT, FormattableT]):
-    @overload
-    def __call__(
-        self: "AgentTemplate[None, FormattableT]",
-    ) -> Agent[None, FormattableT]:
-        """Create an Agent with no deps"""
-
-    @overload
-    def __call__(
-        self: "AgentTemplate[DepsT, FormattableT]", deps: DepsT
-    ) -> Agent[DepsT, FormattableT]:
-        """Create an Agent with deps"""
-
-    def __call__(
-        self: "AgentTemplate[None, FormattableT] | AgentTemplate[DepsT, FormattableT]",
-        deps: DepsT | None = None,
-    ) -> Agent[None, FormattableT] | Agent[DepsT, FormattableT]:
-        raise NotImplementedError()
-
-
-class AsyncAgentTemplate(Generic[DepsT, FormattableT]):
-    @overload
-    async def __call__(
-        self: "AsyncAgentTemplate[None, FormattableT]",
-    ) -> AsyncAgent[None, FormattableT]:
-        """Create an AsyncAgent with no deps"""
-
-    @overload
-    async def __call__(
-        self: "AsyncAgentTemplate[DepsT, FormattableT]", deps: DepsT
-    ) -> AsyncAgent[DepsT, FormattableT]:
-        """Create an AsyncAgent with deps"""
-
-    async def __call__(
-        self: "AsyncAgentTemplate[None, FormattableT] | AsyncAgentTemplate[DepsT, FormattableT]",
-        deps: DepsT | None = None,
-    ) -> AsyncAgent[None, FormattableT] | AsyncAgent[DepsT, FormattableT]:
-        raise NotImplementedError()

mirascope/llm/agents/decorator.py

@@ -1,176 +0,0 @@
-"""The `llm.agent` decorator for turning a function into an agent."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, Literal, Protocol, overload
-from typing_extensions import TypeVar, Unpack
-
-from ..tools import AsyncContextTool, AsyncTool, ContextTool, Tool
-from .agent_template import AgentTemplate, AsyncAgentTemplate
-
-if TYPE_CHECKING:
-    from ..clients import (
-        AnthropicClient,
-        AnthropicModelId,
-        BaseClient,
-        GoogleClient,
-        GoogleModelId,
-        ModelId,
-        OpenAICompletionsClient,
-        OpenAICompletionsModelId,
-        Params,
-        Provider,
-    )
-
-from ..context import Context, DepsT
-from ..formatting import FormattableT
-from ..types import P
-
-AgentToolT = TypeVar(
-    "AgentToolT",
-    bound="Tool | AsyncTool | ContextTool[Any] | AsyncContextTool[Any] | None",
-    covariant=True,
-    default=None,
-)
-
-
-class SystemPrompt(Protocol[P]):
-    """Protocol for a prompt template function that returns a system prompt as a string (no context)."""
-
-    def __call__(self) -> str: ...
-
-
-class ContextSystemPrompt(Protocol[P, DepsT]):
-    """Protocol for a prompt template function that returns a system prompt as a string (with context)."""
-
-    def __call__(self, ctx: Context[DepsT]) -> str: ...
-
-
-class AsyncSystemPrompt(Protocol[P]):
-    """Protocol for an async prompt template function that returns a system prompt as a string (no context)."""
-
-    async def __call__(self) -> str: ...
-
-
-class AsyncContextSystemPrompt(Protocol[P, DepsT]):
-    """Protocol for an async prompt template function that returns a system prompt as a string (with context)."""
-
-    async def __call__(self, ctx: Context[DepsT]) -> str: ...
-
-
-class AgentDecorator(Protocol[P, AgentToolT, FormattableT]):
-    """Protocol for the `agent` decorator."""
-
-    @overload
-    def __call__(
-        self: AgentDecorator[
-            P,
-            None | Tool | ContextTool[DepsT],
-            FormattableT,
-        ],
-        fn: SystemPrompt[P] | ContextSystemPrompt[P, DepsT],
-    ) -> AgentTemplate[DepsT, FormattableT]:
-        """Decorator for creating a sync agent."""
-        ...
-
-    @overload
-    def __call__(
-        self: AgentDecorator[
-            P,
-            None | AsyncTool | AsyncContextTool[DepsT],
-            FormattableT,
-        ],
-        fn: AsyncSystemPrompt[P] | AsyncContextSystemPrompt[P, DepsT],
-    ) -> AsyncAgentTemplate[DepsT, FormattableT]:
-        """Decorator for creating an async agent."""
-        ...
-
-    def __call__(
-        self,
-        fn: SystemPrompt[P]
-        | ContextSystemPrompt[P, DepsT]
-        | AsyncSystemPrompt[P]
-        | AsyncContextSystemPrompt[P, DepsT],
-    ) -> AgentTemplate[DepsT, FormattableT] | AsyncAgentTemplate[DepsT, FormattableT]:
-        """Decorator for creating an agent."""
-        raise NotImplementedError()
-
-
-@overload
-def agent(
-    *,
-    provider: Literal["anthropic"],
-    model_id: AnthropicModelId,
-    tools: list[AgentToolT] | None = None,
-    format: type[FormattableT] | None = None,
-    client: AnthropicClient | None = None,
-    **params: Unpack[Params],
-) -> AgentDecorator[..., AgentToolT, FormattableT]:
-    """Decorator for creating an Anthropic agent."""
-    ...
-
-
-@overload
-def agent(
-    *,
-    provider: Literal["google"],
-    model_id: GoogleModelId,
-    tools: list[AgentToolT] | None = None,
-    format: type[FormattableT] | None = None,
-    client: GoogleClient | None = None,
-    **params: Unpack[Params],
-) -> AgentDecorator[..., AgentToolT, FormattableT]:
-    """Decorator for creating a Google agent."""
-    ...
-
-
-@overload
-def agent(
-    *,
-    provider: Literal["openai:completions"],
-    model_id: OpenAICompletionsModelId,
-    tools: list[AgentToolT] | None = None,
-    format: type[FormattableT] | None = None,
-    client: OpenAICompletionsClient | None = None,
-    **params: Unpack[Params],
-) -> AgentDecorator[..., AgentToolT, FormattableT]:
-    """Decorator for creating an OpenAI agent."""
-    ...
-
-
-@overload
-def agent(
-    *,
-    provider: Provider,
-    model_id: ModelId,
-    tools: list[AgentToolT] | None = None,
-    format: type[FormattableT] | None = None,
-    client: None = None,
-    **params: Unpack[Params],
-) -> AgentDecorator[..., AgentToolT, FormattableT]:
-    """Decorator for creating an agent using any registered model."""
-    ...
-
-
-def agent(
-    *,
-    provider: Provider,
-    model_id: ModelId,
-    tools: list[AgentToolT] | None = None,
-    format: type[FormattableT] | None = None,
-    client: BaseClient | None = None,
-    **params: Unpack[Params],
-) -> AgentDecorator[..., AgentToolT, FormattableT]:
-    """Decorator for creating an agent or structured agent.
-
-    Args:
-        model_id: The model to use for the agent.
-        tools: The tools available to the agent.
-        format: The response format type for the agent.
-        client: The client to use for the agent.
-        **params: Additional parameters for the model.
-
-    Returns:
-        An of `AgentDecorator`.
-    """
-    raise NotImplementedError()

mirascope/llm/calls/base_call.py

@@ -1,33 +0,0 @@
-"""The `BaseCall` class for LLM calls."""
-
-from abc import ABC
-from dataclasses import dataclass
-from typing import Generic
-
-from ..formatting import Format, FormattableT
-from ..models import Model, get_model_from_context
-from ..prompts import PromptT
-from ..tools import ToolkitT
-from ..types import P
-
-
-@dataclass
-class BaseCall(Generic[P, PromptT, ToolkitT, FormattableT], ABC):
-    """A base class for generating responses using LLMs."""
-
-    default_model: Model
-    """The default model that will be used if no model is set in context."""
-
-    toolkit: ToolkitT
-    """The toolkit containing this call's tools."""
-
-    format: type[FormattableT] | Format[FormattableT] | None
-    """The response format for the generated response."""
-
-    fn: PromptT
-    """The Prompt function that generates the Prompt."""
-
-    @property
-    def model(self) -> Model:
-        """The model used for generating responses. May be overwritten via `with llm.model(...)."""
-        return get_model_from_context() or self.default_model

mirascope/llm/clients/__init__.py

@@ -1,34 +0,0 @@
-"""Client interfaces for LLM providers."""
-
-from .anthropic import (
-    AnthropicClient,
-    AnthropicModelId,
-)
-from .base import BaseClient, ClientT, Params
-from .google import GoogleClient, GoogleModelId
-from .openai import (
-    OpenAICompletionsClient,
-    OpenAICompletionsModelId,
-    OpenAIResponsesClient,
-    OpenAIResponsesModelId,
-)
-from .providers import PROVIDERS, ModelId, Provider, client, get_client
-
-__all__ = [
-    "PROVIDERS",
-    "AnthropicClient",
-    "AnthropicModelId",
-    "BaseClient",
-    "ClientT",
-    "GoogleClient",
-    "GoogleModelId",
-    "ModelId",
-    "OpenAICompletionsClient",
-    "OpenAICompletionsModelId",
-    "OpenAIResponsesClient",
-    "OpenAIResponsesModelId",
-    "Params",
-    "Provider",
-    "client",
-    "get_client",
-]

mirascope/llm/clients/anthropic/__init__.py

@@ -1,25 +0,0 @@
-"""Anthropic client implementation."""
-
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from .clients import AnthropicClient, client, get_client
-    from .model_ids import AnthropicModelId
-else:
-    try:
-        from .clients import AnthropicClient, client, get_client
-        from .model_ids import AnthropicModelId
-    except ImportError:  # pragma: no cover
-        from .._missing_import_stubs import create_client_stub, create_import_error_stub
-
-        AnthropicClient = create_client_stub("anthropic", "AnthropicClient")
-        AnthropicModelId = str
-        client = create_import_error_stub("anthropic", "AnthropicClient")
-        get_client = create_import_error_stub("anthropic", "AnthropicClient")
-
-__all__ = [
-    "AnthropicClient",
-    "AnthropicModelId",
-    "client",
-    "get_client",
-]

mirascope/llm/clients/anthropic/_utils/encode.py

@@ -1,243 +0,0 @@
-"""Anthropic message encoding and request preparation."""
-
-import json
-from collections.abc import Sequence
-from functools import lru_cache
-from typing import Literal, TypedDict, cast
-from typing_extensions import Required
-
-from anthropic import Omit, types as anthropic_types
-
-from ....content import ContentPart, ImageMimeType
-from ....exceptions import FeatureNotSupportedError, FormattingModeNotSupportedError
-from ....formatting import (
-    Format,
-    FormattableT,
-    _utils as _formatting_utils,
-    resolve_format,
-)
-from ....messages import AssistantMessage, Message, UserMessage
-from ....tools import FORMAT_TOOL_NAME, BaseToolkit, ToolSchema
-from ...base import Params, _utils as _base_utils
-from ..model_ids import AnthropicModelId
-
-DEFAULT_MAX_TOKENS = 16000
-
-AnthropicImageMimeType = Literal["image/jpeg", "image/png", "image/gif", "image/webp"]
-
-
-def encode_image_mime_type(
-    mime_type: ImageMimeType,
-) -> AnthropicImageMimeType:
-    """Convert an ImageMimeType into anthropic supported mime type"""
-    if mime_type in ("image/jpeg", "image/png", "image/gif", "image/webp"):
-        return mime_type
-    raise FeatureNotSupportedError(
-        feature=f"Image with mime_type: {mime_type}", provider="anthropic"
-    )  # pragma: no cover
-
-
-class MessageCreateKwargs(TypedDict, total=False):
-    """Kwargs for Anthropic Message.create method."""
-
-    model: Required[str]
-    max_tokens: Required[int]
-    messages: Sequence[anthropic_types.MessageParam]
-    system: str | Omit
-    tools: Sequence[anthropic_types.ToolParam] | Omit
-    tool_choice: anthropic_types.ToolChoiceParam | Omit
-    temperature: float | Omit
-    top_p: float | Omit
-    top_k: int | Omit
-    stop_sequences: list[str] | Omit
-    thinking: anthropic_types.ThinkingConfigParam | Omit
-
-
-def _encode_content(
-    content: Sequence[ContentPart], encode_thoughts: bool
-) -> str | Sequence[anthropic_types.ContentBlockParam]:
-    """Convert mirascope content to Anthropic content format."""
-
-    if len(content) == 1 and content[0].type == "text":
-        return content[0].text
-
-    blocks: list[anthropic_types.ContentBlockParam] = []
-
-    for part in content:
-        if part.type == "text":
-            blocks.append(anthropic_types.TextBlockParam(type="text", text=part.text))
-        elif part.type == "image":
-            source: (
-                anthropic_types.Base64ImageSourceParam
-                | anthropic_types.URLImageSourceParam
-            )
-            if part.source.type == "base64_image_source":
-                source = anthropic_types.Base64ImageSourceParam(
-                    type="base64",
-                    media_type=encode_image_mime_type(part.source.mime_type),
-                    data=part.source.data,
-                )
-            else:  # url_image_source
-                source = anthropic_types.URLImageSourceParam(
-                    type="url",
-                    url=part.source.url,
-                )
-            blocks.append(anthropic_types.ImageBlockParam(type="image", source=source))
-        elif part.type == "audio":
-            raise FeatureNotSupportedError(
-                "audio input",
-                "anthropic",
-                message="Anthropic does not support audio inputs.",
-            )
-        elif part.type == "tool_output":
-            blocks.append(
-                anthropic_types.ToolResultBlockParam(
-                    type="tool_result",
-                    tool_use_id=part.id,
-                    content=str(part.value),
-                )
-            )
-        elif part.type == "tool_call":
-            blocks.append(
-                anthropic_types.ToolUseBlockParam(
-                    type="tool_use",
-                    id=part.id,
-                    name=part.name,
-                    input=json.loads(part.args),
-                )
-            )
-        elif part.type == "thought":
-            if encode_thoughts:
-                blocks.append(
-                    anthropic_types.TextBlockParam(
-                        type="text", text="**Thinking:** " + part.thought
-                    )
-                )
-        else:
-            raise NotImplementedError(f"Unsupported content type: {part.type}")
-
-    return blocks
-
-
-def _encode_message(
-    message: UserMessage | AssistantMessage,
-    model_id: AnthropicModelId,
-    encode_thoughts: bool,
-) -> anthropic_types.MessageParam:
-    """Convert user or assistant `Message`s to Anthropic `MessageParam` format.
-
-    Args:
-        messages: A Sequence containing `UserMessage`s or `AssistantMessage`s
-        model_id: The Anthropic model ID being used
-
-    Returns:
-        A Sequence of converted Anthropic `MessageParam`
-    """
-
-    if (
-        message.role == "assistant"
-        and message.provider == "anthropic"
-        and message.model_id == model_id
-        and message.raw_message
-        and not encode_thoughts
-    ):
-        return cast(anthropic_types.MessageParam, message.raw_message)
-    return {
-        "role": message.role,
-        "content": _encode_content(message.content, encode_thoughts),
-    }
-
-
-@lru_cache(maxsize=128)
-def _convert_tool_to_tool_param(tool: ToolSchema) -> anthropic_types.ToolParam:
-    """Convert a single Mirascope tool to Anthropic tool format with caching."""
-    schema_dict = tool.parameters.model_dump(by_alias=True, exclude_none=True)
-    schema_dict["type"] = "object"
-    return anthropic_types.ToolParam(
-        name=tool.name,
-        description=tool.description,
-        input_schema=schema_dict,
-    )
-
-
-def encode_request(
-    *,
-    model_id: AnthropicModelId,
-    messages: Sequence[Message],
-    tools: Sequence[ToolSchema] | BaseToolkit | None,
-    format: type[FormattableT] | Format[FormattableT] | None,
-    params: Params,
-) -> tuple[Sequence[Message], Format[FormattableT] | None, MessageCreateKwargs]:
-    """Prepares a request for the `Anthropic.messages.create` method."""
-    kwargs: MessageCreateKwargs = MessageCreateKwargs(
-        {
-            "model": model_id,
-            "max_tokens": DEFAULT_MAX_TOKENS,
-        }
-    )
-    encode_thoughts = False
-
-    with _base_utils.ensure_all_params_accessed(
-        params=params, provider="anthropic", unsupported_params=["seed"]
-    ) as param_accessor:
-        if param_accessor.temperature is not None:
-            kwargs["temperature"] = param_accessor.temperature
-        if param_accessor.max_tokens is not None:
-            kwargs["max_tokens"] = param_accessor.max_tokens
-        if param_accessor.top_p is not None:
-            kwargs["top_p"] = param_accessor.top_p
-        if param_accessor.top_k is not None:
-            kwargs["top_k"] = param_accessor.top_k
-        if param_accessor.stop_sequences is not None:
-            kwargs["stop_sequences"] = param_accessor.stop_sequences
-        if param_accessor.thinking is not None:
-            if param_accessor.thinking:
-                # Set budget to 50% of max_tokens with minimum of 1024
-                budget_tokens = max(1024, kwargs["max_tokens"] // 2)
-                kwargs["thinking"] = {"type": "enabled", "budget_tokens": budget_tokens}
-            else:
-                kwargs["thinking"] = {"type": "disabled"}
-        if param_accessor.encode_thoughts_as_text:
-            encode_thoughts = True
-
-    tools = tools.tools if isinstance(tools, BaseToolkit) else tools or []
-    anthropic_tools = [_convert_tool_to_tool_param(tool) for tool in tools]
-    format = resolve_format(format, default_mode="tool")
-    if format is not None:
-        if format.mode == "strict":
-            raise FormattingModeNotSupportedError(
-                formatting_mode="strict", provider="anthropic"
-            )
-        elif format.mode == "tool":
-            format_tool_schema = _formatting_utils.create_tool_schema(format)
-            anthropic_tools.append(_convert_tool_to_tool_param(format_tool_schema))
-            if tools:
-                kwargs["tool_choice"] = {"type": "any"}
-            else:
-                kwargs["tool_choice"] = {
-                    "type": "tool",
-                    "name": FORMAT_TOOL_NAME,
-                    "disable_parallel_tool_use": True,
-                }
-
-        if format.formatting_instructions:
-            messages = _base_utils.add_system_instructions(
-                messages, format.formatting_instructions
-            )
-
-    if anthropic_tools:
-        kwargs["tools"] = anthropic_tools
-
-    system_message_content, remaining_messages = _base_utils.extract_system_message(
-        messages
-    )
-
-    kwargs["messages"] = [
-        _encode_message(remaining_message, model_id, encode_thoughts)
-        for remaining_message in remaining_messages
-    ]
-
-    if system_message_content:
-        kwargs["system"] = system_message_content
-
-    return messages, format, kwargs