nighthawk-python 0.7.0__tar.gz → 0.9.0__tar.gz

{nighthawk_python-0.7.0 → nighthawk_python-0.9.0}/.github/workflows/docs.yml

@@ -46,4 +46,4 @@ jobs:
       url: ${{ steps.deployment.outputs.page_url }}
     steps:
       - id: deployment
-        uses: actions/deploy-pages@v4
+        uses: actions/deploy-pages@v5

{nighthawk_python-0.7.0 → nighthawk_python-0.9.0}/CHANGELOG.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+- Redesigned `nh.scope()` around `mode` semantics (`"inherit"` default, `"replace"` for explicit replacement).
+- Scope prompt suffix arguments now use list-based forms: `system_prompt_suffix_fragments` and `user_prompt_suffix_fragments`.
+
+### Removed
+- Removed `step_executor_configuration_patch` from `nh.scope()`.
+- Removed `StepExecutorConfigurationPatch` from the public API.
+
+### Fixed
+- Clarified and aligned docs/tests for scope merge vs replace behavior.
+
+## [0.8.0]
+
+### Added
+- Unit tests covering prompt token-budget injection: system prompt resolves `$tool_result_max_tokens`, and custom user prompt templates can resolve the same placeholder.
+
+### Changed
+- Default step system prompt now states that tool result `value` is a preview and includes the injected max-token limit.
+- User prompt template rendering now uses `Template.safe_substitute`, aligned with system prompt injection behavior and compatible with optional `$tool_result_max_tokens` placeholders.
+
 ## [0.7.0]
 
 ### Added
@@ -118,8 +138,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Step executor abstraction and provider integration foundation.
 - Core documentation and project scaffolding.
 
-[Unreleased]: https://github.com/kurusugawa-computer/nighthawk-python/compare/v0.7.0...HEAD
-[0.6.1]: https://github.com/kurusugawa-computer/nighthawk-python/compare/v0.6.1...v0.7.0
+[Unreleased]: https://github.com/kurusugawa-computer/nighthawk-python/compare/v0.8.0...HEAD
+[0.8.0]: https://github.com/kurusugawa-computer/nighthawk-python/compare/v0.7.0...v0.8.0
+[0.7.0]: https://github.com/kurusugawa-computer/nighthawk-python/compare/v0.6.1...v0.7.0
 [0.6.1]: https://github.com/kurusugawa-computer/nighthawk-python/compare/v0.6.0...v0.6.1
 [0.6.0]: https://github.com/kurusugawa-computer/nighthawk-python/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/kurusugawa-computer/nighthawk-python/compare/v0.4.0...v0.5.0

{nighthawk_python-0.7.0 → nighthawk_python-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nighthawk-python
-Version: 0.7.0
+Version: 0.9.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.7.0 → nighthawk_python-0.9.0}/docs/api.md

@@ -14,7 +14,6 @@
         - scope
         - AgentStepExecutor
         - StepExecutorConfiguration
-        - StepExecutorConfigurationPatch
         - StepPromptTemplates
         - StepContextLimits
         - JsonableValue

{nighthawk_python-0.7.0 → nighthawk_python-0.9.0}/docs/for-coding-agents.md

