mirascope 2.0.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

mirascope/api/_generated/reference.md

@@ -1682,7 +1682,7 @@ client.organization_invitations.create(
 <dl>
 <dd>
 
-**recipient_email:** `str` — a string matching the pattern ^[^\s@]+@[^\s@]+\.[^\s@]+$
+**recipient_email:** `str` — a string matching the pattern ^[^ \t\n\r\f\v@]+@[^ \t\n\r\f\v@]+[.][^ \t\n\r\f\v@]+$
     
 </dd>
 </dl>
@@ -2616,6 +2616,78 @@ client.project_memberships.create(
 </dl>
 
 
+</dd>
+</dl>
+</details>
+
+<details><summary><code>client.project_memberships.<a href="src/mirascope/project_memberships/client.py">get</a>(...)</code></summary>
+<dl>
+<dd>
+
+#### 🔌 Usage
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+```python
+from mirascope.api._generated import Mirascope
+
+client = Mirascope()
+client.project_memberships.get(
+    organization_id="organizationId",
+    project_id="projectId",
+    member_id="memberId",
+)
+
+```
+</dd>
+</dl>
+</dd>
+</dl>
+
+#### ⚙️ Parameters
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+**organization_id:** `str` 
+    
+</dd>
+</dl>
+
+<dl>
+<dd>
+
+**project_id:** `str` 
+    
+</dd>
+</dl>
+
+<dl>
+<dd>
+
+**member_id:** `str` 
+    
+</dd>
+</dl>
+
+<dl>
+<dd>
+
+**request_options:** `typing.Optional[RequestOptions]` — Request-specific configuration.
+    
+</dd>
+</dl>
+</dd>
+</dl>
+
+
 </dd>
 </dl>
 </details>

mirascope/llm/__init__.py

@@ -75,6 +75,7 @@ from .exceptions import (
 )
 from .formatting import (
     Format,
+    FormatSpec,
     FormattableT,
     FormattingMode,
     OutputParser,
@@ -130,6 +131,7 @@ from .responses import (
     ContextResponse,
     ContextStreamResponse,
     FinishReason,
+    ProviderToolUsage,
     RawMessageChunk,
     Response,
     RootResponse,
@@ -144,18 +146,25 @@ from .responses import (
 )
 from .tools import (
     AnyToolFn,
+    AnyTools,
     AnyToolSchema,
     AsyncContextTool,
     AsyncContextToolkit,
+    AsyncContextTools,
     AsyncTool,
     AsyncToolkit,
+    AsyncTools,
     BaseToolkit,
     ContextTool,
     ContextToolkit,
+    ContextTools,
+    ProviderTool,
     Tool,
     Toolkit,
     ToolkitT,
+    Tools,
     ToolSchema,
+    WebSearchTool,
     tool,
 )
 from .types import Jsonable
@@ -165,6 +174,7 @@ __all__ = [
     "AnyResponse",
     "AnyToolFn",
     "AnyToolSchema",
+    "AnyTools",
     "AssistantContent",
     "AssistantContentChunk",
     "AssistantContentPart",
@@ -177,6 +187,7 @@ __all__ = [
     "AsyncContextStreamResponse",
     "AsyncContextTool",
     "AsyncContextToolkit",
+    "AsyncContextTools",
     "AsyncPrompt",
     "AsyncResponse",
     "AsyncStream",
@@ -186,6 +197,7 @@ __all__ = [
     "AsyncTool",
     "AsyncToolCallStream",
     "AsyncToolkit",
+    "AsyncTools",
     "Audio",
     "AuthenticationError",
     "BadRequestError",
@@ -203,12 +215,14 @@ __all__ = [
     "ContextStreamResponse",
     "ContextTool",
     "ContextToolkit",
+    "ContextTools",
     "DepsT",
     "Document",
     "Error",
     "FeatureNotSupportedError",
     "FinishReason",
     "Format",
+    "FormatSpec",
     "FormattableT",
     "FormattingMode",
     "Image",
@@ -229,6 +243,8 @@ __all__ = [
     "Provider",
     "ProviderError",
     "ProviderId",
+    "ProviderTool",
+    "ProviderToolUsage",
     "RateLimitError",
     "RawMessageChunk",
     "Response",
@@ -266,12 +282,15 @@ __all__ = [
     "ToolSchema",
     "Toolkit",
     "ToolkitT",
+    "Tools",
     "URLImageSource",
     "Usage",
     "UsageDeltaChunk",
     "UserContent",
     "UserContentPart",
     "UserMessage",
+    "WebSearchTool",
+    "WebSearchTool",
     "call",
     "calls",
     "content",

mirascope/llm/calls/calls.py

@@ -1,8 +1,10 @@
 """The Call module for generating responses using LLMs."""
 
-from dataclasses import dataclass
-from typing import Generic, TypeVar, overload
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any, Generic, TypeVar, overload
 
+from ..._utils import copy_function_metadata
 from ..context import Context, DepsT
 from ..formatting import FormattableT
 from ..models import Model, use_model
@@ -12,6 +14,7 @@ from ..prompts import (
     ContextPrompt,
     Prompt,
 )
+from ..prompts.prompts import BasePrompt
 from ..responses import (
     AsyncContextResponse,
     AsyncContextStreamResponse,
@@ -24,24 +27,35 @@ from ..responses import (
 )
 from ..types import P
 
-CallT = TypeVar("CallT", bound="BaseCall")
+PromptT = TypeVar("PromptT", bound=BasePrompt[Callable[..., Any]])
+CallT = TypeVar("CallT", bound="BaseCall[Any]")
 
 
-@dataclass
-class BaseCall:
+@dataclass(kw_only=True)
+class BaseCall(Generic[PromptT]):
     """Base class for all Call types with shared model functionality."""
 
     default_model: Model
     """The default model that will be used if no model is set in context."""
 
+    prompt: PromptT
+    """The underlying Prompt instance that generates messages with tools and format."""
+
+    __name__: str = field(init=False, repr=False, default="")
+    """The name of the underlying function (preserved for decorator stacking)."""
+
     @property
     def model(self) -> Model:
         """The model used for generating responses. May be overwritten via `with llm.model(...)`."""
         return use_model(self.default_model)
 
+    def __post_init__(self) -> None:
+        """Preserve standard function attributes for decorator stacking."""
+        copy_function_metadata(self, self.prompt.fn)
+
 
 @dataclass
-class Call(BaseCall, Generic[P, FormattableT]):
+class Call(BaseCall[Prompt[P, FormattableT]], Generic[P, FormattableT]):
     """A call that directly generates LLM responses without requiring a model argument.
 
     Created by decorating a `MessageTemplate` with `llm.call`. The decorated function
@@ -53,9 +67,6 @@ class Call(BaseCall, Generic[P, FormattableT]):
     The model can be overridden at runtime using `with llm.model(...)` context manager.
     """
 
-    prompt: Prompt[P, FormattableT]
-    """The underlying Prompt instance that generates messages with tools and format."""
-
     @overload
     def __call__(
         self: "Call[P, None]", *args: P.args, **kwargs: P.kwargs
@@ -104,7 +115,7 @@ class Call(BaseCall, Generic[P, FormattableT]):
 
 
 @dataclass
-class AsyncCall(BaseCall, Generic[P, FormattableT]):
+class AsyncCall(BaseCall[AsyncPrompt[P, FormattableT]], Generic[P, FormattableT]):
     """An async call that directly generates LLM responses without requiring a model argument.
 
     Created by decorating an async `MessageTemplate` with `llm.call`. The decorated async
@@ -116,9 +127,6 @@ class AsyncCall(BaseCall, Generic[P, FormattableT]):
     The model can be overridden at runtime using `with llm.model(...)` context manager.
     """
 
-    prompt: AsyncPrompt[P, FormattableT]
-    """The underlying AsyncPrompt instance that generates messages with tools and format."""
-
     @overload
     async def __call__(
         self: "AsyncCall[P, None]", *args: P.args, **kwargs: P.kwargs
@@ -169,7 +177,9 @@ class AsyncCall(BaseCall, Generic[P, FormattableT]):
 
 
 @dataclass
-class ContextCall(BaseCall, Generic[P, DepsT, FormattableT]):
+class ContextCall(
+    BaseCall[ContextPrompt[P, DepsT, FormattableT]], Generic[P, DepsT, FormattableT]
+):
     """A context-aware call that directly generates LLM responses without requiring a model argument.
 
     Created by decorating a `ContextMessageTemplate` with `llm.call`. The decorated function
@@ -182,9 +192,6 @@ class ContextCall(BaseCall, Generic[P, DepsT, FormattableT]):
     The model can be overridden at runtime using `with llm.model(...)` context manager.
     """
 
-    prompt: ContextPrompt[P, DepsT, FormattableT]
-    """The underlying ContextPrompt instance that generates messages with tools and format."""
-
     @overload
     def __call__(
         self: "ContextCall[P, DepsT, None]",
@@ -255,7 +262,10 @@ class ContextCall(BaseCall, Generic[P, DepsT, FormattableT]):
 
 
 @dataclass
-class AsyncContextCall(BaseCall, Generic[P, DepsT, FormattableT]):
+class AsyncContextCall(
+    BaseCall[AsyncContextPrompt[P, DepsT, FormattableT]],
+    Generic[P, DepsT, FormattableT],
+):
     """An async context-aware call that directly generates LLM responses without requiring a model argument.
 
     Created by decorating an async `ContextMessageTemplate` with `llm.call`. The decorated async
@@ -268,9 +278,6 @@ class AsyncContextCall(BaseCall, Generic[P, DepsT, FormattableT]):
     The model can be overridden at runtime using `with llm.model(...)` context manager.
     """
 
-    prompt: AsyncContextPrompt[P, DepsT, FormattableT]
-    """The underlying AsyncContextPrompt instance that generates messages with tools and format."""
-
     @overload
     async def __call__(
         self: "AsyncContextCall[P, DepsT, None]",

mirascope/llm/calls/decorator.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING, Generic, cast, overload
 from typing_extensions import Unpack
 
 from ..context import DepsT
-from ..formatting import Format, FormattableT, OutputParser
+from ..formatting import FormatSpec, FormattableT
 from ..models import Model
 from ..prompts import (
     AsyncContextMessageTemplate,
@@ -29,6 +29,7 @@ from ..tools import (
     AsyncToolkit,
     ContextTool,
     ContextToolkit,
+    ProviderTool,
     Tool,
     Toolkit,
     ToolT,
@@ -58,12 +59,10 @@ class CallDecorator(Generic[ToolT, FormattableT]):
     model: Model
     """The default model to use with this call. May be overridden."""
 
-    tools: Sequence[ToolT] | None
+    tools: Sequence[ToolT | ProviderTool] | None
     """The tools that are included in the prompt, if any."""
 
-    format: (
-        type[FormattableT] | Format[FormattableT] | OutputParser[FormattableT] | None
-    )
+    format: FormatSpec[FormattableT] | None
     """The structured output format off the prompt, if any."""
 
     @overload
@@ -114,7 +113,8 @@ class CallDecorator(Generic[ToolT, FormattableT]):
 
         if is_context and is_async:
             tools = cast(
-                Sequence[AsyncTool | AsyncContextTool[DepsT]] | None, self.tools
+                Sequence[AsyncTool | AsyncContextTool[DepsT] | ProviderTool] | None,
+                self.tools,
             )
             prompt = AsyncContextPrompt(
                 fn=fn,
@@ -126,7 +126,9 @@ class CallDecorator(Generic[ToolT, FormattableT]):
                 default_model=self.model,
             )
         elif is_context:
-            tools = cast(Sequence[Tool | ContextTool[DepsT]] | None, self.tools)
+            tools = cast(
+                Sequence[Tool | ContextTool[DepsT] | ProviderTool] | None, self.tools
+            )
             prompt = ContextPrompt(
                 fn=fn,
                 toolkit=ContextToolkit(tools=tools),
@@ -137,7 +139,7 @@ class CallDecorator(Generic[ToolT, FormattableT]):
                 default_model=self.model,
             )
         elif is_async:
-            tools = cast(Sequence[AsyncTool] | None, self.tools)
+            tools = cast(Sequence[AsyncTool | ProviderTool] | None, self.tools)
             prompt = AsyncPrompt(
                 fn=fn, toolkit=AsyncToolkit(tools=tools), format=self.format
             )
@@ -146,7 +148,7 @@ class CallDecorator(Generic[ToolT, FormattableT]):
                 default_model=self.model,
             )
         else:
-            tools = cast(Sequence[Tool] | None, self.tools)
+            tools = cast(Sequence[Tool | ProviderTool] | None, self.tools)
             prompt = Prompt(fn=fn, toolkit=Toolkit(tools=tools), format=self.format)
             return Call(
                 prompt=prompt,
@@ -158,11 +160,8 @@ class CallDecorator(Generic[ToolT, FormattableT]):
 def call(
     model: ModelId,
     *,
-    tools: Sequence[ToolT] | None = None,
-    format: type[FormattableT]
-    | Format[FormattableT]
-    | OutputParser[FormattableT]
-    | None = None,
+    tools: Sequence[ToolT | ProviderTool] | None = None,
+    format: FormatSpec[FormattableT] | None = None,
     **params: Unpack[Params],
 ) -> CallDecorator[ToolT, FormattableT]:
     """Decorator for converting prompt functions into LLM calls.
@@ -176,11 +175,8 @@ def call(
 def call(
     model: Model,
     *,
-    tools: Sequence[ToolT] | None = None,
-    format: type[FormattableT]
-    | Format[FormattableT]
-    | OutputParser[FormattableT]
-    | None = None,
+    tools: Sequence[ToolT | ProviderTool] | None = None,
+    format: FormatSpec[FormattableT] | None = None,
 ) -> CallDecorator[ToolT, FormattableT]:
     """Decorator for converting prompt functions into LLM calls.
 
@@ -192,11 +188,8 @@ def call(
 def call(
     model: ModelId | Model,
     *,
-    tools: Sequence[ToolT] | None = None,
-    format: type[FormattableT]
-    | Format[FormattableT]
-    | OutputParser[FormattableT]
-    | None = None,
+    tools: Sequence[ToolT | ProviderTool] | None = None,
+    format: FormatSpec[FormattableT] | None = None,
     **params: Unpack[Params],
 ) -> CallDecorator[ToolT, FormattableT]:
     """Decorates a `MessageTemplate` to create a `Call` that can be invoked directly.

mirascope/llm/formatting/__init__.py

@@ -18,11 +18,11 @@ from .primitives import (
     create_wrapper_model,
     is_primitive_type,
 )
-from .types import FormattableT, FormattingMode
+from .types import FormatSpec, FormattableT, FormattingMode
 
 __all__ = [
     "Format",
-    "FormattableT",
+    "FormatSpec",
     "FormattableT",
     "FormattingMode",
     "FromCallArgs",

mirascope/llm/formatting/format.py

@@ -11,7 +11,7 @@ from ..tools import FORMAT_TOOL_NAME, ToolFn, ToolParameterSchema, ToolSchema
 from ..types import NoneType
 from .output_parser import OutputParser, is_output_parser
 from .primitives import create_wrapper_model, is_primitive_type
-from .types import FormattableT, FormattingMode, HasFormattingInstructions
+from .types import FormatSpec, FormattableT, FormattingMode, HasFormattingInstructions
 
 TOOL_MODE_INSTRUCTIONS = f"""Always respond to the user's query using the {FORMAT_TOOL_NAME} tool for structured output."""
 
@@ -267,9 +267,7 @@ def format(
 
 
 def resolve_format(
-    formattable: (
-        type[FormattableT] | Format[FormattableT] | OutputParser[FormattableT] | None
-    ),
+    formattable: FormatSpec[FormattableT] | None,
     default_mode: FormattingMode,
 ) -> Format[FormattableT] | None:
     """Resolve a `Format` (or None) from a possible `Format`, Formattable, or `OutputParser`.

mirascope/llm/formatting/types.py

@@ -1,15 +1,32 @@
 """Type for the formatting module."""
 
-from typing import Literal, Protocol, runtime_checkable
-from typing_extensions import TypeVar
+from typing import TYPE_CHECKING, Literal, Protocol, runtime_checkable
+from typing_extensions import TypeAliasType, TypeVar
 
 from pydantic import BaseModel
 
 from .primitives import PrimitiveType
 
+if TYPE_CHECKING:
+    from .format import Format
+    from .output_parser import OutputParser
+
 FormattableT = TypeVar(
     "FormattableT", bound=BaseModel | PrimitiveType | None, default=None
 )
+
+FormatSpec = TypeAliasType(
+    "FormatSpec",
+    "type[FormattableT] | Format[FormattableT] | OutputParser[FormattableT]",
+    type_params=(FormattableT,),
+)
+"""Type alias for format parameter types.
+
+A FormatSpec can be:
+- A type (class) that represents the format schema (e.g., a Pydantic BaseModel)
+- A Format wrapper that includes mode and other metadata
+- An OutputParser for custom parsing logic
+"""
 """Type variable for structured response format types.
 
 This TypeVar represents the type of structured output format that LLM responses