mirascope 2.0.1__tar.gz → 2.0.2__tar.gz

{mirascope-2.0.1 → mirascope-2.0.2}/PKG-INFO

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

mirascope-2.0.2/examples/intro/welcome.py

@@ -0,0 +1,46 @@
+from typing import Literal
+
+from mirascope import llm, ops
+
+# Connect to Mirascope Cloud for tracing and analytics
+ops.configure()
+ops.instrument_llm()
+
+
+@llm.tool
+@ops.trace
+def calculate(
+    operation: Literal["add", "subtract", "multiply", "divide"],
+    a: float,
+    b: float,
+) -> str:
+    """Perform a mathematical operation on two numbers."""
+    match operation:
+        case "add":
+            return str(a + b)
+        case "subtract":
+            return str(a - b)
+        case "multiply":
+            return str(a * b)
+        case "divide":
+            return str(a / b) if b != 0 else "Cannot divide by zero"
+
+
+@ops.version  # Automatically versions `math_agent` and traces it's execution
+@llm.call("openai/gpt-4o-mini", tools=[calculate])
+def math_agent(query: str) -> str:
+    return f"Help the user with: {query}"
+
+
+@ops.trace
+def run_math_agent(query: str) -> str:
+    response = math_agent(query)
+
+    while response.tool_calls:
+        tool_outputs = response.execute_tools()
+        response = response.resume(tool_outputs)
+
+    return response.text()
+
+
+print(run_math_agent("What's 42 * 17?"))

mirascope-2.0.2/mirascope/_utils.py

@@ -0,0 +1,34 @@
+"""Shared internal utilities for mirascope."""
+
+from typing import Any
+
+# Attributes to copy from wrapped functions (matches functools.WRAPPER_ASSIGNMENTS)
+WRAPPER_ASSIGNMENTS = (
+    "__module__",
+    "__name__",
+    "__qualname__",
+    "__annotations__",
+    "__doc__",
+)
+
+
+def copy_function_metadata(target: Any, source: Any) -> None:  # noqa: ANN401
+    """Copy standard function metadata from source to target.
+
+    Copies __module__, __name__, __qualname__, __annotations__, __doc__
+    from source to target, and sets __wrapped__ to source.
+
+    This enables decorator stacking by preserving the original function's
+    metadata on wrapper objects.
+
+    Args:
+        target: The wrapper object to copy metadata to
+        source: The original function to copy metadata from
+    """
+    for attr in WRAPPER_ASSIGNMENTS:
+        try:
+            value = getattr(source, attr)
+            object.__setattr__(target, attr, value)
+        except AttributeError:
+            pass
+    object.__setattr__(target, "__wrapped__", source)

{mirascope-2.0.1 → mirascope-2.0.2}/mirascope/api/_generated/organization_invitations/client.py

@@ -92,7 +92,7 @@ class OrganizationInvitationsClient:
         organization_id : str
 
         recipient_email : str
-            a string matching the pattern ^[^\s@]+@[^\s@]+\.[^\s@]+$
+            a string matching the pattern ^[^ \t\n\r\f\v@]+@[^ \t\n\r\f\v@]+[.][^ \t\n\r\f\v@]+$
 
         role : OrganizationInvitationsCreateRequestRole
 
@@ -335,7 +335,7 @@ class AsyncOrganizationInvitationsClient:
         organization_id : str
 
         recipient_email : str
-            a string matching the pattern ^[^\s@]+@[^\s@]+\.[^\s@]+$
+            a string matching the pattern ^[^ \t\n\r\f\v@]+@[^ \t\n\r\f\v@]+[.][^ \t\n\r\f\v@]+$
 
         role : OrganizationInvitationsCreateRequestRole
 

{mirascope-2.0.1 → mirascope-2.0.2}/mirascope/api/_generated/organization_invitations/raw_client.py

@@ -172,7 +172,7 @@ class RawOrganizationInvitationsClient:
         organization_id : str
 
         recipient_email : str
-            a string matching the pattern ^[^\s@]+@[^\s@]+\.[^\s@]+$
+            a string matching the pattern ^[^ \t\n\r\f\v@]+@[^ \t\n\r\f\v@]+[.][^ \t\n\r\f\v@]+$
 
         role : OrganizationInvitationsCreateRequestRole
 
@@ -911,7 +911,7 @@ class AsyncRawOrganizationInvitationsClient:
         organization_id : str
 
         recipient_email : str