@@ -146,8 +146,12 @@ with nh.run(fast_executor):
         report = write_analysis_report(ticket_text, product_summary)
 ```
 
-`implicit_references` can inject global helper functions as block capabilities.
-Nested scopes still merge additively (set union by key).
+- `implicit_references` inject helper functions as block capabilities.
+- `nh.scope()` must run inside `nh.run()`; it keeps `run_id` and creates a new `scope_id`.
+- `mode` affects only `system_prompt_suffix_fragments`, `user_prompt_suffix_fragments`, and `implicit_references`.
+- `inherit`: suffix lists append; `implicit_references` merge with conflict check (same key + different object => `NighthawkError`).
+- `replace`: explicit list/mapping fully replace; `[]`/`{}` clear; `None` keeps inherited value.
+- `step_executor` / `step_executor_configuration` are resolved independently of `mode`.
 
 ## 4. The standard contract shape
 
@@ -273,6 +277,8 @@ Do not inject untrusted raw text into Natural source. If input is user-controlle
 Rules:
 
 - The model sees callable signatures from both LOCALS and GLOBALS.
+- For object read bindings, the model also sees a capability view: object header, public methods (with signatures), and public fields (with typed previews).
+- Object capability views expose public members only. Private/dunder members are omitted, and properties are not evaluated.
 - Put per-invocation data in function parameters. Put stable, reusable capabilities at module level.
 - Do not annotate callable parameters as `object` or `Any` -- this erases the signature the model needs:
 

{nighthawk_python-0.7.0 → nighthawk_python-0.9.0}/docs/runtime-configuration.md

@@ -2,7 +2,7 @@
 
 > This page assumes you have completed [Executors](executors.md).
 
-This page covers how to configure execution at runtime: scoping, configuration patching, prompt suffix fragments, context limits, JSON rendering, and execution identity. These settings are independent of executor choice and apply equally to Pydantic AI providers and coding agent backends.
+This page covers how to configure execution at runtime: scoping modes, prompt suffix fragments, context limits, JSON rendering, and execution identity. These settings are independent of executor choice and apply equally to Pydantic AI providers and coding agent backends.
 
 ## Scoped overrides with `nh.scope()`
 
@@ -11,17 +11,20 @@ Use `nh.scope()` to override execution settings within an existing run. Each sco
 ```py
 with nh.run(step_executor):
 
