nighthawk-python 0.15.0__py3-none-any.whl → 0.16.0__py3-none-any.whl

nighthawk/composition.py

@@ -1,4 +1,4 @@
-"""Explicit inheritance and composition operations for execution scopes."""
+"""Omitted arguments and explicit collection composition operations."""
 
 from __future__ import annotations
 
@@ -30,7 +30,11 @@ class UnsetType:
 
 
 UNSET = UnsetType()
-"""Inherit the enclosing scope value; also marks omitted rewrite fields."""
+"""An omitted argument: use the receiving API's documented default behavior.
+
+Scopes inherit, runs create fresh resources, and rewrites retain the current field.
+Ordinary values, including empty collections, remain explicit values.
+"""
 
 
 @dataclass(frozen=True, init=False)

nighthawk/configuration.py

@@ -121,8 +121,9 @@ class StepExecutorConfiguration(BaseModel):
             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).
+        model_settings: Provider-specific overrides. Defaults to an empty dict;
+            accepts a dict or a backend-specific BaseModel (converted to dict).
+            None and UNSET are invalid. An empty dict preserves model-owned defaults.
         prompts: Prompt templates for step execution.
         context_limits: Token and item limits for context rendering.
         json_renderer_style: Headson rendering style for JSON summarization.
@@ -136,11 +137,11 @@ class StepExecutorConfiguration(BaseModel):
     model_config = ConfigDict(extra="forbid", frozen=True)
 
     model: str | InstanceOf[Model] = Field(default="openai-responses:gpt-5.6-luna", repr=False)
-    model_settings: dict[str, Any] | BaseModel | None = None
+    model_settings: dict[str, Any] | BaseModel = Field(default_factory=dict)
 
     @field_validator("model_settings", mode="before")
     @classmethod
-    def _normalize_model_settings(cls, value: Any) -> dict[str, Any] | None:
+    def _normalize_model_settings(cls, value: Any) -> dict[str, Any]:
         if isinstance(value, BaseModel):
             return value.model_dump()
         return value

nighthawk/function_call.py

@@ -10,8 +10,9 @@ from contextlib import contextmanager, nullcontext
 from contextvars import ContextVar
 from dataclasses import dataclass
 from types import MappingProxyType
-from typing import Any, Protocol
+from typing import Any, Protocol, runtime_checkable
 
+from .composition import UNSET, UnsetType
 from .configuration import ModelSelection
 from .errors import NighthawkError
 from .natural.definition import NaturalFunctionDefinition
@@ -31,6 +32,7 @@ class FunctionCall:
     model_selection: ModelSelection | None
 
 
+@runtime_checkable
 class FunctionCallHandler(Protocol):
     """Application-owned admission, grouping, and observation of function calls."""
 