-            a string matching the pattern ^[^\s@]+@[^\s@]+\.[^\s@]+$
+            a string matching the pattern ^[^ \t\n\r\f\v@]+@[^ \t\n\r\f\v@]+[.][^ \t\n\r\f\v@]+$
 
         role : OrganizationInvitationsCreateRequestRole
 

{mirascope-2.0.1 → mirascope-2.0.2}/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>

{mirascope-2.0.1 → mirascope-2.0.2}/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-2.0.1 → mirascope-2.0.2}/mirascope/llm/prompts/prompts.py

@@ -1,9 +1,10 @@
 """Concrete Prompt classes for generating messages with tools and formatting."""
 
-from collections.abc import Sequence
-from dataclasses import dataclass
-from typing import Generic, overload
+from collections.abc import Callable, Sequence
+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 Format, FormattableT, OutputParser
 from ..messages import Message, promote_to_messages
@@ -19,12 +20,7 @@ from ..responses import (
     Response,
     StreamResponse,
 )
-from ..tools import (
-    AsyncContextToolkit,
-    AsyncToolkit,
-    ContextToolkit,
-    Toolkit,
-)
+from ..tools import AsyncContextToolkit, AsyncToolkit, ContextToolkit, Toolkit
 from ..types import P
 from .protocols import (
     AsyncContextMessageTemplate,
@@ -33,9 +29,26 @@ from .protocols import (
     MessageTemplate,
 )
 
+FunctionT = TypeVar("FunctionT", bound=Callable[..., Any])
+
+
+@dataclass(kw_only=True)
+class BasePrompt(Generic[FunctionT]):
+    """Base class for all Prompt types with shared metadata functionality."""
+
+    fn: FunctionT
+    """The underlying prompt function that generates message content."""
+
+    __name__: str = field(init=False, repr=False, default="")
+    """The name of the underlying function (preserved for decorator stacking)."""
+
+    def __post_init__(self) -> None:
+        """Preserve standard function attributes for decorator stacking."""
+        copy_function_metadata(self, self.fn)
+
 
 @dataclass
-class Prompt(Generic[P, FormattableT]):
+class Prompt(BasePrompt[MessageTemplate[P]], Generic[P, FormattableT]):
     """A prompt that can be called with a model to generate a response.
 
     Created by decorating a `MessageTemplate` with `llm.prompt`. The decorated
@@ -45,9 +58,6 @@ class Prompt(Generic[P, FormattableT]):
     It can be invoked with a model: `prompt(model, *args, **kwargs)`.
     """
 
-    fn: MessageTemplate[P]
-    """The underlying prompt function that generates message content."""
-
     toolkit: Toolkit
     """The toolkit containing this prompt's tools."""
 
@@ -134,7 +144,7 @@ class Prompt(Generic[P, FormattableT]):
 
 
 @dataclass
-class AsyncPrompt(Generic[P, FormattableT]):
+class AsyncPrompt(BasePrompt[AsyncMessageTemplate[P]], Generic[P, FormattableT]):
     """An async prompt that can be called with a model to generate a response.
 
     Created by decorating an async `MessageTemplate` with `llm.prompt`. The decorated
@@ -144,9 +154,6 @@ class AsyncPrompt(Generic[P, FormattableT]):
     It can be invoked with a model: `await prompt(model, *args, **kwargs)`.
     """
 
-    fn: AsyncMessageTemplate[P]
-    """The underlying async prompt function that generates message content."""
-
     toolkit: AsyncToolkit
     """The toolkit containing this prompt's async tools."""
 
@@ -235,7 +242,9 @@ class AsyncPrompt(Generic[P, FormattableT]):
 
 
 @dataclass
-class ContextPrompt(Generic[P, DepsT, FormattableT]):
+class ContextPrompt(
+    BasePrompt[ContextMessageTemplate[P, DepsT]], Generic[P, DepsT, FormattableT]
+):
     """A context-aware prompt that can be called with a model to generate a response.
 
     Created by decorating a `ContextMessageTemplate` with `llm.prompt`. The decorated
@@ -246,9 +255,6 @@ class ContextPrompt(Generic[P, DepsT, FormattableT]):
     It can be invoked with a model: `prompt(model, ctx, *args, **kwargs)`.
     """
 
-    fn: ContextMessageTemplate[P, DepsT]
-    """The underlying context-aware prompt function that generates message content."""
-
     toolkit: ContextToolkit[DepsT]
     """The toolkit containing this prompt's context-aware tools."""
 
@@ -361,7 +367,9 @@ class ContextPrompt(Generic[P, DepsT, FormattableT]):
 
 
 @dataclass
-class AsyncContextPrompt(Generic[P, DepsT, FormattableT]):
+class AsyncContextPrompt(
+    BasePrompt[AsyncContextMessageTemplate[P, DepsT]], Generic[P, DepsT, FormattableT]
+):
     """An async context-aware prompt that can be called with a model to generate a response.
 
     Created by decorating an async `ContextMessageTemplate` with `llm.prompt`. The decorated
@@ -372,9 +380,6 @@ class AsyncContextPrompt(Generic[P, DepsT, FormattableT]):
     It can be invoked with a model: `await prompt(model, ctx, *args, **kwargs)`.
     """
 
-    fn: AsyncContextMessageTemplate[P, DepsT]
-    """The underlying async context-aware prompt function that generates message content."""
-
     toolkit: AsyncContextToolkit[DepsT]
     """The toolkit containing this prompt's async context-aware tools."""
 

{mirascope-2.0.1 → mirascope-2.0.2}/mirascope/llm/tools/tool_schema.py

@@ -22,6 +22,7 @@ from docstring_parser import parse
 from pydantic import BaseModel, Field, create_model
 from pydantic.fields import FieldInfo
 
+from ..._utils import copy_function_metadata
 from ..content import ToolCall
 from ..types import Jsonable
 from .protocols import AsyncContextToolFn, AsyncToolFn, ContextToolFn, ToolFn
@@ -159,11 +160,14 @@ class ToolSchema(Generic[ToolFnT]):
 
     strict: bool | None
     """Whether the tool should use strict mode when supported by the model.
-    
-    If set to None, will use the provider's default setting (usually as strict as 
+
+    If set to None, will use the provider's default setting (usually as strict as
     possible).
     """
 
+    __name__: str
+    """The name of the underlying function (preserved for decorator stacking)."""
+
     def __hash__(self) -> int:
         if not hasattr(self, "_hash"):
             self._hash = hash(
@@ -200,6 +204,7 @@ class ToolSchema(Generic[ToolFnT]):
         self.description = description
         self.parameters = parameters
         self.strict = strict
+        copy_function_metadata(self, fn)
 
     @classmethod
     def from_function(

{mirascope-2.0.1 → mirascope-2.0.2}/mirascope/ops/_internal/closure.py

@@ -738,12 +738,15 @@ class _DependencyCollector:
             # For Python 3.13+
             return definition.func  # pyright: ignore[reportFunctionMemberAccess] # pragma: no cover
 
+        # Handle objects with .fn but no __qualname__ (e.g., old-style wrappers).
+        # With copy_function_metadata() now copying __qualname__ to ToolSchema, Prompt,
+        # Call, etc., this branch is no longer reached in normal usage.
         if (
             (wrapped_function := getattr(definition, "fn", None)) is not None
             and not hasattr(definition, "__qualname__")
             and callable(wrapped_function)
         ):
-            return wrapped_function
+            return wrapped_function  # pragma: no cover
 
         return definition
 

{mirascope-2.0.1 → mirascope-2.0.2}/mirascope/ops/_internal/exporters/exporters.py

@@ -20,14 +20,17 @@ from ....api._generated.traces.types import (
     TracesCreateRequestResourceSpansItemResource,
     TracesCreateRequestResourceSpansItemResourceAttributesItem,
     TracesCreateRequestResourceSpansItemResourceAttributesItemValue,
+    TracesCreateRequestResourceSpansItemResourceAttributesItemValueArrayValue,
     TracesCreateRequestResourceSpansItemScopeSpansItem,
     TracesCreateRequestResourceSpansItemScopeSpansItemScope,
     TracesCreateRequestResourceSpansItemScopeSpansItemSpansItem,
     TracesCreateRequestResourceSpansItemScopeSpansItemSpansItemAttributesItem,
     TracesCreateRequestResourceSpansItemScopeSpansItemSpansItemAttributesItemValue,
+    TracesCreateRequestResourceSpansItemScopeSpansItemSpansItemAttributesItemValueArrayValue,
     TracesCreateRequestResourceSpansItemScopeSpansItemSpansItemStatus,
 )
 from ....api.client import Mirascope
+from .utils import to_otlp_any_value
 
 logger = logging.getLogger(__name__)
 
@@ -282,17 +285,7 @@ class MirascopeOTLPExporter(SpanExporter):
     def _convert_attribute_value(
         self, value: AttributeValue
     ) -> TracesCreateRequestResourceSpansItemScopeSpansItemSpansItemAttributesItemValue:
-        """Convert OpenTelemetry AttributeValue to Mirascope API's KeyValueValue.
-
-        This conversion is necessary because the Fern-generated API client
-        expects KeyValueValue objects, not OpenTelemetry's AttributeValue types.
-
-        Args:
-            value: An OpenTelemetry AttributeValue (bool, int, float, str, or Sequence)
-
-        Returns:
-            A KeyValueValue object for the Mirascope API
-        """
+        """Convert OpenTelemetry AttributeValue to Mirascope API's KeyValueValue."""
         match value:
             case str():
                 return TracesCreateRequestResourceSpansItemScopeSpansItemSpansItemAttributesItemValue(
@@ -312,49 +305,21 @@ class MirascopeOTLPExporter(SpanExporter):
                 )
             case _:
                 return TracesCreateRequestResourceSpansItemScopeSpansItemSpansItemAttributesItemValue(
-                    string_value=str(list(value))
+                    array_value=TracesCreateRequestResourceSpansItemScopeSpansItemSpansItemAttributesItemValueArrayValue(
+                        values=[to_otlp_any_value(v) for v in value]
+                    )
                 )
 
     def _convert_event_attribute_value(
         self, value: AttributeValue
     ) -> dict[str, object]:
-        """Convert OpenTelemetry AttributeValue to OTLP event attribute value format.
-
-        This uses the OTLP JSON format with typed value wrappers (e.g., stringValue, intValue).
-
-        Args:
-            value: An OpenTelemetry AttributeValue (bool, int, float, str, or Sequence)
-
-        Returns:
-            A dict with the typed value (e.g., {"stringValue": "..."})
-        """
-        match value:
-            case str():
-                return {"stringValue": value}
-            case bool():
-                return {"boolValue": value}
-            case int():
-                return {"intValue": str(value)}
-            case float():
-                return {"doubleValue": value}
-            case _:
-                # Sequences - convert to string representation
-                return {"stringValue": str(list(value))}
+        """Convert OpenTelemetry AttributeValue to OTLP event attribute value format."""
+        return to_otlp_any_value(value)
 
     def _convert_resource_attribute_value(
         self, value: AttributeValue
     ) -> TracesCreateRequestResourceSpansItemResourceAttributesItemValue:
-        """Convert OpenTelemetry AttributeValue to Mirascope API's resource KeyValueValue.
-
-        This conversion is necessary because the Fern-generated API client
-        expects KeyValueValue objects, not OpenTelemetry's AttributeValue types.
-
-        Args:
-            value: An OpenTelemetry AttributeValue (bool, int, float, str, or Sequence)
-
-        Returns:
-            A KeyValueValue object for the Mirascope API resource attributes
-        """
+        """Convert OpenTelemetry AttributeValue to Mirascope API's resource KeyValueValue."""
         match value:
             case str():
                 return TracesCreateRequestResourceSpansItemResourceAttributesItemValue(
@@ -374,7 +339,9 @@ class MirascopeOTLPExporter(SpanExporter):
                 )
             case _:
                 return TracesCreateRequestResourceSpansItemResourceAttributesItemValue(
-                    string_value=str(list(value))
+                    array_value=TracesCreateRequestResourceSpansItemResourceAttributesItemValueArrayValue(
+                        values=[to_otlp_any_value(v) for v in value]
+                    )
                 )
 
     def shutdown(self) -> None:

mirascope-2.0.2/mirascope/ops/_internal/exporters/utils.py

@@ -0,0 +1,66 @@
+"""Utility functions for OpenTelemetry exporters.
+
+This module provides helper functions for formatting and converting
+OpenTelemetry data types for export.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+
+from opentelemetry.util.types import AttributeValue
+
+
+def to_otlp_any_value(value: AttributeValue) -> dict[str, object]:
+    """Convert AttributeValue to OTLP AnyValue (dict form).
+
+    - string/bool/int/float are converted to stringValue/boolValue/intValue/doubleValue
+    - Sequence (excluding str/bytes/Mapping) is converted to arrayValue.values
+    - Unsupported types fallback to stringValue=str(value)
+
+    Args:
+        value: An OpenTelemetry AttributeValue (bool, int, float, str, or Sequence)
+
+    Returns:
+        A dict representing OTLP AnyValue (e.g., {"stringValue": "..."})
+    """
+    match value:
+        case str():
+            return {"stringValue": value}
+        case bool():
+            return {"boolValue": value}
+        case int():
+            return {"intValue": str(value)}
+        case float():
+            return {"doubleValue": value}
+        case _ if isinstance(value, bytes | bytearray | memoryview | Mapping):
+            return {"stringValue": str(value)}
+        case _ if isinstance(value, Sequence):
+            values = [to_otlp_any_value(v) for v in value]
+            return {"arrayValue": {"values": values}}
+        case _:
+            return {"stringValue": str(value)}
+
+
+def format_trace_id(trace_id: int) -> str:
+    """Format a trace ID as a 32-character hex string.
+
+    Args:
+        trace_id: The trace ID as an integer.
+
+    Returns:
+        32-character hexadecimal string representation of the trace ID.
+    """
+    return format(trace_id, "032x")
+
+
+def format_span_id(span_id: int) -> str:
+    """Format a span ID as a 16-character hex string.
+
+    Args:
+        span_id: The span ID as an integer.
+
+    Returns:
+        16-character hexadecimal string representation of the span ID.
+    """
+    return format(span_id, "016x")

{mirascope-2.0.1 → mirascope-2.0.2}/mirascope/ops/_internal/traced_calls.py

@@ -6,6 +6,7 @@ from dataclasses import dataclass, field
 from typing import Any, Generic, TypeVar
 from typing_extensions import TypeIs
 
+from ..._utils import copy_function_metadata
 from ...llm.calls import AsyncCall, AsyncContextCall, Call, ContextCall
 from ...llm.context import Context, DepsT
 from ...llm.formatting import FormattableT
@@ -35,6 +36,7 @@ from .traced_functions import (
     TracedContextFunction,
     TracedFunction,
 )
+from .utils import get_original_fn
 
 CallT = TypeVar(
     "CallT",
@@ -106,6 +108,14 @@ class _BaseTracedCall(Generic[CallT]):
     metadata: dict[str, str] = field(default_factory=dict)
     """Arbitrary key-value pairs for additional metadata."""
 
+    __name__: str = field(init=False, repr=False, default="")
+    """The name of the underlying function (preserved for decorator stacking)."""
+
+    def __post_init__(self) -> None:
+        """Preserve standard function attributes for decorator stacking."""
+        original_fn = get_original_fn(self._call.prompt.fn)
+        copy_function_metadata(self, original_fn)
+
 
 @dataclass(kw_only=True)
 class TracedCall(_BaseTracedCall[Call[P, FormattableT]]):
@@ -153,6 +163,7 @@ class TracedCall(_BaseTracedCall[Call[P, FormattableT]]):
 
     def __post_init__(self) -> None:
         """Initialize TracedFunction wrappers for call and stream methods."""
+        super().__post_init__()
         self.call = TracedFunction(
             fn=self._call.call, tags=self.tags, metadata=self.metadata
         )
@@ -213,6 +224,7 @@ class TracedAsyncCall(_BaseTracedCall[AsyncCall[P, FormattableT]]):
 
     def __post_init__(self) -> None:
         """Initialize AsyncTracedFunction wrappers for call and stream methods."""
+        super().__post_init__()
         self.call = AsyncTracedFunction(
             fn=self._call.call, tags=self.tags, metadata=self.metadata
         )
@@ -276,6 +288,7 @@ class TracedContextCall(_BaseTracedCall[ContextCall[P, DepsT, FormattableT]]):
 
     def __post_init__(self) -> None:
         """Initialize TracedContextFunction wrappers for call and stream methods."""
+        super().__post_init__()
         self.call = TracedContextFunction(
             fn=self._call.call, tags=self.tags, metadata=self.metadata
         )
@@ -344,6 +357,7 @@ class TracedAsyncContextCall(_BaseTracedCall[AsyncContextCall[P, DepsT, Formatta
 
     def __post_init__(self) -> None:
         """Initialize AsyncTracedContextFunction wrappers for call and stream methods."""
+        super().__post_init__()
         self.call = AsyncTracedContextFunction(
             fn=self._call.call, tags=self.tags, metadata=self.metadata
         )