nighthawk-python 0.11.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

nighthawk/__init__.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from . import oversight, resilience
+from .composition import UNSET, Extend, Merge, UnsetType
 from .configuration import (
     StepContextLimits,
     StepExecutorConfiguration,
@@ -8,31 +9,41 @@ 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,
     UsageMeter,
-    get_current_usage_meter,
+    get_capabilities,
     get_execution_ref,
     get_implicit_references,
+    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",
@@ -45,21 +56,24 @@ __all__ = [
     "StepExecutorConfiguration",
     "StepPromptTemplates",
     "ToolEvaluationError",
-    "ToolRegistrationError",
+    "ToolDeclarationError",
     "ToolValidationError",
     "UsageMeter",
-    "get_current_step_context",
-    "get_current_usage_meter",
+    "get_capabilities",
+    "get_step_context",
+    "get_usage_meter",
     "get_execution_ref",
     "get_implicit_references",
+    "get_oversight",
     "get_step_executor",
+    "get_tools",
     "get_system_prompt_suffix_fragments",
     "get_user_prompt_suffix_fragments",
     "oversight",
     "natural_function",
+    "get_transformed_function",
     "resilience",
     "run",
     "scope",
     "to_jsonable_value",
-    "tool",
 ]

nighthawk/backends/base.py

@@ -9,6 +9,7 @@ from pydantic import BaseModel, ConfigDict, field_validator
 from pydantic_ai.exceptions import UnexpectedModelBehavior, UserError
 from pydantic_ai.messages import (
     CachePoint,
+    InstructionPart,
     ModelMessage,
     ModelRequest,
     RetryPromptPart,
@@ -73,6 +74,31 @@ def _collect_system_prompt_text(model_request: ModelRequest) -> str:
     return "\n\n".join(parts)
 
 
+def _collect_instruction_text(
+    messages: list[ModelMessage],
+    model_request_parameters: ModelRequestParameters,
+) -> str | None:
+    instruction_parts = model_request_parameters.instruction_parts
+    if instruction_parts is not None:
+        return InstructionPart.join(instruction_parts)
+
+    model_request_list = [message for message in reversed(messages) if isinstance(message, ModelRequest)]
+    if not model_request_list:
+        return None
+
+    most_recent_model_request = model_request_list[0]
+    if most_recent_model_request.instructions is not None:
+        return most_recent_model_request.instructions
+
+    if len(model_request_list) < 2:
+        return None
+
+    if all(isinstance(part, ToolReturnPart | RetryPromptPart) for part in most_recent_model_request.parts):
+        return model_request_list[1].instructions
+
+    return None
+
+
 def _resolve_current_tool_result_max_tokens() -> int:
     return resolve_current_tool_result_rendering_policy().tool_result_max_tokens
 
@@ -152,8 +178,8 @@ class BackendModelBase(Model):
         messages: list[ModelMessage],
         model_request_parameters: ModelRequestParameters,
     ) -> PreparedRequestParts:
-        if model_request_parameters.builtin_tools:
-            raise UserError(f"{self.backend_label} does not support builtin tools")
+        if model_request_parameters.native_tools:
+            raise UserError(f"{self.backend_label} does not support native tools")
 
         if model_request_parameters.allow_image_output:
             raise UserError(f"{self.backend_label} does not support image output")
@@ -162,7 +188,7 @@ class BackendModelBase(Model):
 
         system_prompt_text = _collect_system_prompt_text(model_request)
 
-        instructions = self._get_instructions(messages, model_request_parameters)
+        instructions = _collect_instruction_text(messages, model_request_parameters)
         if instructions:
             system_prompt_text = "\n\n".join([system_prompt_text, instructions]) if system_prompt_text else instructions
 

nighthawk/backends/claude_code_cli.py

@@ -8,7 +8,6 @@ import tempfile
 from typing import IO, TypedDict
 
 from pydantic import field_validator
-from pydantic_ai.builtin_tools import AbstractBuiltinTool
 from pydantic_ai.exceptions import UnexpectedModelBehavior, UserError
 from pydantic_ai.messages import ModelMessage, ModelResponse, TextPart
 from pydantic_ai.models import ModelRequestParameters
@@ -16,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
@@ -137,7 +136,7 @@ class ClaudeCodeCliModel(BackendModelBase):
                 supports_json_object_output=False,
                 supports_image_output=False,
                 default_structured_output_mode="native",
-                supported_builtin_tools=frozenset([AbstractBuiltinTool]),
+                supported_native_tools=frozenset(),
             ),
         )
         self._model_name = model_name