@@ -48,9 +50,19 @@ _call: ContextVar[FunctionCall | None] = ContextVar("nighthawk_function_call", d
 
 
 @contextmanager
-def function_call_scope(handler: FunctionCallHandler | None) -> Iterator[None]:
-    """Install or explicitly clear interception independently of executor runs."""
-    token = _handler.set(handler)
+def function_call_scope(handler: FunctionCallHandler | None | UnsetType = UNSET) -> Iterator[None]:
+    """Inherit, replace, or clear interception independently of executor runs.
+
+    Omission or UNSET inherits; None clears; a handler replaces the current one.
+    Invalid handlers fail before context installation.
+    """
+    if (
+        not isinstance(handler, UnsetType)
+        and handler is not None
+        and (not isinstance(handler, FunctionCallHandler) or not callable(handler.invoke) or not callable(handler.invoke_async))
+    ):
+        raise TypeError("handler must implement FunctionCallHandler, be None, or be UNSET")
+    token = _handler.set(_handler.get() if isinstance(handler, UnsetType) else handler)
     try:
         yield
     finally:

nighthawk/oversight.py

@@ -81,11 +81,12 @@ class Reject:
 
 @dataclass(frozen=True)
 class Rewrite:
-    """Replace supplied commit fields; UNSET inherits and Return(None) returns None.
+    """Replace supplied commit fields; UNSET retains and Return(None) returns None.
 
     A mapping replaces all writes. Use outcome=Return(value=...) to supply
     a new return value or change another allowed outcome into a return.
     Replacements are validated before commit without replaying return expressions.
+    A resolved Raise cannot be paired with an explicit nonempty output mapping.
     """
 
     outcome: StepResult | UnsetType = UNSET
@@ -96,11 +97,13 @@ class Rewrite:
         if not isinstance(self.outcome, (UnsetType, Pass, Return, Break, Continue, Raise)):
             raise TypeError("Rewrite outcome must be a resolved StepResult or UNSET")
         if not isinstance(self.binding_name_to_value, UnsetType):
-            if not isinstance(self.binding_name_to_value, Mapping):
-                raise TypeError("Rewrite binding_name_to_value must be a mapping or UNSET")
+            if not isinstance(self.binding_name_to_value, Mapping) or any(not isinstance(name, str) for name in self.binding_name_to_value):
+                raise TypeError("Rewrite binding_name_to_value must be a string-keyed mapping or UNSET")
             object.__setattr__(self, "binding_name_to_value", _reference_mapping(self.binding_name_to_value))
         if self.outcome is UNSET and self.binding_name_to_value is UNSET:
             raise ValueError("Rewrite must change outcome or binding_name_to_value")
+        if isinstance(self.outcome, Raise) and not isinstance(self.binding_name_to_value, UnsetType) and len(self.binding_name_to_value):
+            raise ValueError("Rewrite Raise cannot include output bindings")
 
 
 type StepCommitDecision = Accept | Reject | Rewrite

nighthawk/runtime/environment.py

@@ -5,13 +5,21 @@ from __future__ import annotations
 from collections.abc import Iterator, Mapping
 from dataclasses import dataclass
 from types import CellType, MappingProxyType
-from typing import Literal
+from typing import Literal, Never
 
 from .bindings import MISSING_ANNOTATION
 from .description import annotation_text
 from .discovery import DiscoveryResult, page_names
 
-type EnvironmentSource = Literal["effective", "python", "parent", "task", "step"]
+type EnvironmentSource = Literal["effective", "python", "task", "step"]
+
+_EMPTY_NAME_TO_VALUE: Mapping[str, Never] = MappingProxyType({})
+
+
+def _copy_name_to_value[T](name_to_value: Mapping[str, T], parameter: str) -> dict[str, T]:
+    if not isinstance(name_to_value, Mapping) or any(not isinstance(name, str) for name in name_to_value):
+        raise TypeError(f"{parameter} must be a string-keyed mapping")
+    return dict(name_to_value)
 
 
 class MissingEnvironmentNameError(NameError):
@@ -63,6 +71,16 @@ class _ExpressionNamespace(dict[str, object]):
             return self._override_name_to_value[name]
         return self._environment.resolve(name)
 
+    def __contains__(self, name: object) -> bool:
+        # Python 3.14 forward references check membership before looking up a name.
+        if not isinstance(name, str):
+            return False
+        try:
+            self[name]
+        except MissingEnvironmentNameError:
+            return False
+        return True
+
 
 @dataclass(frozen=True)
 class _RuntimeAccess:
@@ -78,7 +96,7 @@ class _RuntimeAccess:
 class StepEnvironment:
     """Read-only environment views with a separate, tracked working namespace.
 
-    Parent membership and object associations are captured at entry.
+    Python working associations and scoped task references are captured at entry.
     Application values remain live; the views do not freeze their object graphs.
     """
 
@@ -88,28 +106,29 @@ class StepEnvironment:
         python_name_to_value: Mapping[str, object],
         python_globals: dict[str, object],
         local_name_set: frozenset[str] = frozenset(),
-        python_name_to_cell: Mapping[str, CellType] | None = None,
-        parent_name_to_value: Mapping[str, object] | None = None,
-        task_name_to_value: Mapping[str, object] | None = None,
+        python_name_to_cell: Mapping[str, CellType] = _EMPTY_NAME_TO_VALUE,
+        task_name_to_value: Mapping[str, object] = _EMPTY_NAME_TO_VALUE,
         output_name_set: frozenset[str] = frozenset(),
-        binding_name_to_annotation: Mapping[str, object] | None = None,
-        binding_name_to_type: Mapping[str, object] | None = None,
+        binding_name_to_annotation: Mapping[str, object] = _EMPTY_NAME_TO_VALUE,
+        binding_name_to_type: Mapping[str, object] = _EMPTY_NAME_TO_VALUE,
         runtime_name_set: frozenset[str] = frozenset(),
     ) -> None:
+        python_name_to_value = _copy_name_to_value(python_name_to_value, "python_name_to_value")
+        if not isinstance(python_globals, dict) or any(not isinstance(name, str) for name in python_globals):
+            raise TypeError("python_globals must be a string-keyed dict")
         self._runtime_name_set = frozenset(runtime_name_set)
         self._python_name_to_value = {name: value for name, value in python_name_to_value.items() if not self._is_runtime_name(name)}
         self._python_global_name_to_value = python_globals
         builtins_value = python_globals.get("__builtins__", __builtins__)
         self._python_builtin_name_to_value: dict[str, object] = builtins_value if isinstance(builtins_value, dict) else vars(builtins_value)
         self._local_name_set = local_name_set
-        self._python_name_to_cell = dict(python_name_to_cell or {})
+        self._python_name_to_cell = _copy_name_to_value(python_name_to_cell, "python_name_to_cell")
         self._output_name_set = output_name_set
         self._step_name_to_value: dict[str, object] = {}
-        self._binding_name_to_annotation = dict(binding_name_to_annotation or {})
-        self._binding_name_to_type = dict(binding_name_to_type or {})
+        self._binding_name_to_annotation = _copy_name_to_value(binding_name_to_annotation, "binding_name_to_annotation")
+        self._binding_name_to_type = _copy_name_to_value(binding_name_to_type, "binding_name_to_type")
         self.python_name_to_value: Mapping[str, object] = _PythonEnvironmentView(self)
-        self.parent_name_to_value = MappingProxyType(dict(parent_name_to_value or {}))
-        self.task_name_to_value = MappingProxyType(dict(task_name_to_value or {}))
+        self.task_name_to_value = MappingProxyType(_copy_name_to_value(task_name_to_value, "task_name_to_value"))
         self.step_name_to_value = MappingProxyType(self._step_name_to_value)
         known_names = (
             python_name_to_value.keys()
@@ -117,7 +136,6 @@ class StepEnvironment:
             | self._python_builtin_name_to_value.keys()
             | self._local_name_set
             | self._python_name_to_cell.keys()
-            | self.parent_name_to_value.keys()
             | self.task_name_to_value.keys()
             | self._runtime_name_set
         )
@@ -166,7 +184,6 @@ class StepEnvironment:
         source_to_name_to_value = {
             "step": self.step_name_to_value,
             "python": self.python_name_to_value,
-            "parent": self.parent_name_to_value,
             "task": self.task_name_to_value,
         }
         if source != "effective" and source not in source_to_name_to_value:
@@ -188,19 +205,25 @@ class StepEnvironment:
         self._step_name_to_value[name] = value
 
     def snapshot_working_state(self) -> dict[str, object]:
-        snapshot = dict(self.parent_name_to_value)
+        """Copy this step's bound working names for explicit application-owned sharing.
+
+        Include Python locals, live cells, and tracked assignments.
+        Exclude module globals, builtins, scoped task references, and runtime names.
+        Referenced objects retain identity; the returned mapping is independent.
+        """
+        name_to_value: dict[str, object] = {}
         for name in self._python_name_to_value.keys() | self._local_name_set | self._python_name_to_cell.keys():
             if self._is_runtime_name(name):
                 continue
             try:
-                snapshot[name] = self._resolve_python(name)
+                name_to_value[name] = self._resolve_python(name)
             except (KeyError, UnboundLocalError):
-                snapshot.pop(name, None)
-        snapshot.update(self.step_name_to_value)
-        return snapshot
+                continue
+        name_to_value.update(self.step_name_to_value)
+        return name_to_value
 
-    def expression_namespace(self, overrides: Mapping[str, object] | None = None) -> dict[str, object]:
-        return _ExpressionNamespace(self, overrides or {})
+    def expression_namespace(self, overrides: Mapping[str, object] = _EMPTY_NAME_TO_VALUE) -> dict[str, object]:
+        return _ExpressionNamespace(self, _copy_name_to_value(overrides, "overrides"))
 
     def reference(self, name: str, *, source: EnvironmentSource = "effective") -> str:
         """Return a Python expression resolving this binding when evaluated."""
@@ -208,18 +231,17 @@ class StepEnvironment:
 
     def discover(self, *, source: EnvironmentSource = "effective", cursor: str | None = None, max_items: int = 8) -> dict[str, object]:
         """List names with provenance, usable references, and progressing pages."""
-        source_to_view = {
+        source_to_name_to_value = {
             "python": self.python_name_to_value,
-            "parent": self.parent_name_to_value,
             "task": self.task_name_to_value,
             "step": self.step_name_to_value,
         }
-        if source != "effective" and source not in source_to_view:
-            return {"error": "Unknown source", "recovery": "Choose effective, python, parent, task, or step."}
+        if source != "effective" and source not in source_to_name_to_value:
+            return {"error": "Unknown source", "recovery": "Choose effective, python, task, or step."}
         names = (
-            tuple(sorted(set().union(*[set(view) for view in source_to_view.values()])))
+            tuple(sorted(set().union(*[set(view) for view in source_to_name_to_value.values()])))
             if source == "effective"
-            else tuple(sorted(source_to_view[source]))
+            else tuple(sorted(source_to_name_to_value[source]))
         )
         page = page_names(names, source=source, cursor=cursor, max_items=max_items)
         if page.error is not None:
@@ -244,7 +266,6 @@ class StepEnvironment:
             for source, view in (
                 ("step", self.step_name_to_value),
                 ("python", self.python_name_to_value),
-                ("parent", self.parent_name_to_value),
                 ("task", self.task_name_to_value),
             )
             if name in view

nighthawk/runtime/expression.py

@@ -38,7 +38,7 @@ async def evaluate_compiled_expression(
     allow_awaitable_result: bool = True,
     override_name_to_value: Mapping[str, object] | None = None,
 ) -> object:
-    namespace = step_context.environment.expression_namespace(override_name_to_value)
+    namespace = step_context.environment.expression_namespace({} if override_name_to_value is None else override_name_to_value)
     try:
         value = eval(compiled, namespace, namespace)
         if inspect.isawaitable(value):

nighthawk/runtime/model_candidate.py

@@ -2,6 +2,7 @@
 
 from collections.abc import Mapping
 
+from ..composition import UNSET, UnsetType
 from ..errors import ExecutionError
 from .expression import evaluate_expression_operation
 from .operation_contract import OperationError
@@ -13,14 +14,21 @@ from .step_result import Break, Continue, Pass, Raise, Return, StepResult
 async def resolve_model_candidate(
     request: StepRequest,
     outcome: StepOutcome,
-    binding_name_to_value: Mapping[str, object],
+    binding_name_to_value: Mapping[str, object] | UnsetType = UNSET,
 ) -> StepCandidate:
     """Resolve a provider response once; leave commit validation to the runner."""
     if outcome.kind not in request.allowed_step_kinds:
         raise ExecutionError(f"Step '{outcome.kind}' is not allowed for this step. Allowed kinds: {request.allowed_step_kinds}")
-    undeclared = binding_name_to_value.keys() - set(request.output_binding_names)
+    if not isinstance(binding_name_to_value, UnsetType) and (
+        not isinstance(binding_name_to_value, Mapping) or any(not isinstance(name, str) for name in binding_name_to_value)
+    ):
+        raise TypeError("binding_name_to_value must be a string-keyed mapping or UNSET")
+    supplied_name_to_value = {} if isinstance(binding_name_to_value, UnsetType) else dict(binding_name_to_value)
+    undeclared = supplied_name_to_value.keys() - set(request.output_binding_names)
     if undeclared:
         raise ExecutionError(f"Undeclared output binding names: {sorted(undeclared)}")
+    if isinstance(outcome, RaiseStepOutcome) and supplied_name_to_value:
+        raise ExecutionError("Raise cannot include output bindings")
     resolved: StepResult
     if isinstance(outcome, ReturnStepOutcome):
         value = await evaluate_expression_operation(
@@ -29,7 +37,7 @@ async def resolve_model_candidate(
             purpose="return",
             allow_awaitable_result=request.allow_awaitable_return,
             expected_type=request.return_annotation,
-            override_name_to_value=binding_name_to_value,
+            override_name_to_value=supplied_name_to_value,
         )
         resolved = Return(value)
     elif isinstance(outcome, RaiseStepOutcome):
@@ -46,4 +54,4 @@ async def resolve_model_candidate(
         resolved = Raise(outcome.raise_message, error_type)
     else:
         resolved = {"pass": Pass, "break": Break, "continue": Continue}[outcome.kind]()
-    return StepCandidate(outcome=resolved, binding_name_to_value=binding_name_to_value)
+    return StepCandidate(outcome=resolved, binding_name_to_value=UNSET if isinstance(binding_name_to_value, UnsetType) else supplied_name_to_value)

nighthawk/runtime/preparation.py

@@ -13,7 +13,7 @@ from .bindings import MISSING_ANNOTATION, infer_binding_types, normalize_binding
 from .description import discover_type_alias_reference_names
 from .environment import StepEnvironment
 from .scoping import _current_task_references, get_execution_reference
-from .step_context import StepContext, ToolResultRenderingPolicy, get_python_cell_scope_stack, get_step_context_stack
+from .step_context import StepContext, ToolResultRenderingPolicy, get_python_cell_scope_stack
 from .step_contract import StepKind
 from .step_executor import StepExecutor
 
@@ -85,8 +85,6 @@ class StepPreparation:
         python_locals = caller_frame.f_locals
         python_globals = caller_frame.f_globals
         step_locals = {name: value for name, value in python_locals.items() if name not in self.runtime_name_set}
-        parent_stack = get_step_context_stack()
-        parent_name_to_value = parent_stack[-1].environment.snapshot_working_state() if parent_stack else {}
         cell_scope_stack = get_python_cell_scope_stack()
         python_name_to_cell = cell_scope_stack[-1] if cell_scope_stack else {}
 
@@ -119,7 +117,6 @@ class StepPreparation:
             python_globals=python_globals,
             local_name_set=frozenset(local_name_set),
             python_name_to_cell=python_name_to_cell,
-            parent_name_to_value=parent_name_to_value,
             task_name_to_value=scoped_task_name_to_value,
             output_name_set=frozenset(output_binding_names),
             binding_name_to_annotation=binding_name_to_annotation,

nighthawk/runtime/prompt.py

@@ -452,12 +452,7 @@ def _collect_explicit_multimodal_reference_and_value_list(
             continue
 
         root_reference = reference_path.split(".", 1)[0]
-        local_names = (
-            step_context.step_locals.keys()
-            | step_context.environment.parent_name_to_value.keys()
-            | step_context.environment.step_name_to_value.keys()
-            | step_context.binding_commit_targets
-        )
+        local_names = step_context.step_locals.keys() | step_context.environment.step_name_to_value.keys() | step_context.binding_commit_targets
         if (root_reference in local_names) != include_locals:
             continue
 
@@ -553,7 +548,6 @@ def _render_globals_section(
     for reference in sorted(references):
         if (
             reference in step_context.step_locals
-            or reference in step_context.environment.parent_name_to_value
             or reference in step_context.environment.step_name_to_value
             or reference in step_context.binding_commit_targets
         ):
@@ -695,10 +689,7 @@ def _build_user_prompt_content(
 
     locals_content = _render_locals_section(
         step_context=step_context,
-        references=step_context.step_locals.keys()
-        | step_context.environment.parent_name_to_value.keys()
-        | step_context.environment.step_name_to_value.keys()
-        | step_context.binding_commit_targets,
+        references=step_context.step_locals.keys() | step_context.environment.step_name_to_value.keys() | step_context.binding_commit_targets,
         explicit_reference_paths=explicit_reference_paths,
         render_context=render_context,
     )
@@ -728,12 +719,7 @@ def _build_user_prompt_content(
         "Displayed annotations are best-effort metadata and may be unresolved source spelling; they are not evaluated for presentation.",
     ]
     relevant_names = (
-        set(references)
-        | step_context.binding_commit_targets
-        | set(step_context.step_locals)
-        | set(environment.parent_name_to_value)
-        | set(environment.task_name_to_value)
-        | {"inspect"}
+        set(references) | step_context.binding_commit_targets | set(step_context.step_locals) | set(environment.task_name_to_value) | {"inspect"}
     )
     collision_names = [
         name

nighthawk/runtime/runner.py

@@ -24,7 +24,6 @@ from ..oversight import (
 )
 from .async_bridge import run_coroutine_synchronously
 from .bindings import BindingValidationError, require_declared_binding_names, validate_output_bindings
-from .environment import UnboundEnvironmentNameError
 from .execution_reference import ExecutionReference
 from .interruption import chain_cleanup_errors
 from .notifications import await_notification
@@ -45,7 +44,7 @@ from .step_context import (
 )
 from .step_contract import StepKind
 from .step_executor import AsyncStepExecutor, StepExecutor, SyncStepExecutor
-from .step_request import StepCandidate, StepRequest
+from .step_request import StepCandidate, StepRequest, _snapshot_output_bindings
 from .step_result import Break, Continue, Pass, Raise, Return, StepResult
 
 
@@ -301,22 +300,19 @@ class Runner:
         *,
         preparation: PreparedStep,
         step_outcome: StepResult,
-        bindings: dict[str, object],
+        bindings: Mapping[str, object] | UnsetType,
     ) -> dict[str, object]:
-        require_declared_binding_names(bindings, preparation.output_binding_names)
+        if not isinstance(bindings, UnsetType):
+            require_declared_binding_names(bindings, preparation.output_binding_names)
         if step_outcome.kind == "raise":
+            if not isinstance(bindings, UnsetType) and len(bindings):
+                raise NighthawkError("StepCandidate Raise cannot include output bindings")
             return {}
-        environment = preparation.step_context.environment
-        selected_binding_name_to_value: dict[str, object] = {}
-        for name in preparation.output_binding_names:
-            if name in environment.step_name_to_value:
-                selected_binding_name_to_value[name] = environment.step_name_to_value[name]
-                continue
-            try:
-                selected_binding_name_to_value[name] = environment.python_name_to_value[name]
-            except (KeyError, UnboundEnvironmentNameError):
-                continue
-        selected_binding_name_to_value.update(bindings)
+        selected_binding_name_to_value = (
+            _snapshot_output_bindings(preparation.step_context.environment, preparation.output_binding_names)
+            if isinstance(bindings, UnsetType)
+            else dict(bindings)
+        )
         return self._validate_and_coerce_output_bindings(preparation=preparation, bindings=selected_binding_name_to_value)
 
     async def _apply_step_oversight_if_needed(
@@ -403,14 +399,13 @@ class Runner:
         if not isinstance(candidate, StepCandidate):
             raise ExecutionError("Step executor must return StepCandidate")
         step_outcome = candidate.outcome
-        bindings = dict(candidate.binding_name_to_value)
         self.attempted_outcome = step_outcome
         self._require_allowed_step_kind(step_outcome=step_outcome, allowed_step_kinds=preparation.allowed_step_kinds)
         self.failure_stage = "binding_validation"
         validated_bindings = self._validate_bindings_for_outcome(
             preparation=preparation,
             step_outcome=step_outcome,
-            bindings=bindings,
+            bindings=candidate.binding_name_to_value,
         )
         self.validated_binding_name_to_value = validated_bindings
         outcome = step_outcome

nighthawk/runtime/scoping.py

@@ -334,7 +334,7 @@ def _validate_step_executor(step_executor: object) -> None:
 def run(
     step_executor: StepExecutor,
     *,
-    run_id: str | None = None,
+    run_id: str | UnsetType = UNSET,
     usage_meter: UsageMeter | UnsetType = UNSET,
 ) -> Iterator[None]:
     """Start an execution run with the given step executor.
@@ -344,8 +344,8 @@ def run(
 
     Args:
         step_executor: The step executor to use for Natural block execution.
-        run_id: Optional identifier for the run. If not provided, a ULID is
-            generated automatically.
+        run_id: Nonempty identifier for the run. Omission or UNSET generates
+            a fresh ULID. None and empty strings are invalid.
         usage_meter: Optional meter that accumulates LLM usage for the run.
             If not provided, a fresh :class:`UsageMeter` is created.
 
@@ -356,8 +356,12 @@ def run(
         TypeError: If the executor does not implement either execution protocol or the usage meter is invalid.
     """
     _validate_step_executor(step_executor)
+    if not isinstance(run_id, (str, UnsetType)):
+        raise TypeError("run_id must be a nonempty string or UNSET")
+    if isinstance(run_id, str) and not run_id:
+        raise ValueError("run_id must not be empty")
     execution_reference = ExecutionReference(
-        run_id=run_id or generate_ulid(),
+        run_id=generate_ulid() if isinstance(run_id, UnsetType) else run_id,
         scope_id=generate_ulid(),
         step_execution_id=None,
         source_location=None,
@@ -434,6 +438,7 @@ def scope(
     installing context. Executor replacement precedes delegated model selection.
     model replaces only the model; step_executor_configuration replaces all configuration
     fields. Supplying both is invalid. Selection preserves unrelated scoped controls.
+    A new scope retains the active step identity and its source location.
     """
     from ..lifecycle import StepLifecycle
     from ..oversight import Oversight
@@ -455,9 +460,7 @@ def scope(
         raise TypeError("lifecycle must be StepLifecycle, None, or UNSET")
     next_step_executor = current_step_executor if isinstance(step_executor, UnsetType) else step_executor
     selection = _model_selection(model, step_executor_configuration)
-    if selection is not None:
-        next_step_executor = _resolve_model_selection(next_step_executor, selection)
-    next_execution_reference = replace(current_execution_reference, scope_id=generate_ulid(), step_execution_id=None, source_location=None)
+    next_execution_reference = replace(current_execution_reference, scope_id=generate_ulid())
     next_usage_meter = get_usage_meter() if isinstance(usage_meter, UnsetType) else usage_meter
     next_oversight = _oversight_var.get() if isinstance(oversight, UnsetType) else oversight
     next_system_prompt_suffix_fragments = _compose_sequence(_system_prompt_suffix_fragments_var.get(), system_prompt_suffix_fragments)
@@ -481,6 +484,9 @@ def scope(
         entries = _compose_sequence((), tools)
         next_tools = resolve_scoped_tools((), entries)
 
+    if selection is not None:
+        next_step_executor = _resolve_model_selection(next_step_executor, selection)
+
     step_executor_token = _step_executor_var.set(next_step_executor)
     execution_reference_token = _execution_reference_var.set(next_execution_reference)
     usage_meter_token = _usage_meter_var.set(next_usage_meter)

nighthawk/runtime/step_context.py

@@ -46,7 +46,8 @@ class StepContext:
 
     ``environment`` owns effective lookup and tracked step assignments.
     Use :meth:`record_assignment` or the common assignment operations to keep that environment and ``step_locals`` bookkeeping consistent.
-    Revision and mutation marks describe tracked changes; finalization independently validates all initialized declared outputs, with explicit candidate proposals taking precedence.
+    Revision and mutation marks describe tracked changes.
+    Finalization validates initialized declared outputs when the candidate omits its output selection; an explicit mapping supplies the complete selection.
     """
 
     execution_reference: ExecutionReference
@@ -139,10 +140,6 @@ def python_cell_scope(name_to_cell: dict[str, CellType]) -> Iterator[None]:
         _python_lookup_state_var.reset(token)
 
 
-def get_step_context_stack() -> tuple[StepContext, ...]:
-    return _step_context_stack_var.get()
-
-
 def get_python_cell_scope_stack() -> tuple[dict[str, CellType], ...]:
     return _python_lookup_state_var.get().python_cell_scope_stack
 

nighthawk/runtime/step_executor.py

@@ -7,8 +7,10 @@ from pydantic_ai import Agent, RunContext, StructuredDict
 from pydantic_ai.capabilities import AbstractCapability
 from pydantic_ai.messages import UserContent
 from pydantic_ai.models import ModelRequestContext
+from pydantic_ai.settings import ModelSettings
 from pydantic_ai.toolsets.function import FunctionToolset
 
+from ..composition import UNSET, UnsetType
 from ..configuration import ModelSelection, StepExecutorConfiguration
 from ..errors import ExecutionError, NighthawkError
 from ..tools._admission import ToolAdmissionCapability
@@ -125,10 +127,6 @@ def _new_agent_step_executor(
             case _:
                 model = model_identifier
 
-    constructor_arguments: dict[str, Any] = {}
-    if configuration.model_settings is not None:
-        constructor_arguments["model_settings"] = configuration.model_settings
-
     system_prompt_text = build_system_prompt(configuration=configuration)
 
     agent = Agent(
@@ -136,7 +134,7 @@ def _new_agent_step_executor(
         output_type=StepFinalResult,
         deps_type=StepContext,
         system_prompt=system_prompt_text,
-        **constructor_arguments,
+        model_settings=cast(ModelSettings, configuration.model_settings),
     )
 
     @agent.system_prompt(dynamic=True)
@@ -173,10 +171,14 @@ class AgentStepExecutor:
 
     def __init__(
         self,
-        configuration: StepExecutorConfiguration | None = None,
+        configuration: StepExecutorConfiguration | UnsetType = UNSET,
         agent: StepExecutionAgent | None = None,
     ) -> None:
-        self.configuration = configuration or StepExecutorConfiguration()
+        if not isinstance(configuration, (StepExecutorConfiguration, UnsetType)):
+            raise TypeError("configuration must be StepExecutorConfiguration or UNSET")
+        if agent is not None and not isinstance(agent, (AsyncExecutionAgent, SyncExecutionAgent)):
+            raise TypeError("agent must implement the synchronous or asynchronous agent protocol")
+        self.configuration = StepExecutorConfiguration() if isinstance(configuration, UnsetType) else configuration
         if agent is not None and not isinstance(self.configuration.model, str):
             raise NighthawkError("The external agent owns model selection; configuration.model must be a string")
         self.agent_is_managed = agent is None
@@ -193,15 +195,17 @@ class AgentStepExecutor:
         cls,
         *,
         agent: StepExecutionAgent,
-        configuration: StepExecutorConfiguration | None = None,
+        configuration: StepExecutorConfiguration | UnsetType = UNSET,
     ) -> AgentStepExecutor:
         """Create an executor wrapping an existing agent.
 
         Args:
             agent: A pre-configured agent to use for step execution.
-            configuration: Optional configuration. Defaults to
-                StepExecutorConfiguration().
+            configuration: Omission or UNSET creates StepExecutorConfiguration().
+                None and raw dictionaries are invalid; parse configuration data explicitly.
         """
+        if not isinstance(agent, (AsyncExecutionAgent, SyncExecutionAgent)):
+            raise TypeError("agent must implement the synchronous or asynchronous agent protocol")
         return cls(configuration=configuration, agent=agent)
 
     @classmethod
@@ -211,6 +215,8 @@ class AgentStepExecutor:
         configuration: StepExecutorConfiguration,
     ) -> AgentStepExecutor:
         """Create an executor from a configuration, building a managed agent internally."""
+        if not isinstance(configuration, StepExecutorConfiguration):
+            raise TypeError("configuration must be StepExecutorConfiguration")
         return cls(configuration=configuration)
 
     def resolve_model_selection(self, selection: ModelSelection) -> StepExecutor:
@@ -374,7 +380,7 @@ class AgentStepExecutor:
             usage_meter.record(result.usage, kind="step")
 
         step_outcome = self._parse_agent_result(result)
-        return await resolve_model_candidate(request, step_outcome, {})
+        return await resolve_model_candidate(request, step_outcome)
 
     def run_step(
         self,

nighthawk/runtime/step_request.py

@@ -1,14 +1,29 @@
 """Frozen executor contracts containing live application values."""
 
-from collections.abc import Mapping
+from collections.abc import Mapping, Sequence
 from types import MappingProxyType
 
-from pydantic import BaseModel, ConfigDict, Field, InstanceOf, field_validator, model_validator
+from pydantic import BaseModel, ConfigDict, InstanceOf, field_validator, model_validator
 
+from ..composition import UNSET, UnsetType
+from .environment import StepEnvironment, UnboundEnvironmentNameError
 from .execution_reference import ExecutionReference
 from .step_context import StepContext
 from .step_contract import StepKind
-from .step_result import StepResult
+from .step_result import Raise, StepResult
+
+
+def _snapshot_output_bindings(environment: StepEnvironment, output_binding_names: Sequence[str]) -> dict[str, object]:
+    binding_name_to_value: dict[str, object] = {}
+    for name in output_binding_names:
+        if name in environment.step_name_to_value:
+            binding_name_to_value[name] = environment.step_name_to_value[name]
+            continue
+        try:
+            binding_name_to_value[name] = environment.python_name_to_value[name]
+        except (KeyError, UnboundEnvironmentNameError):
+            continue
+    return binding_name_to_value
 
 
 class StepRequest(BaseModel):
@@ -29,6 +44,17 @@ class StepRequest(BaseModel):
     allowed_step_kinds: tuple[StepKind, ...]
     allow_awaitable_return: bool = False
 
+    def snapshot_output_bindings(self) -> dict[str, object]:
+        """Snapshot initialized declared outputs in declaration order.
+
+        Tracked assignments precede current Python values, including live globals and cells.
+        Unbound names and task-only references are excluded.
+        The dictionary is independent; values retain identity.
+        This neither validates nor writes values.
+        Later working changes do not change its name associations.
+        """
+        return _snapshot_output_bindings(self.step_context.environment, self.output_binding_names)
+
     @field_validator("binding_name_to_type", mode="after")
     @classmethod
     def freeze_contracts(cls, value: Mapping[str, object]) -> Mapping[str, object]:
@@ -48,14 +74,26 @@ class StepRequest(BaseModel):
 
 
 class StepCandidate(BaseModel):
-    """Resolved control flow and proposed writes, pending runtime finalization."""
+    """Resolved control flow and output selection, pending runtime validation.
+
+    Omission or UNSET selects initialized declared outputs at finalization.
+    A mapping supplies the entire output selection; {} selects no writes.
+    Explicit selections receive no supplementation from the working environment.
+    Raise permits only omitted or empty outputs.
+    """
 
     model_config = ConfigDict(frozen=True, arbitrary_types_allowed=True, extra="forbid", validate_default=True)
 
     outcome: StepResult
-    binding_name_to_value: Mapping[str, object] = Field(default_factory=dict)
+    binding_name_to_value: Mapping[str, object] | UnsetType = UNSET
 
     @field_validator("binding_name_to_value", mode="after")
     @classmethod
-    def preserve_live_values(cls, value: Mapping[str, object]) -> Mapping[str, object]:
-        return MappingProxyType(dict(value))
+    def preserve_live_values(cls, value: Mapping[str, object] | UnsetType) -> Mapping[str, object] | UnsetType:
+        return value if isinstance(value, UnsetType) else MappingProxyType(dict(value))
+
+    @model_validator(mode="after")
+    def validate_output_selection(self) -> "StepCandidate":
+        if isinstance(self.outcome, Raise) and not isinstance(self.binding_name_to_value, UnsetType) and len(self.binding_name_to_value):
+            raise ValueError("StepCandidate Raise cannot include output bindings")
+        return self

nighthawk/testing.py

@@ -6,9 +6,12 @@ deterministic tests of Natural functions without LLM API calls.
 
 from __future__ import annotations
 
-from collections.abc import Callable
-from dataclasses import dataclass, field
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
 
+from pydantic import Field
+
+from .composition import UNSET, UnsetType
 from .runtime.execution_reference import ExecutionReference
 from .runtime.step_context import StepContext
 from .runtime.step_contract import StepKind
@@ -42,20 +45,19 @@ class StepCall:
     step_locals: dict[str, object]
     step_globals: dict[str, object]
     task_name_to_value: dict[str, object]
-    parent_name_to_value: dict[str, object]
 
 
-@dataclass
-class StepResponse:
+class StepResponse(StepCandidate):
     """Scripted response for a single Natural block execution.
 
     Attributes:
-        bindings: Proposed output values. Undeclared names fail finalization.
+        binding_name_to_value: Complete output selection.
+            Omission or UNSET selects initialized declared outputs; {} selects no writes.
+            Undeclared names fail finalization.
         outcome: Resolved Python control result. Strings are values, never expressions.
     """
 
-    bindings: dict[str, object] = field(default_factory=dict)
-    outcome: StepResult = field(default_factory=Pass)
+    outcome: StepResult = Field(default_factory=Pass)
 
 
 def _build_step_call(
@@ -67,7 +69,7 @@ def _build_step_call(
     referenced_global_names = (
         step_context.read_binding_names | (set(step_context.environment.task_name_to_value) | step_context.type_alias_reference_names)
     ) - step_context.step_locals.keys()
-    filtered_globals = {name: step_context.step_globals[name] for name in referenced_global_names if name in step_context.step_globals}
+    global_name_to_value = {name: step_context.step_globals[name] for name in referenced_global_names if name in step_context.step_globals}
     return StepCall(
         execution_reference=step_context.execution_reference,
         natural_program=processed_natural_program,
@@ -75,9 +77,8 @@ def _build_step_call(
         binding_name_to_type=dict(step_context.binding_name_to_type),
         allowed_step_kinds=allowed_step_kinds,
         step_locals=dict(step_context.step_locals),
-        step_globals=filtered_globals,
+        step_globals=global_name_to_value,
         task_name_to_value=dict(step_context.environment.task_name_to_value),
-        parent_name_to_value=dict(step_context.environment.parent_name_to_value),
     )
 
 
@@ -117,7 +118,7 @@ class ScriptedExecutor:
                 f"{len(self.responses)} responses were supplied. "
                 "Supply another response or an explicit default_response."
             )
-        return StepCandidate(outcome=response.outcome, binding_name_to_value=response.bindings)
+        return response
 
     async def run_step_async(
         self,
@@ -148,7 +149,7 @@ class CallbackExecutor:
         )
         self.calls.append(call)
         response = self.handler(call)
-        return StepCandidate(outcome=response.outcome, binding_name_to_value=response.bindings)
+        return response
 
     async def run_step_async(
         self,
@@ -158,9 +159,9 @@ class CallbackExecutor:
         return self.run_step(request=request)
 
 
-def pass_response(**bindings: object) -> StepResponse:
-    """Create a response with pass outcome and optional binding values."""
-    return StepResponse(bindings=bindings)
+def pass_response(*, binding_name_to_value: Mapping[str, object] | UnsetType = UNSET) -> StepResponse:
+    """Continue with automatic output selection, or an explicit complete mapping."""
+    return StepResponse(binding_name_to_value=binding_name_to_value)
 
 
 def raise_response(message: str, *, error_type: type[BaseException] = Exception) -> StepResponse:
@@ -176,21 +177,22 @@ def raise_response(message: str, *, error_type: type[BaseException] = Exception)
     return StepResponse(outcome=Raise(message, error_type))
 
 
-def return_response(value: object, /, **bindings: object) -> StepResponse:
+def return_response(value: object, /, *, binding_name_to_value: Mapping[str, object] | UnsetType = UNSET) -> StepResponse:
     """Return a Python value subject to the Natural function's return contract.
 
     Args:
         value: Resolved value; strings are returned literally without evaluation.
-        **bindings: Proposed output values, independently validated at finalization.
+        binding_name_to_value: Complete output selection; omission or UNSET selects initialized declared outputs.
+            {} selects no writes.
     """
-    return StepResponse(bindings=bindings, outcome=Return(value))
+    return StepResponse(binding_name_to_value=binding_name_to_value, outcome=Return(value))
 
 
-def break_response() -> StepResponse:
+def break_response(*, binding_name_to_value: Mapping[str, object] | UnsetType = UNSET) -> StepResponse:
     """Create a response with break outcome (exit enclosing loop)."""
-    return StepResponse(outcome=Break())
+    return StepResponse(outcome=Break(), binding_name_to_value=binding_name_to_value)
 
 
-def continue_response() -> StepResponse:
+def continue_response(*, binding_name_to_value: Mapping[str, object] | UnsetType = UNSET) -> StepResponse:
     """Create a response with continue outcome (skip to next iteration)."""
-    return StepResponse(outcome=Continue())
+    return StepResponse(outcome=Continue(), binding_name_to_value=binding_name_to_value)

{nighthawk_python-0.15.0.dist-info → nighthawk_python-0.16.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: nighthawk-python
-Version: 0.15.0
+Version: 0.16.0
 Summary: A Python library where Python controls flow and LLMs or coding agents reason within constrained Natural blocks.
 Project-URL: Repository, https://github.com/kurusugawa-computer/nighthawk-python
 Project-URL: Documentation, https://kurusugawa-computer.github.io/nighthawk-python/

{nighthawk_python-0.15.0.dist-info → nighthawk_python-0.16.0.dist-info}/RECORD

@@ -1,13 +1,13 @@
 nighthawk/__init__.py,sha256=A_3q-S4wUnuy_GzRlI8TSADfy2cQNPfOdh2y6eIvdHg,2390
-nighthawk/composition.py,sha256=6ffFoFilnaDk17pRlU-pm330KnRIoDb5BNHEmvXVxj0,1914
-nighthawk/configuration.py,sha256=84MDKupaNaEiOTeoABjvRbXsC-UjWQR7JrAW4mziA9M,9024
+nighthawk/composition.py,sha256=qd5NgA3p4RiFeTgZEnSruEcVmAejolP3xAgT226m3OA,2070
+nighthawk/configuration.py,sha256=3w4fAihCGub9ubSwlwAtVTIHSLPU4wUu-_ZRpdcbf4w,9127
 nighthawk/errors.py,sha256=U9ogl_0MLA1xXe_bU2RCA1gRWN0ev5E4a3FiBLgpilI,1282
-nighthawk/function_call.py,sha256=eHWL0wpXcosRQMIl8GmOcPHJXc4n40PvGbXYmdKLlJw,6138
+nighthawk/function_call.py,sha256=o_i86cbsRxC0kMsTXCWvijA7SJmC7oNrcEghTNvpWJE,6745
 nighthawk/identifier_path.py,sha256=QRbDte7j0mubwg8ebs1GlxW7QeA5V_ow29MpVPCg6Ck,626
 nighthawk/json_renderer.py,sha256=QT4-kyKcr_rcga5hg2irKZ4a2OH6XJ8c0_b1zBlPjcE,10501
 nighthawk/lifecycle.py,sha256=pHCTZCMbG7iTVmLOWuwspi4DeM5p2Y5BskONFF_beTY,5513
-nighthawk/oversight.py,sha256=STOFtR8hx5wIVPiTUPjc0FsNEMUp_DSYsy_6o994LoE,5382
-nighthawk/testing.py,sha256=u4phjHPzgoAmbSHsi1vbG6k30BWOa4hCIa-TKYI7yAs,7732
+nighthawk/oversight.py,sha256=xCuJ5kARG0P2KS0eaf4pHqvkUYVgSULNqB-QLXEKxGU,5762
+nighthawk/testing.py,sha256=yJE2ru0igXknjN2CCpLur2XGSCGI-ww_58Y8XK4h4iw,8045
 nighthawk/ulid.py,sha256=CBpGLXDGm2j69Yk15hEq4Z5V8StWOY4714ow4BZn5tc,546
 nighthawk/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nighthawk/backends/_text_fallback.py,sha256=h4dt3nU73Uwd6rxn2zLx7trnlxgxKVhNYWc3xZjTMeg,3606
@@ -45,24 +45,24 @@ nighthawk/runtime/context.py,sha256=fJlrV8-Ty0P5dATYQsW4aPCGErH90JJYly_H2mqZyIM,
 nighthawk/runtime/description.py,sha256=tLL_tD6RTUFGBBz64QZo9atwHaWDLd0SpQPnZ2JkUc4,21411
 nighthawk/runtime/discovery.py,sha256=Z0gRU0xVQfxfZ-2ffol3CKwIWg5vWDchOU59ucN9Lpc,5145
 nighthawk/runtime/embedded.py,sha256=59wZE7ooLpnxxRvS1YwqQzcIqOo9DBoWJD1PlFRxWbE,4961
-nighthawk/runtime/environment.py,sha256=0Jyw2PM9MrZDN--p5V5fNyb5ni0v-hcT0vrlAqiIOIg,12843
+nighthawk/runtime/environment.py,sha256=hvmAS9N2_cbxxzQcJ4QZJfkhufPrrw1gcJY0ct7rsx8,14038
 nighthawk/runtime/execution_reference.py,sha256=9sMqcpS8kmyNWEPruFnuYMaOqgpDszcfk2Rofqr2Eek,410
-nighthawk/runtime/expression.py,sha256=xYIGGuO4MEJQ8KKdz7IAlC9WJ1mUfmAjCwYJYtCQi54,4000
+nighthawk/runtime/expression.py,sha256=421HuL53GGEKW1Tuag9VRRcJffmPShpJ0rTRmZYkxWM,4042
 nighthawk/runtime/inspection.py,sha256=06zWKw_u61585qc-Wp1QmvKAekydWoCcmaDEU22Hdbw,3454
 nighthawk/runtime/interruption.py,sha256=9B3hjMbXXtjf1sP2qVAf10dWk0KDS_UttZwqaix1tFU,679
-nighthawk/runtime/model_candidate.py,sha256=cfRFzNkX9ogln5GUFoqf3GYYq6hShelc1mEHKqrMiBQ,2461
+nighthawk/runtime/model_candidate.py,sha256=X0aJvlk9zSDTwU6KCnYLBnOuiKab-E4IqVEeypvljhs,3122
 nighthawk/runtime/notifications.py,sha256=khLidCGr9lc2aed_GwGiWaUOx6jNQepGqY0_a6flJWo,1449
 nighthawk/runtime/operation_contract.py,sha256=zTZTQXrv6xpUgJxUIGB3xVFDQZ0NglgmdU30aFbOf9Q,2471
 nighthawk/runtime/operations.py,sha256=OQ15NKnSs2NSUgRxFALzS6bRCWPgbzNrjXCOOW6GH7A,6706
-nighthawk/runtime/preparation.py,sha256=Bm80_F6zKrBaMGaLlTOyfHK7qEBAMN8sUMRU4m3XVWE,11632
-nighthawk/runtime/prompt.py,sha256=5SoDBHLNC6hRqJX3IDRhk1HJO4raoFzsaATIOQCLfK8,30098
-nighthawk/runtime/runner.py,sha256=rMf0ZzD4Xp8LGs3weWGwEiwIxlr-h5Ekg4NDVwY6VJ8,27287
-nighthawk/runtime/scoping.py,sha256=hjoauK3PCTFKTeIWDyjIN2SqoBOrmwAHcSk_vBYmFKc,21309
-nighthawk/runtime/step_context.py,sha256=7n4ZIwdCIVaD1n-klRDcalPpoxCAtS2wTUCLnYQ8qd0,5904
+nighthawk/runtime/preparation.py,sha256=zLrnP53k7PrKv4gTYf_RJDB2dOEbI_KxB7JSqPzG0EM,11396
+nighthawk/runtime/prompt.py,sha256=ihKOoMEWiTKX6SsyXiAvXydPfgnIAQBrBhDsBib2_ak,29750
+nighthawk/runtime/runner.py,sha256=I5A2CnqzxcWAmIQlGO46h5p460RB_ibHxnLktDj0g7c,27097
+nighthawk/runtime/scoping.py,sha256=94l8lW9UWDSAh4e1-lG1GOt3l7vlm_KMfAcCTbGGCM0,21623
+nighthawk/runtime/step_context.py,sha256=DM7mHCiiFhulUAqS6qK7TAZLHfOe-ZqRtZHkEwj22OE,5836
 nighthawk/runtime/step_contract.py,sha256=xIQcpD1PDY_gqrTqSUZ_5yZoMQt1EJOU33fpn-Da_28,6737
 nighthawk/runtime/step_definition.py,sha256=f64IVSAfpbxUpFVdIKBuWW43m2sQRQDvVmFgBrQeKbE,1913
-nighthawk/runtime/step_executor.py,sha256=4YSkZctDalR8OyXXKEp0TeME-Zs5UucMAPd0qQ9O_2U,15326
-nighthawk/runtime/step_request.py,sha256=04z-TYR5b-_7yQoeAwqg9YGFNGaglbstFFfzLn-mgzw,2563
+nighthawk/runtime/step_executor.py,sha256=Q7Teu6mUrForLi1q6Q570ZRkP44KZ-9KoodUUXnJEXs,16089
+nighthawk/runtime/step_request.py,sha256=qs_kJZ_SqvYSD4yTs-5jSoHVrTbVT27YxWUFHeLHLjM,4508
 nighthawk/runtime/step_result.py,sha256=mCdteQgQMMwoYTvhCJLuwcctljw-rjjyoFy2awfiRRg,1678
 nighthawk/runtime/tool_calls.py,sha256=IZQWk2IH8rPF6hjVBzBDn0cpGDkG9k368dDFpmquYOg,3318
 nighthawk/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -74,7 +74,7 @@ nighthawk/tools/contracts.py,sha256=X-YixPwBun0FmjiyPPNCXPW2pJf7CpmWR7jyTVJQvsM,
 nighthawk/tools/declarations.py,sha256=goPDT7iVaXez11R_9z8e4czeeA7wevmZPs8sO85hqdA,3986
 nighthawk/tools/execution.py,sha256=IeZs32tUSLJkj7_M94vrWh0Xt1CkJgvoUike9iIKe1I,6720
 nighthawk/tools/provided.py,sha256=H17PoX8ztUmtgrBkB-bEdfDkK5OSULIl_tyMgzEc3g4,1958
-nighthawk_python-0.15.0.dist-info/METADATA,sha256=QUwsH_cWrn_ywrZYLhSLCGyOlp2JdV-1w2G7xRSh7I4,6147
-nighthawk_python-0.15.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-nighthawk_python-0.15.0.dist-info/licenses/LICENSE,sha256=R8tjrX79o5Pbi_l_aFPPWDbTZkmz4is0CxmzMMs3f0A,1076
-nighthawk_python-0.15.0.dist-info/RECORD,,
+nighthawk_python-0.16.0.dist-info/METADATA,sha256=g2-niQ9VaMFvMMN3Rn0advG6wBR-Oume9kwYaC_UvjI,6147
+nighthawk_python-0.16.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+nighthawk_python-0.16.0.dist-info/licenses/LICENSE,sha256=R8tjrX79o5Pbi_l_aFPPWDbTZkmz4is0CxmzMMs3f0A,1076
+nighthawk_python-0.16.0.dist-info/RECORD,,