-    # Override model for a specific section
+    # Inherit mode (default): merge/append into current scope state
     with nh.scope(
-        step_executor_configuration_patch=nh.StepExecutorConfigurationPatch(
+        step_executor_configuration=nh.StepExecutorConfiguration(
             model="openai-responses:gpt-5.4-mini",
         ),
     ) as scoped_executor:
         expensive_analysis(data)
 
-    # Append a system prompt suffix for a section
+    # Replace mode: replace only explicitly provided values
+    # None means "no change". [] / {} means "clear".
     with nh.scope(
-        system_prompt_suffix_fragment="Always respond in formal English.",
+        mode="replace",
+        system_prompt_suffix_fragments=["Always respond in formal English."],
+        implicit_references={},
     ):
         formal_summary(text)
 
@@ -29,31 +32,35 @@ with nh.run(step_executor):
     with nh.scope(step_executor=another_executor):
         specialized_step(data)
 
-    # Add implicit global references for this scope (merged across nested scopes)
+    # Add implicit global references for this scope
     with nh.scope(implicit_references={"search_repository": search_repository}):
         typed_labeling_step(ticket_text)
 ```
 
 Parameters:
 
+- `mode`: scope composition mode. Default: `"inherit"`.
 - `step_executor_configuration`: replace the entire configuration.
-- `step_executor_configuration_patch`: partially override specific fields.
 - `step_executor`: replace the step executor entirely.
-- `system_prompt_suffix_fragment`: append text to the system prompt for the scope.
-- `user_prompt_suffix_fragment`: append text to the user prompt for the scope.
-- `implicit_references`: add implicit global references for this scope as a name-to-value mapping. Nested scopes merge references additively (set union by key).
+- `system_prompt_suffix_fragments`: scope-level system suffix fragments.
+- `user_prompt_suffix_fragments`: scope-level user suffix fragments.
+- `implicit_references`: scope-level implicit global references.
 
-Use `step_executor_configuration` when you want a full configuration replacement for a scope.
-Use `step_executor_configuration_patch` for targeted changes (for example, switching only the model).
-Use `step_executor` to swap the executor implementation for that scope.
-Use `system_prompt_suffix_fragment` and `user_prompt_suffix_fragment` to append one-off scope-level prompt text.
-Use `implicit_references` when a step should always expose specific globals even without explicit `<name>` bindings.
+Mode semantics:
+
+- `mode="inherit"` (default):
+  - `system_prompt_suffix_fragments` and `user_prompt_suffix_fragments` are appended.
+  - `implicit_references` are merged additively with conflict checks.
+- `mode="replace"`:
+  - `None` means no change.
+  - Explicit `[]` or `{}` clears inherited list/dict values.
+  - Explicit list/dict values (for example `[e1, e2]` or `{k1: v1, k2: v2}`) fully replace inherited values.
 
 The context manager yields the resolved `StepExecutor` for the scope.
 
-`StepExecutorConfiguration` also accepts `system_prompt_suffix_fragments` and `user_prompt_suffix_fragments` (tuples of strings) as baseline suffix fragments for the whole run. Scope-level fragments are appended after configuration-level fragments.
+`StepExecutorConfiguration` also accepts `system_prompt_suffix_fragments` and `user_prompt_suffix_fragments` (tuples of strings) as baseline suffix fragments for the whole run. In `mode="inherit"`, scope-level fragments are appended after configuration-level fragments.
 
-## Additive scoped implicit references
+## Scoped implicit references
 
 `implicit_references` can inject global helper functions as step capabilities:
 
@@ -65,8 +72,72 @@ with nh.run(step_executor):
         triage_issue(ticket_text)
 ```
 
-Nested scopes merge names additively (set union by key).
+In `mode="inherit"` (default), nested scopes merge additively with conflict checks.
+In `mode="replace"`, explicit mappings fully replace inherited mappings.
+
+```py
+with nh.run(step_executor), nh.scope(implicit_references={"parent": search_repository}):
+    with nh.scope(mode="replace", implicit_references={}):
+        triage_issue(ticket_text)
+```
+
+The inner scope above clears inherited implicit references.
+
+```py
+with nh.scope(mode="replace", implicit_references={"child": search_repository}):
+    triage_issue(ticket_text)
+```
+
+This fully replaces inherited references with the provided mapping.
+
+```py
+with nh.scope(mode="replace", implicit_references=None):
+    triage_issue(ticket_text)
+```
+
+This keeps inherited references unchanged.
+
+## Prompt suffix fragments in scopes
+
+Use list values when setting scope-level suffix fragments:
+
+```py
+with nh.run(step_executor):
+    with nh.scope(system_prompt_suffix_fragments=["Use concise answers."]):
+        summarize_ticket(ticket_text)
+```
+
+`user_prompt_suffix_fragments` follows the same rules.
+
+```py
+with nh.scope(user_prompt_suffix_fragments=["Focus on actionable output."]):
+    summarize_ticket(ticket_text)
+```
+
+In `mode="inherit"`, provided lists are appended.
+In `mode="replace"`, provided lists fully replace inherited lists.
+
+```py
+with nh.run(step_executor), nh.scope(system_prompt_suffix_fragments=["parent"]):
+    with nh.scope(mode="replace", system_prompt_suffix_fragments=["child_1", "child_2"]):
+        summarize_ticket(ticket_text)
+```
+
+Pass `[]` to clear inherited fragments.
+
+```py
+with nh.scope(mode="replace", system_prompt_suffix_fragments=[]):
+    summarize_ticket(ticket_text)
+```
+
+Pass `None` to keep inherited fragments unchanged.
+
+```py
+with nh.scope(mode="replace", system_prompt_suffix_fragments=None):
+    summarize_ticket(ticket_text)
+```
 
+The same `replace` semantics apply to `user_prompt_suffix_fragments`.
 ## Mixing executors
 
 Use `nh.scope(step_executor=...)` to switch executors within a single run. This is the standard pattern for mixing a cheap classifier with a deep autonomous step:

{nighthawk_python-0.7.0 → nighthawk_python-0.9.0}/docs/specification.md

@@ -91,9 +91,6 @@ The condensed coding agent guide (`for-coding-agents.md`) is a derivative docume
     - `json_renderer_style`: [headson](https://github.com/kantord/headson) rendering style used in prompt context and tool result envelopes. Default: `"default"`. Available values: `"strict"` (valid JSON, no annotations), `"default"` (pseudo-JSON with omission markers like `…`), `"detailed"` (JS-like with inline comments such as `// N more`).
     - `system_prompt_suffix_fragments`: optional baseline system prompt suffix fragments for this executor configuration.
     - `user_prompt_suffix_fragments`: optional baseline user prompt suffix fragments for this executor configuration.
-- `StepExecutorConfigurationPatch`
-    - Partial override object for scoped configuration updates.
-    - Supports patching model, model settings, templates, limits, renderer style, tokenizer encoding, and prompt suffix fragment tuples.
 
 ### 5.3. Supporting types
 
@@ -103,7 +100,7 @@ The condensed coding agent guide (`for-coding-agents.md`) is a derivative docume
     - `step_user_prompt_template`: user prompt template.
 - `StepContextLimits`
     - Limits for rendering dynamic context into the LLM prompt.
-    - Fields: `locals_max_tokens`, `locals_max_items`, `globals_max_tokens`, `globals_max_items`, `value_max_tokens`, `tool_result_max_tokens`.
+    - Fields: `locals_max_tokens`, `locals_max_items`, `globals_max_tokens`, `globals_max_items`, `value_max_tokens`, `object_max_methods`, `object_max_fields`, `object_field_value_max_tokens`, `tool_result_max_tokens`.
 - `JsonableValue`
     - Type alias for JSON-serializable Python values (`dict | list | str | int | float | bool | None`).
 - `ExecutionContext`
@@ -254,12 +251,49 @@ Ordering:
 
 Rendering format:
 
-- Non-callable values: `name: type_name = json_value`, where `json_value` is the compact JSON rendering of the value (bounded by `context_limits.value_max_tokens`).
+- `TypeAliasType` values (PEP 695): `name: type = underlying_type`.
 - Callable values: `name: (signature)`, where `(signature)` is the result of `inspect.signature`. Type annotations are included when available (e.g., `(base: int, bonus: int) -> int`).
     - If the callable has a meaningful docstring, the first line is appended as `# first_line`.
-    - If multiple callable entries share the same signature text, each is annotated with `# disambiguation: use name` to help the LLM distinguish them.
+    - If the callable is async, `async` is appended in metadata comments.
+    - If multiple callable entries share the same signature text, each is annotated with `# disambiguation: use name`.
     - If the signature cannot be resolved (e.g., `__signature__` raises), the entry renders as `name: <callable; signature-unavailable>`.
-- `TypeAliasType` values (PEP 695): `name: type = underlying_type`.
+- Object capability values (non-callable, non-scalar, non-container values):
+    - Header line: `name: object = TypeName`.
+    - Public method lines: `name.method: (signature)` using callable rules above.
+    - Public field lines: `name.field: type_name = json_value`.
+    - Public means names that do not start with `_`; private and dunder names are excluded.
+    - Properties are not evaluated.
+    - Field discovery uses safe sources: instance `__dict__`, dataclass fields, Pydantic model fields, and readable public `__slots__` entries.
+    - Class attributes that are public and non-callable are included as fields.
+    - Method expansion is bounded by `context_limits.object_max_methods`; field expansion is bounded by `context_limits.object_max_fields`; each field value preview is bounded by `context_limits.object_field_value_max_tokens`.
+    - If object member limits are exceeded, explicit omission lines are added: `name.<methods>: <snipped N public methods>` and/or `name.<fields>: <snipped N public fields>`.
+- Other non-callable values: `name: type_name = json_value`, where `json_value` is bounded by `context_limits.value_max_tokens`.
+
+Callable disambiguation considers both top-level callable entries and object method entries in the same section.
+
+Ordering:
+
+- Top-level entries are rendered in lexicographic order by top-level name.
+- Object methods and fields are rendered in lexicographic order by member name.
+- Methods are rendered before fields for each object entry.
+- If a section-level budget prevents rendering all top-level entries, `<snipped>` is appended at the end of the section.
+
+Safety:
+
+- Prompt rendering does not call user methods.
+- Prompt rendering does not evaluate properties or descriptors requiring attribute execution.
+- Slot and field access failures are ignored for rendering purposes.
+
+Token budgeting:
+
+- Section budgets remain governed by `locals_max_tokens` / `globals_max_tokens` and item budgets by `locals_max_items` / `globals_max_items`.
+- Object method and field expansion is additionally governed by object-specific limits listed above.
+- Line-level token counting includes newline separators during budget checks.
+
+Observability:
+
+- Section-level token truncation emits `prompt_context_truncated` logs with section, reason, and configured max token details.
+- Object member omission due to object-specific member limits does not emit a separate log event.
 
 Truncation:
 
@@ -421,7 +455,7 @@ Atomicity requirement:
 #### 8.3.1. Supporting types (internal)
 
 - `ToolBoundaryError`: Exception carrying `kind` (ErrorKind), `message`, and optional `guidance`. Raised by tool implementations to signal structured failures.
-- `ToolResultRenderingPolicy`: Frozen dataclass controlling how tool results are rendered (tokenizer encoding name, max tokens, JSON renderer style).
+- `ToolResultRenderingPolicy`: Frozen dataclass controlling how tool result previews are rendered (tokenizer encoding name, max tokens, JSON renderer style).
 
 ### 8.4. Execution contract (final JSON)
 
@@ -552,13 +586,18 @@ API:
     - Uses provided `run_id` when given; otherwise generates a new `run_id` (trace root).
     - Always generates a fresh `scope_id`.
     - Can be used even when no step executor is currently set.
-- `nighthawk.scope(*, step_executor_configuration: StepExecutorConfiguration | None = None, step_executor_configuration_patch: StepExecutorConfigurationPatch | None = None, step_executor: StepExecutor | None = None, system_prompt_suffix_fragment: str | None = None, user_prompt_suffix_fragment: str | None = None) -> Iterator[StepExecutor]`
+- `nighthawk.scope(*, mode: Literal["inherit", "replace"] = "inherit", step_executor_configuration: StepExecutorConfiguration | None = None, step_executor: StepExecutor | None = None, system_prompt_suffix_fragments: Sequence[str] | None = None, user_prompt_suffix_fragments: Sequence[str] | None = None, implicit_references: Mapping[str, object] | None = None) -> Iterator[StepExecutor]`
     - Enter a nested scope within the current run.
     - Requires an existing step executor.
     - Generates a new `scope_id` (keeps the current `run_id`).
-    - Only specified fields are overridden for the duration of the `with`.
-    - `system_prompt_suffix_fragment`: optional string appended to the system prompt for the duration of the scope.
-    - `user_prompt_suffix_fragment`: optional string appended to the user prompt for the duration of the scope.
+    - `mode="inherit"` (default):
+        - Appends prompt suffix fragment lists.
+        - Merges `implicit_references` additively with conflict checks.
+    - `mode="replace"`:
+        - Replaces provided list/mapping values.
+        - `None` means no change.
+        - Explicit `[]` / `{}` clears inherited list/mapping values.
+        - Explicit list/mapping values (for example `[e1, e2]` or `{k1: v1, k2: v2}`) fully replace inherited values.
     - Yields the resolved `StepExecutor` for the scope.
 - `nighthawk.get_step_executor() -> StepExecutor`
     - Get the current step executor. Raises if unset.
@@ -691,7 +730,7 @@ Instance attributes:
 - `configuration: StepExecutorConfiguration` — the resolved configuration.
 - `agent_is_managed: bool` — `True` when the agent was built internally from the configuration, `False` when provided externally via `from_agent`.
 - `token_encoding` — tiktoken encoding resolved from the configuration.
-- `tool_result_rendering_policy: ToolResultRenderingPolicy` — policy for rendering tool results, derived from configuration.
+- `tool_result_rendering_policy: ToolResultRenderingPolicy` — policy for rendering tool result previews, derived from configuration.
 
 ### 14.3. Custom backends
 

{nighthawk_python-0.7.0 → nighthawk_python-0.9.0}/evals/promptfoo/prompts/eval_default.txt

@@ -22,4 +22,4 @@ Trust boundaries:
 
 Notes:
 - In async Natural functions, expressions may use `await`.
-- Tool calls return {"value": ..., "error": ...}. Values may contain … where content was omitted. Check "error" for failures.
+- Tool calls return {"value": ..., "error": ...}; "value" is a preview (max $tool_result_max_tokens tokens), so persist large/intermediate data via nh_assign and inspect with focused nh_eval reads.

{nighthawk_python-0.7.0 → nighthawk_python-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nighthawk-python"
-version = "0.7.0"
+version = "0.9.0"
 description = "A Python library where Python controls flow and LLMs or coding agents reason within constrained Natural blocks."
 readme = "README.md"
 requires-python = ">=3.13"

{nighthawk_python-0.7.0 → nighthawk_python-0.9.0}/src/nighthawk/__init__.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 from .configuration import (
     StepContextLimits,
     StepExecutorConfiguration,
-    StepExecutorConfigurationPatch,
     StepPromptTemplates,
 )
 from .errors import (
@@ -32,7 +31,6 @@ __all__ = [
     "StepContextLimits",
     "StepExecutor",
     "StepExecutorConfiguration",
-    "StepExecutorConfigurationPatch",
     "StepPromptTemplates",
     "ToolEvaluationError",
     "ToolRegistrationError",

{nighthawk_python-0.7.0 → nighthawk_python-0.9.0}/src/nighthawk/configuration.py

@@ -32,7 +32,7 @@ Trust boundaries:
 
 Notes:
 - In async Natural functions, expressions may use `await`.
-- Tool calls return {"value": ..., "error": ...}. Values may contain \u2026 where content was omitted. Check "error" for failures.
+- Tool calls return {"value": ..., "error": ...}; "value" is a preview (max $tool_result_max_tokens tokens), so persist large/intermediate data via nh_assign and inspect with focused nh_eval reads.
 """
 
 
@@ -81,8 +81,11 @@ class StepContextLimits(BaseModel):
         locals_max_items: Maximum items rendered in the locals section.
         globals_max_tokens: Maximum tokens for the globals section.
         globals_max_items: Maximum items rendered in the globals section.
-        value_max_tokens: Maximum tokens for a single value rendering.
-        tool_result_max_tokens: Maximum tokens for a tool result rendering.
+        value_max_tokens: Maximum tokens for a single value preview.
+        object_max_methods: Maximum public methods rendered for one object capability view.
+        object_max_fields: Maximum public fields rendered for one object capability view.
+        object_field_value_max_tokens: Maximum tokens for one object field value preview.
+        tool_result_max_tokens: Maximum tokens for a tool result preview.
     """
 
     model_config = ConfigDict(extra="forbid", frozen=True)
@@ -94,6 +97,9 @@ class StepContextLimits(BaseModel):
     globals_max_items: int = Field(default=40, ge=1)
 
     value_max_tokens: int = Field(default=200, ge=1)
+    object_max_methods: int = Field(default=16, ge=0)
+    object_max_fields: int = Field(default=16, ge=0)
+    object_field_value_max_tokens: int = Field(default=120, ge=1)
     tool_result_max_tokens: int = Field(default=1_200, ge=1)
 
 
@@ -154,44 +160,3 @@ class StepExecutorConfiguration(BaseModel):
             return tiktoken.encoding_for_model(model_name)
         except Exception:
             return tiktoken.get_encoding("o200k_base")
-
-
-class StepExecutorConfigurationPatch(BaseModel):
-    """Partial override for StepExecutorConfiguration.
-
-    Non-None fields replace the corresponding fields in the target configuration.
-
-    Attributes:
-        model: Model identifier override.
-        model_settings: Model settings override. Accepts a dict or a
-            backend-specific BaseModel instance (auto-converted to dict).
-        prompts: Prompt templates override.
-        context_limits: Context limits override.
-        json_renderer_style: JSON renderer style override.
-        tokenizer_encoding: Tokenizer encoding override.
-        system_prompt_suffix_fragments: System prompt suffix fragments override.
-        user_prompt_suffix_fragments: User prompt suffix fragments override.
-    """
-
-    model_config = ConfigDict(extra="forbid", frozen=True)
-
-    model: str | None = None
-    model_settings: dict[str, Any] | BaseModel | None = None
-
-    @field_validator("model_settings", mode="before")
-    @classmethod
-    def _normalize_model_settings(cls, value: Any) -> dict[str, Any] | None:
-        if isinstance(value, BaseModel):
-            return value.model_dump()
-        return value
-
-    prompts: StepPromptTemplates | None = None
-    context_limits: StepContextLimits | None = None
-    json_renderer_style: JsonRendererStyle | None = None
-    tokenizer_encoding: str | None = None
-    system_prompt_suffix_fragments: tuple[str, ...] | None = None
-    user_prompt_suffix_fragments: tuple[str, ...] | None = None
-
-    def apply_to(self, configuration: StepExecutorConfiguration) -> StepExecutorConfiguration:
-        """Apply non-None fields to the given configuration and return a new copy."""
-        return configuration.model_copy(update=self.model_dump(exclude_none=True))