nighthawk/backends/claude_code_sdk.py

@@ -7,7 +7,6 @@ from datetime import datetime
 from typing import Any
 
 from opentelemetry import context as otel_context
-from pydantic_ai.builtin_tools import AbstractBuiltinTool
 from pydantic_ai.exceptions import UnexpectedModelBehavior
 from pydantic_ai.messages import ModelMessage, ModelResponse, TextPart
 from pydantic_ai.models import ModelRequestParameters
@@ -16,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
@@ -111,7 +110,7 @@ class ClaudeCodeSdkModel(BackendModelBase):
                 supports_json_object_output=False,
                 supports_image_output=False,
                 default_structured_output_mode="native",
-                supported_builtin_tools=frozenset([AbstractBuiltinTool]),
+                supported_native_tools=frozenset(),
             ),
         )
         self._model_name = model_name

nighthawk/backends/codex.py

@@ -8,7 +8,6 @@ from dataclasses import replace
 from typing import IO, Any, Literal, TypedDict
 
 from pydantic import field_validator
-from pydantic_ai.builtin_tools import AbstractBuiltinTool
 from pydantic_ai.exceptions import UnexpectedModelBehavior, UserError
 from pydantic_ai.messages import ModelMessage, ModelResponse, TextPart
 from pydantic_ai.models import ModelRequestParameters
@@ -17,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
@@ -165,7 +164,7 @@ class CodexModel(BackendModelBase):
                 supports_json_object_output=False,
                 supports_image_output=False,
                 default_structured_output_mode="native",
-                supported_builtin_tools=frozenset([AbstractBuiltinTool]),
+                supported_native_tools=frozenset(),
                 json_schema_transformer=_CodexJsonSchemaTransformer,
             ),
         )

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)
@@ -92,10 +92,10 @@ def _tool_outcome_to_mcp_content_list(
 
         if isinstance(content_item, BinaryContent):
             if content_item.is_image:
-                content_block_list.append(mcp_types.ImageContent(type="image", data=content_item.base64, mimeType=content_item.media_type))
+                content_block_list.append(mcp_types.ImageContent(type="image", data=content_item.base64, mime_type=content_item.media_type))
                 continue
             if content_item.is_audio:
-                content_block_list.append(mcp_types.AudioContent(type="audio", data=content_item.base64, mimeType=content_item.media_type))
+                content_block_list.append(mcp_types.AudioContent(type="audio", data=content_item.base64, mime_type=content_item.media_type))
                 continue
             # Non-image / non-audio blobs project to text per spec §8.3:
             # MCP's rich transport only has first-class slots for image and

nighthawk/backends/mcp_server.py

@@ -15,7 +15,7 @@ import time
 from collections.abc import AsyncIterator, Awaitable, Callable
 from contextlib import asynccontextmanager
 from contextvars import copy_context
-from typing import Any
+from typing import Any, cast
 
 from opentelemetry import context as otel_context
 from pydantic_ai.exceptions import UnexpectedModelBehavior
@@ -62,20 +62,20 @@ class McpServer:
             raise RuntimeError("MCP tool server is already started")
 
         import uvicorn
-        from mcp.server.fastmcp.server import StreamableHTTPASGIApp
-        from mcp.server.lowlevel.server import Server as McpLowLevelServer
+        from mcp import types as mcp_types
+        from mcp.server import Server as McpLowLevelServer
+        from mcp.server import ServerRequestContext
         from mcp.server.streamable_http_manager import (
+            StreamableHTTPASGIApp,
             StreamableHTTPSessionManager,
         )
         from starlette.applications import Starlette
         from starlette.routing import Route
 
-        mcp_server = McpLowLevelServer("nighthawk")
-
-        @mcp_server.list_tools()
-        async def list_tools() -> list[Any]:
-            from mcp import types as mcp_types
-
+        async def list_tools(
+            _context: ServerRequestContext[Any, Any],
+            _parameters: mcp_types.PaginatedRequestParams | None,
+        ) -> mcp_types.ListToolsResult:
             tools: list[mcp_types.Tool] = []
             for tool_name in sorted(self._tool_name_to_handler.keys()):
                 tool_definition = self._tool_name_to_tool_definition.get(tool_name)
@@ -86,13 +86,17 @@ class McpServer:
                     mcp_types.Tool(
                         name=tool_name,
                         description=tool_definition.description or "",
-                        inputSchema=tool_definition.parameters_json_schema,
+                        input_schema=tool_definition.parameters_json_schema,
                     )
                 )
