nighthawk-python 0.12.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

nighthawk/__init__.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from . import oversight, resilience
+from . import lifecycle, oversight, resilience
+from .composition import UNSET, Extend, Merge, UnsetType
 from .configuration import (
     StepContextLimits,
     StepExecutorConfiguration,
@@ -8,34 +9,45 @@ from .configuration import (
 )
 from .errors import (
     ExecutionError,
+    NameConflictError,
     NaturalParseError,
     NighthawkError,
+    ToolDeclarationError,
     ToolEvaluationError,
-    ToolRegistrationError,
+    ToolNameConflictError,
     ToolValidationError,
 )
 from .json_renderer import JsonableValue, to_jsonable_value
-from .natural.decorator import natural_function
+from .natural.decorator import get_transformed_function, natural_function
 from .runtime.scoping import (
-    ExecutionRef,
+    ExecutionReference,
     UsageMeter,
-    get_current_usage_meter,
-    get_execution_ref,
+    get_capabilities,
+    get_execution_reference,
     get_implicit_references,
+    get_lifecycle,
+    get_oversight,
     get_step_executor,
     get_system_prompt_suffix_fragments,
+    get_tools,
+    get_usage_meter,
     get_user_prompt_suffix_fragments,
     run,
     scope,
 )
-from .runtime.step_context import StepContext, get_current_step_context
+from .runtime.step_context import StepContext, get_step_context
 from .runtime.step_executor import AgentStepExecutor, StepExecutor
-from .tools.registry import tool
 
 __all__ = [
+    "UNSET",
+    "Extend",
+    "Merge",
+    "UnsetType",
+    "NameConflictError",
+    "ToolNameConflictError",
     "AgentStepExecutor",
     "ExecutionError",
-    "ExecutionRef",
+    "ExecutionReference",
     "JsonableValue",
     "NaturalParseError",
     "NighthawkError",
@@ -45,21 +57,26 @@ __all__ = [
     "StepExecutorConfiguration",
     "StepPromptTemplates",
     "ToolEvaluationError",
-    "ToolRegistrationError",
+    "ToolDeclarationError",
     "ToolValidationError",
     "UsageMeter",
-    "get_current_step_context",
-    "get_current_usage_meter",
-    "get_execution_ref",
+    "get_capabilities",
+    "get_step_context",
+    "get_usage_meter",
+    "get_execution_reference",
     "get_implicit_references",
+    "get_oversight",
     "get_step_executor",
+    "get_tools",
     "get_system_prompt_suffix_fragments",
     "get_user_prompt_suffix_fragments",
     "oversight",
+    "lifecycle",
+    "get_lifecycle",
     "natural_function",
+    "get_transformed_function",
     "resilience",
     "run",
     "scope",
     "to_jsonable_value",
-    "tool",
 ]

nighthawk/backends/claude_code_cli.py

@@ -15,7 +15,7 @@ from pydantic_ai.profiles import ModelProfile
 from pydantic_ai.settings import ModelSettings
 from pydantic_ai.usage import RequestUsage
 
-from ..tools.registry import get_visible_tools
+from ..tools.declarations import get_visible_tools
 from .base import BackendModelBase, append_text_projected_tool_result_preview_prompt
 from .claude_code_settings import ClaudeCodeModelSettings
 from .mcp_server import mcp_server_if_needed

nighthawk/backends/claude_code_sdk.py

@@ -15,7 +15,7 @@ from pydantic_ai.settings import ModelSettings
 from pydantic_ai.usage import RequestUsage
 
 from ..json_renderer import to_jsonable_value
-from ..tools.registry import get_visible_tools
+from ..tools.declarations import get_visible_tools
 from .base import BackendModelBase, append_text_projected_tool_result_preview_prompt
 from .claude_code_settings import ClaudeCodeModelSettings
 from .mcp_boundary import call_tool_for_claude_code_sdk

nighthawk/backends/codex.py

@@ -16,7 +16,7 @@ from pydantic_ai.profiles.openai import OpenAIJsonSchemaTransformer
 from pydantic_ai.settings import ModelSettings
 from pydantic_ai.usage import RequestUsage
 
-from ..tools.registry import get_visible_tools
+from ..tools.declarations import get_visible_tools
 from .base import BackendModelBase, BackendModelSettings, append_text_projected_tool_result_preview_prompt
 from .mcp_server import mcp_server_if_needed
 from .text_projection import TextProjectedRequest, resolve_text_projection_staging_root_directory

nighthawk/backends/mcp_boundary.py

@@ -13,7 +13,7 @@ from pydantic_ai.messages import BinaryContent, FileUrl, TextContent, UploadedFi
 from ..runtime.step_context import (
     DEFAULT_TOOL_RESULT_RENDERING_POLICY,
     ToolResultRenderingPolicy,
-    get_current_step_context,
+    get_step_context,
     resolve_tool_result_rendering_policy,
 )
 from ..tools._tool_return_content import resolve_tool_return_segments
@@ -38,7 +38,7 @@ _logger = logging.getLogger("nighthawk")
 
 def _resolve_tool_result_rendering_policy() -> ToolResultRenderingPolicy:
     try:
-        step_context = get_current_step_context()
+        step_context = get_step_context()
     except Exception:
         return DEFAULT_TOOL_RESULT_RENDERING_POLICY
     return resolve_tool_result_rendering_policy(step_context.tool_result_rendering_policy)

nighthawk/composition.py

@@ -0,0 +1,59 @@
+"""Explicit inheritance and composition operations for execution scopes."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import ClassVar
+
+
+class UnsetType:
+    """The singleton type of :data:`UNSET`, representing an omitted argument."""
+
+    __slots__ = ()
+    _instance: ClassVar[UnsetType | None] = None
+
+    def __new__(cls) -> UnsetType:
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __repr__(self) -> str:
+        return "UNSET"
+
+    def __copy__(self) -> UnsetType:
+        return self
+
+    def __deepcopy__(self, identity_to_copy: dict[int, object]) -> UnsetType:
+        return self
+
+
+UNSET = UnsetType()
+"""Inherit the enclosing scope value; also marks omitted rewrite fields."""
+
+
+@dataclass(frozen=True, init=False)
+class Extend[T]:
+    """Append a sequence to an inherited ordered collection, preserving entry identity."""
+
+    values: tuple[T, ...]
+
+    def __init__(self, values: Sequence[T]) -> None:
+        if not isinstance(values, Sequence) or isinstance(values, (str, bytes, bytearray)):
+            raise TypeError("Extend requires a sequence of entries")
+        object.__setattr__(self, "values", tuple(values))
+
+
+@dataclass(frozen=True, init=False)
+class Merge[T]:
+    """Merge named references with inherited references, checking conflicts by identity."""
+
+    name_to_value: Mapping[str, T]
+
+    def __init__(self, name_to_value: Mapping[str, T]) -> None:
+        if not isinstance(name_to_value, Mapping):
+            raise TypeError("Merge requires a name-to-value mapping")
+        if any(not isinstance(name, str) for name in name_to_value):
+            raise TypeError("Merge names must be strings")
+        object.__setattr__(self, "name_to_value", MappingProxyType(dict(name_to_value)))

nighthawk/configuration.py

@@ -3,7 +3,9 @@ from __future__ import annotations
 from typing import Any
 
 import tiktoken
-from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic import BaseModel, ConfigDict, Field, InstanceOf, field_serializer, field_validator
+from pydantic_ai.models import Model
+from pydantic_core import PydanticSerializationError
 
 from .json_renderer import JsonRendererStyle
 
@@ -113,7 +115,10 @@ class StepExecutorConfiguration(BaseModel):
     """Configuration for a step executor.
 
     Attributes:
-        model: Model identifier in "provider:model" format (e.g. "openai:gpt-4o").
+        model: Provider-qualified identifier or borrowed Pydantic AI Model instance.
+            Instances retain identity; the host owns client lifetime. Serialization
+            must explicitly exclude a live model field, including in nested records.
+            Configuration representations omit the model to avoid traversing credentials.
         model_settings: Provider-specific model settings. Accepts a dict or a
             backend-specific BaseModel instance (auto-converted to dict).
         prompts: Prompt templates for step execution.
@@ -128,7 +133,7 @@ class StepExecutorConfiguration(BaseModel):
 
     model_config = ConfigDict(extra="forbid", frozen=True)
 
-    model: str = "openai-responses:gpt-5.4-nano"
+    model: str | InstanceOf[Model] = Field(default="openai-responses:gpt-5.6-luna", repr=False)
     model_settings: dict[str, Any] | BaseModel | None = None
 
     @field_validator("model_settings", mode="before")
@@ -147,8 +152,14 @@ class StepExecutorConfiguration(BaseModel):
 
     @field_validator("model")
     @classmethod
-    def _validate_model(cls, value: str) -> str:
-        return _validate_model_identifier(value)
+    def _validate_model(cls, value: str | Model) -> str | Model:
+        return _validate_model_identifier(value) if isinstance(value, str) else value
+
+    @field_serializer("model")
+    def _serialize_model(self, value: str | Model) -> str:
+        if not isinstance(value, str):
+            raise PydanticSerializationError("A runtime Model cannot be serialized; exclude the model field explicitly")
+        return value
 
     def resolve_token_encoding(self) -> tiktoken.Encoding:
         """Return the tiktoken encoding for this configuration.
@@ -160,7 +171,7 @@ class StepExecutorConfiguration(BaseModel):
         if self.tokenizer_encoding is not None:
             return tiktoken.get_encoding(self.tokenizer_encoding)
 
-        _, model_name = self.model.split(":", 1)
+        model_name = self.model.split(":", 1)[1] if isinstance(self.model, str) else self.model.model_name
 
         try:
             return tiktoken.encoding_for_model(model_name)

nighthawk/errors.py

@@ -1,5 +1,10 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .lifecycle import StepFailed
+
 
 class NighthawkError(Exception):
     """Base exception for all Nighthawk errors."""
@@ -10,7 +15,16 @@ class NaturalParseError(NighthawkError):
 
 
 class ExecutionError(NighthawkError):
-    """Raised when a Natural block execution fails."""
+    """Runtime failure exposing its terminal record and chaining the original error.
+
+    Internal helpers may supply a message; the runtime boundary attaches a
+    StepFailed record to every outward internal execution failure.
+    """
+
+    def __init__(self, failure: StepFailed | str, *, description: str | None = None) -> None:
+        self.step_failed = None if isinstance(failure, str) else failure
+        message = failure if isinstance(failure, str) else str(failure.original_exception)
+        super().__init__(f"{description}: {message}" if description else message)
 
 
 class ToolEvaluationError(NighthawkError):
@@ -21,5 +35,13 @@ class ToolValidationError(NighthawkError):
     """Raised when tool input validation fails."""
 
 
-class ToolRegistrationError(NighthawkError):
-    """Raised when tool registration fails."""
+class ToolDeclarationError(NighthawkError):
+    """Raised when a tool declaration is invalid."""
+
+
+class NameConflictError(NighthawkError):
+    """Raised when distinct declarations claim the same name."""
+
+
+class ToolNameConflictError(ToolDeclarationError, NameConflictError):
+    """Raised when tool declarations claim the same or a reserved name."""

nighthawk/lifecycle.py

@@ -0,0 +1,129 @@
+"""Terminal delivery for host-owned execution ledgers.
+
+Records snapshot collection structure, retaining the exact live Python values.
+Hosts own serialization, persistence, and deduplication by step_execution_id.
+Delivery is synchronous and attempted once, after caller binding assignments.
+"""
+
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass, field
+from types import MappingProxyType
+from typing import Literal
+
+from .errors import NighthawkError
+from .runtime.execution_reference import ExecutionReference
+from .runtime.step_contract import StepKind, StepOutcome
+from .runtime.step_result import Break, Continue, Pass, Raise, Return, StepResult
+
+type FailureStage = Literal[
+    "preparation",
+    "executor",
+    "outcome_validation",
+    "binding_validation",
+    "return_inspection",
+    "return_evaluation",
+    "return_await",
+    "return_validation",
+    "commit_inspection",
+    "rewrite_validation",
+    "oversight_rejection",
+    "raise_resolution",
+    "raise_construction",
+    "binding_assignment",
+]
+
+
+@dataclass(frozen=True, kw_only=True)
+class _StepFinished:
+    execution_reference: ExecutionReference
+    processed_natural_program: str | None = None
+    input_binding_name_to_value: Mapping[str, object] | None = None
+    allowed_step_kinds: tuple[StepKind, ...] | None = None
+    assigned_binding_name_to_value: Mapping[str, object] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if self.execution_reference.step_execution_id is None or self.execution_reference.source_location is None:
+            raise ValueError("Terminal records require invocation and source identity")
+        for name in ("input_binding_name_to_value", "assigned_binding_name_to_value", "validated_binding_name_to_value"):
+            value = getattr(self, name, None)
+            if value is not None:
+                object.__setattr__(self, name, MappingProxyType(dict(value)))
+        if self.allowed_step_kinds is not None:
+            object.__setattr__(self, "allowed_step_kinds", tuple(self.allowed_step_kinds))
+
+
+@dataclass(frozen=True, kw_only=True)
+class StepCompleted(_StepFinished):
+    """A resolved control result whose generated assignments completed."""
+
+    outcome: Pass | Return | Break | Continue
+    kind: Literal["completed"] = field(default="completed", init=False)
+
+
+@dataclass(frozen=True, kw_only=True)
+class StepRaised(_StepFinished):
+    """An approved DSL Raise, with its successfully constructed exception."""
+
+    outcome: Raise
+    exception: BaseException
+    kind: Literal["raised"] = field(default="raised", init=False)
+
+
+@dataclass(frozen=True, kw_only=True)
+class StepFailed(_StepFinished):
+    """An ordinary execution failure, distinct from a DSL-selected Raise."""
+
+    failure_stage: FailureStage
+    original_exception: Exception
+    attempted_outcome: StepOutcome | StepResult | None = None
+    validated_binding_name_to_value: Mapping[str, object] | None = None
+    inspection_subject: Literal["return_expression", "step_commit", "tool_call"] | None = None
+    rejection_reason: str | None = None
+    kind: Literal["failed"] = field(default="failed", init=False)
+
+
+@dataclass(frozen=True, kw_only=True)
+class StepInterrupted(_StepFinished):
+    """Cancellation or process control; propagation takes priority over delivery."""
+
+    failure_stage: FailureStage
+    original_exception: BaseException
+    kind: Literal["interrupted"] = field(default="interrupted", init=False)
+
+
+type StepFinished = StepCompleted | StepRaised | StepFailed | StepInterrupted
+
+
+@dataclass(frozen=True)
+class StepLifecycle:
+    """Scoped synchronous notification, inherited with UNSET and cleared by None.
+
+    A callback may persist a record and raise a host exception referencing it.
+    Callback errors never trigger another execution notification or rollback.
+    Rethrowing the exact original exception preserves its existing cause.
+    Host deduplication must match both execution identity and the stored event.
+    """
+
+    on_step_finished: Callable[[StepFinished], None] | None = None
+
+
+class StepDeliveryError(NighthawkError):
+    """Host adapter delivery failure; does not assert that persistence succeeded."""
+
+    def __init__(self, execution_reference: ExecutionReference, cause: BaseException) -> None:
+        self.execution_reference = execution_reference
+        self.delivery_cause = cause
+        super().__init__(f"Step terminal delivery failed: {cause}")
+        self.__cause__ = cause
+
+
+__all__ = [
+    "FailureStage",
+    "StepCompleted",
+    "StepDeliveryError",
+    "StepFailed",
+    "StepFinished",
+    "StepInterrupted",
+    "StepLifecycle",
+    "StepRaised",
+]

nighthawk/natural/decorator.py

@@ -6,14 +6,15 @@ import logging
 import sys
 import textwrap
 from collections.abc import Awaitable, Callable
+from contextlib import AbstractContextManager
 from functools import wraps
+from types import FunctionType
 from typing import Any, cast
 
-from ..runtime.runner import Runner, StepEnvelope
+from ..runtime.runner import Runner
 from ..runtime.scoping import get_step_executor
 from ..runtime.step_context import python_cell_scope, python_name_scope
-from ..tools.registry import call_scope
-from .blocks import find_natural_blocks
+from .blocks import extract_program, find_natural_blocks
 from .transform import transform_module_ast
 
 type NaturalFunctionCallable = Callable[..., Any]
@@ -21,48 +22,10 @@ type NaturalFunctionCallable = Callable[..., Any]
 
 class _RunnerProxy:
     @staticmethod
-    def run_step(
-        natural_program: str,
-        input_binding_names: list[str],
-        output_binding_names: list[str],
-        binding_name_to_type: dict[str, object],
-        return_annotation: object,
-        is_in_loop: bool,
-    ) -> StepEnvelope:
+    def execution() -> AbstractContextManager[Runner]:
         caller_frame = sys._getframe(1)
-        current_step_executor = get_step_executor()
-        runner = Runner(current_step_executor)
-        return runner.run_step(
-            natural_program,
-            input_binding_names,
-            output_binding_names,
-            binding_name_to_type,
-            return_annotation,
-            is_in_loop,
-            caller_frame=caller_frame,
-        )
-
-    @staticmethod
-    async def run_step_async(
-        natural_program: str,
-        input_binding_names: list[str],
-        output_binding_names: list[str],
-        binding_name_to_type: dict[str, object],
-        return_annotation: object,
-        is_in_loop: bool,
-    ) -> StepEnvelope:
-        caller_frame = sys._getframe(1)
-        current_step_executor = get_step_executor()
-        runner = Runner(current_step_executor)
-        return await runner.run_step_async(
-            natural_program,
-            input_binding_names,
-            output_binding_names,
-            binding_name_to_type,
-            return_annotation,
-            is_in_loop,
-            caller_frame=caller_frame,
-        )
+        runner = Runner(get_step_executor())
+        return runner.execution(caller_frame=caller_frame)
 
 
 def _extract_inline_fstring_name_set(function_source: str, *, function_name: str) -> set[str]:
@@ -223,6 +186,7 @@ def natural_function(func: NaturalFunctionCallable | None = None) -> NaturalFunc
         original_module = ast.Module(body=[], type_ignores=[])
 
     capture_name_set = _build_capture_name_set(source, func.__name__)
+    capture_name_set.update(func.__code__.co_freevars)
 
     definition_frame = inspect.currentframe()
     name_to_value: dict[str, object] = {}
@@ -233,39 +197,69 @@ def natural_function(func: NaturalFunctionCallable | None = None) -> NaturalFunc
                 if name in caller_frame.f_locals:
                     name_to_value[name] = caller_frame.f_locals[name]
 
+    original_name_to_cell = dict(zip(func.__code__.co_freevars, func.__closure__ or (), strict=True))
+    for name, cell in original_name_to_cell.items():
+        try:
+            name_to_value[name] = cell.cell_contents
+        except ValueError:
+            name_to_value[name] = None
+
     captured_name_tuple = tuple(sorted(capture_name_set))
 
     transformed_module = transform_module_ast(original_module, captured_name_tuple=captured_name_tuple)
 
     filename = inspect.getsourcefile(func) or "<nighthawk>"
 
+    # Runtime helpers referenced by the transformed body travel through the factory closure, not through
+    # module globals. The transformed function therefore shares ``func.__globals__`` with the original
+    # function: names defined in the module after decoration stay visible, and the module namespace is
+    # never polluted with helper names.
+    helper_name_to_value: dict[str, object] = {
+        "__nighthawk_runner__": _RunnerProxy(),
+        "__nh_extract_program__": extract_program,
+        "__nh_python_cell_scope__": python_cell_scope,
+    }
+    factory_name_to_value: dict[str, object] = {**name_to_value, **helper_name_to_value}
+
     factory_module = _build_transformed_factory_module(
         transformed_module=transformed_module,
         function_name=func.__name__,
-        name_to_value=name_to_value,
+        name_to_value=factory_name_to_value,
     )
     code = compile(factory_module, filename, "exec")
 
-    globals_namespace: dict[str, object] = dict(func.__globals__)
-    globals_namespace["__nighthawk_runner__"] = _RunnerProxy()
-    from .blocks import extract_program as _nh_extract_program
-
-    globals_namespace["__nh_extract_program__"] = _nh_extract_program
-    globals_namespace["__nh_python_cell_scope__"] = python_cell_scope
-
     module_namespace: dict[str, object] = {}
-    exec(code, globals_namespace, module_namespace)
+    exec(code, func.__globals__, module_namespace)
 
     factory = module_namespace.get("__nh_factory__")
     if not callable(factory):
         raise RuntimeError("Transformed factory not found after compilation")
 
-    transformed = factory(name_to_value)
+    transformed = factory(factory_name_to_value)
     if not callable(transformed):
         raise RuntimeError("Transformed function not found after factory execution")
 
+    if transformed.__closure__ is not None:
+        # Preserve original Python cells, including nonlocal writes and late rebinding.
+        transformed = FunctionType(
+            transformed.__code__,
+            transformed.__globals__,
+            transformed.__name__,
+            transformed.__defaults__,
+            tuple(
+                original_name_to_cell.get(name, cell)
+                for name, cell in zip(
+                    transformed.__code__.co_freevars,
+                    transformed.__closure__,
+                    strict=True,
+                )
+            ),
+        )
+        transformed.__kwdefaults__ = func.__kwdefaults__
+        transformed.__annotations__ = func.__annotations__
+
     transformed_freevar_name_set = set(transformed.__code__.co_freevars)
-    captured_name_set = set(name_to_value.keys())
+    captured_name_set = set(factory_name_to_value.keys())
 
     unexpected_freevar_name_set = transformed_freevar_name_set - captured_name_set
     allowed_unexpected_freevar_name_set = {func.__name__}
@@ -274,7 +268,7 @@ def natural_function(func: NaturalFunctionCallable | None = None) -> NaturalFunc
             f"Transformed function freevars do not match captured names. freevars={transformed.__code__.co_freevars!r} captured={tuple(sorted(name_to_value.keys()))!r}"
         )
 
-    if transformed.__closure__ is None and name_to_value:
+    if transformed.__closure__ is None and transformed_freevar_name_set:
         raise RuntimeError("Transformed function closure is missing for captured names")
 
     if inspect.iscoroutinefunction(func):
@@ -282,20 +276,43 @@ def natural_function(func: NaturalFunctionCallable | None = None) -> NaturalFunc
 
         @wraps(func)
         async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
-            with call_scope():
-                if name_to_value:
-                    with python_name_scope(name_to_value):
-                        return await transformed_async(*args, **kwargs)
-                return await transformed_async(*args, **kwargs)
+            if name_to_value:
+                with python_name_scope(name_to_value):
+                    return await transformed_async(*args, **kwargs)
+            return await transformed_async(*args, **kwargs)
 
+        async_wrapper.__nighthawk_transformed_function__ = transformed  # type: ignore[attr-defined]
         return cast(NaturalFunctionCallable, async_wrapper)  # type: ignore[return-value]
 
     @wraps(func)
     def wrapper(*args: Any, **kwargs: Any) -> Any:
-        with call_scope():
-            if name_to_value:
-                with python_name_scope(name_to_value):
-                    return transformed(*args, **kwargs)
-            return transformed(*args, **kwargs)
+        if name_to_value:
+            with python_name_scope(name_to_value):
+                return transformed(*args, **kwargs)
+        return transformed(*args, **kwargs)
 
+    wrapper.__nighthawk_transformed_function__ = transformed  # type: ignore[attr-defined]
     return cast(NaturalFunctionCallable, wrapper)  # type: ignore[return-value]
+
+
+def get_transformed_function(function: Callable[..., object]) -> Callable[..., object]:
+    """Find a Natural function's compiled body through conventional wrapper chains.
+
+    Standard inspect.unwrap follows the original source. This accessor exposes the
+    transformed body for inspection; normal execution should use the decorated callable
+    to establish its runtime context. Invalid inputs and wrapper cycles raise TypeError.
+    """
+    current: object = function
+    seen_identity_set: set[int] = set()
+    while id(current) not in seen_identity_set:
+        seen_identity_set.add(id(current))
+        if isinstance(current, (staticmethod, classmethod)) or inspect.ismethod(current):
+            current = current.__func__
+            continue
+        transformed = getattr(current, "__nighthawk_transformed_function__", None)
+        if callable(transformed):
+            return transformed
+        current = getattr(current, "__wrapped__", None)
+        if current is None:
+            break
+    raise TypeError("Expected a Natural function or a conventional wrapper around one")