-            return tools
-
-        @mcp_server.call_tool(validate_input=False)
-        async def call_tool(name: str, arguments: dict[str, Any]) -> Any:
+            return mcp_types.ListToolsResult(tools=tools)
+
+        async def call_tool(
+            _context: ServerRequestContext[Any, Any],
+            parameters: mcp_types.CallToolRequestParams,
+        ) -> mcp_types.CallToolResult:
+            name = parameters.name
+            arguments = parameters.arguments or {}
             handler = self._tool_name_to_handler.get(name)
             if handler is None:
                 tool_outcome: ToolOutcome = {
@@ -100,19 +104,27 @@ class McpServer:
                     "error": {"kind": "resolution", "message": f"Unknown tool: {name}", "guidance": "Choose a visible tool name and retry."},
                 }
                 tool_handler_result: ToolHandlerResult = build_tool_result_observation(tool_outcome=tool_outcome)
-                return tool_handler_result_to_low_level_mcp_content(
+                content_block_list = tool_handler_result_to_low_level_mcp_content(
                     tool_name=name,
                     tool_handler_result=tool_handler_result,
                     rendering_policy=self._tool_result_rendering_policy,
                 )
+                return mcp_types.CallToolResult(content=cast(list[mcp_types.ContentBlock], content_block_list))
 
-            return await call_tool_for_low_level_mcp_server(
+            content_block_list = await call_tool_for_low_level_mcp_server(
                 tool_name=name,
                 arguments=arguments,
                 tool_handler=handler,
                 parent_otel_context=self._parent_otel_context,
                 rendering_policy=self._tool_result_rendering_policy,
             )
+            return mcp_types.CallToolResult(content=cast(list[mcp_types.ContentBlock], content_block_list))
+
+        mcp_server = McpLowLevelServer(
+            "nighthawk",
+            on_list_tools=list_tools,
+            on_call_tool=call_tool,
+        )
 
         session_manager = StreamableHTTPSessionManager(app=mcp_server)
         streamable_http_asgi = StreamableHTTPASGIApp(session_manager)

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

@@ -21,5 +21,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/natural/decorator.py

@@ -12,8 +12,7 @@ from typing import Any, cast
 from ..runtime.runner import Runner, StepEnvelope
 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]
@@ -239,33 +238,37 @@ def natural_function(func: NaturalFunctionCallable | None = None) -> NaturalFunc
 
     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")
 
     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 +277,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 +285,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")

nighthawk/natural/transform.py

@@ -326,11 +326,9 @@ def build_runtime_call_and_assignments(
         statements.extend(ast.parse(f'if "{name}" in __nh_bindings__:\n    {name} = __nh_bindings__["{name}"]\n').body)
 
     # Add outcome extraction and dispatch.
-    statements.extend(ast.parse('__nh_step_outcome__ = __nh_envelope__["step_outcome"]').body)
+    statements.extend(ast.parse('__nh_step_outcome__ = __nh_envelope__["outcome"]').body)
 
-    outcome_source = (
-        'if __nh_step_outcome__ is not None:\n    if __nh_step_outcome__.kind == "return":\n        return __nh_envelope__["return_value"]\n'
-    )
+    outcome_source = 'if __nh_step_outcome__ is not None:\n    if __nh_step_outcome__.kind == "return":\n        return __nh_step_outcome__.value\n'
     if is_in_loop:
         outcome_source += (
             '    if __nh_step_outcome__.kind == "break":\n        break\n    if __nh_step_outcome__.kind == "continue":\n        continue\n'