agentinputlab 0.1.0a1__py3-none-any.whl

agentinputlab/algorithms/clarify/udcs_deterministic.py

@@ -0,0 +1,196 @@
+"""Paper Algorithm 1 UDCS routing, distinct from repository prompt-only routing.
+
+This is a one-step input intervention. It records the routed action/history;
+it never executes that action or fabricates a user/environment response.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any
+
+from agentinputlab.backends.llm import GenerationRequest, ModelCapability
+from agentinputlab.backends.llm.base import require_capabilities
+from agentinputlab.contracts import (
+    AlgorithmOutputError,
+    ExecutionTrace,
+    ExternalDependencyError,
+    FrozenAgentState,
+    InputPatch,
+    InterventionContext,
+    PatchOp,
+    PatchOperation,
+    SemanticFamily,
+    TraceEvent,
+    TracePhase,
+    ValidationError,
+)
+from agentinputlab.contracts.serialization import freeze_mapping
+from agentinputlab.contracts.state import Message
+
+from .udcs import (
+    UDCSDecision,
+    _build_user_prompt,
+    _clarification_request,
+    _system_prompt,
+    parse_udcs_response,
+)
+
+UDCS_DETERMINISTIC_RELEASE = "clarify.udcs.paper_spec_deterministic_route"
+UDCS_PAPER_SPEC = "arxiv:2606.19559v1:Algorithm1"
+UDCS_HISTORY_KEY = "udcs.paper_spec.history.v1"
+
+
+def _threshold(value: Any) -> float:
+    if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value) or not 0 <= value <= 1:
+        raise ValidationError("UDCS threshold must be finite and in [0, 1]")
+    return float(value)
+
+
+@dataclass(frozen=True, slots=True)
+class UDCSDeterministicRoute:
+    proposed_action: str
+    routed_action: str
+    threshold_triggered: bool
+    action_overridden: bool
+    requests_clarification: bool
+    question: str
+
+
+def route_udcs_decision(decision: UDCSDecision, threshold: float = 0.5) -> UDCSDeterministicRoute:
+    """Implement both branches of Algorithm 1 without a second model call."""
+    value = _threshold(threshold)
+    if not isinstance(decision, UDCSDecision):
+        raise ValidationError("UDCS router requires a parsed decision")
+    if any(isinstance(v, bool) or not isinstance(v, (int, float)) or not math.isfinite(v)
+           or not 0 <= v <= 1 for v in (decision.u_request, decision.confidence)):
+        raise AlgorithmOutputError("UDCS routing signals must be finite probabilities")
+    triggered = decision.u_request >= value
+    action = "request_clarification" if triggered else decision.action
+    asks = triggered or decision.requests_clarification
+    if not asks:
+        question = ""
+    elif decision.requests_clarification:
+        question = _clarification_request(decision)
+    else:
+        # A colon in a non-clarification tool action is not a question.
+        question = decision.u_request_explanation or "Please clarify the missing or ambiguous details in your request."
+    return UDCSDeterministicRoute(decision.action, action, triggered,
+        triggered and not decision.requests_clarification, asks, question)
+
+
+def _history(state: FrozenAgentState) -> tuple[Mapping[str, Any], ...]:
+    raw = state.metadata.get(UDCS_HISTORY_KEY, ())
+    if not isinstance(raw, (list, tuple)):
+        raise ValidationError("UDCS history must be an ordered entry sequence")
+    fields = {"source_state_hash", "observation", "think", "u_request", "u_request_explanation",
+              "proposed_action", "routed_action", "confidence", "explanation", "threshold", "threshold_triggered"}
+    result = []
+    for row in raw:
+        if not isinstance(row, Mapping) or set(row) != fields:
+            raise ValidationError("UDCS history entry fields differ from the protocol")
+        for key in fields - {"observation", "u_request", "confidence", "threshold", "threshold_triggered"}:
+            if not isinstance(row[key], str):
+                raise ValidationError("UDCS history text fields must be strings")
+        if (not isinstance(row["observation"], (tuple, list))
+                or any(not isinstance(item, str) for item in row["observation"])
+                or not isinstance(row["threshold_triggered"], bool)):
+            raise ValidationError("UDCS history observation/route fields differ")
+        for key in ("u_request", "confidence", "threshold"):
+            _threshold(row[key])
+        result.append(freeze_mapping(row))
+    return tuple(result)
+
+
+def _history_message(row: Mapping[str, Any]) -> Message:
+    # Preserve the signal-before-action ordering. These are visible previous
+    # observations and model emissions, not a guessed future environment state.
+    text = "# Previous UDCS step\nObservation:\n" + "\n\n".join(row["observation"])
+    for tag, key in (("think", "think"), ("u_request", "u_request"),
+                     ("u_request_explanation", "u_request_explanation"), ("action", "routed_action"),
+                     ("confidence", "confidence"), ("explanation", "explanation")):
+        text += f"\n<{tag}>{row[key]}</{tag}>"
+    return Message(role="assistant", content=text)
+
+
+@dataclass(frozen=True, slots=True)
+class UDCSPaperSpecDeterministicPolicy:
+    clarification_threshold: float = 0.5
+    temperature: float = 0.0
+    max_tokens: int = 512
+    max_history_entries: int = 64
+    profile_kind: str = "controlled_adapter"
+    method_id: str = "udcs"
+    release_id: str = UDCS_DETERMINISTIC_RELEASE
+    family: SemanticFamily = SemanticFamily.CLARIFY
+
+    def __post_init__(self):
+        _threshold(self.clarification_threshold)
+        GenerationRequest(prompt="configuration validation", temperature=self.temperature, max_tokens=self.max_tokens)
+        if type(self.max_history_entries) is not int or self.max_history_entries < 1:
+            raise ValidationError("UDCS max_history_entries must be positive")
+        if self.profile_kind not in {"controlled_adapter", "factorial_adapter"}:
+            raise ValidationError("UDCS deterministic routing requires controlled or factorial mode")
+        if (self.method_id != "udcs" or self.release_id != UDCS_DETERMINISTIC_RELEASE
+                or self.family is not SemanticFamily.CLARIFY):
+            raise ValidationError("UDCS deterministic identity differs from its registered profile")
+
+    def propose(self, state: FrozenAgentState, context: InterventionContext) -> InputPatch:
+        from dataclasses import replace
+
+        history = _history(state)
+        if len(history) >= self.max_history_entries:
+            raise ValidationError("UDCS history safety bound reached; no silent truncation or model call")
+        backend = context.backend
+        if backend is None:
+            raise ExternalDependencyError("UDCS deterministic routing needs a context chat backend")
+        require_capabilities(backend, {ModelCapability.CHAT})
+        prompt_state = replace(state, messages=(*state.messages, *(_history_message(row) for row in history)))
+        response = backend.generate(GenerationRequest(
+            prompt=_build_user_prompt(prompt_state, self.clarification_threshold), system=_system_prompt(),
+            temperature=self.temperature, max_tokens=self.max_tokens, seed=context.seed, stop=(),
+            metadata={"method_id": self.method_id, "release_id": self.release_id,
+                      "routing_semantics": "paper_spec_deterministic"}))
+        decision = parse_udcs_response(response.text)
+        route = route_udcs_decision(decision, self.clarification_threshold)
+        step = freeze_mapping({"source_state_hash": state.state_hash,
+            "observation": tuple(block.text for block in state.context), "think": decision.think,
+            "u_request": decision.u_request, "u_request_explanation": decision.u_request_explanation,
+            "proposed_action": decision.action, "routed_action": route.routed_action,
+            "confidence": decision.confidence, "explanation": decision.explanation,
+            "threshold": self.clarification_threshold, "threshold_triggered": route.threshold_triggered})
+        operations = [PatchOperation(PatchOp.REQUEST_CLARIFICATION, route.question, target="user",
+            rationale=decision.u_request_explanation) if route.requests_clarification else
+            PatchOperation(PatchOp.NO_OP, rationale="paper Algorithm1 retained the proposed action; no tool execution here")]
+        metadata_update = {UDCS_HISTORY_KEY: (*history, step)}
+        if not route.requests_clarification and "clarification_request" in state.metadata:
+            metadata_update["clarification_request"] = None
+        operations.append(PatchOperation(PatchOp.SET_METADATA, metadata_update,
+            target="udcs_history", rationale="retain the observed step and emitted uncertainty fields"))
+        return InputPatch(method_id=self.method_id, release_id=self.release_id, source_state_hash=state.state_hash,
+            operations=tuple(operations), trace=ExecutionTrace(method_id=self.method_id, release_id=self.release_id,
+                events=(TraceEvent(TracePhase.PREPARE, "paper_spec_threshold", {
+                    "threshold": self.clarification_threshold, "python_enforced": True,
+                    "source_spec": UDCS_PAPER_SPEC, "previous_history_entries": len(history)}),
+                    TraceEvent(TracePhase.PROPOSE, "deterministic_udcs_route", {
+                        "u_request": decision.u_request, "confidence": decision.confidence,
+                        "proposed_action": route.proposed_action, "routed_action": route.routed_action,
+                        "threshold_triggered": route.threshold_triggered, "action_overridden": route.action_overridden,
+                        "requests_clarification": route.requests_clarification})),
+                counters={"model_calls": 1}, warnings=tuple(f"clamped_{f}" for f in decision.clamped_fields)),
+            implementation_identity="paper_algorithm1_one_step_deterministic_route",
+            profile_kind=self.profile_kind, metadata={"source_spec": UDCS_PAPER_SPEC,
+                "u_request": decision.u_request, "confidence": decision.confidence,
+                "raw_action": decision.action, "routed_action": route.routed_action,
+                "threshold": self.clarification_threshold, "threshold_enforced": True,
+                "threshold_triggered": route.threshold_triggered, "action_overridden": route.action_overridden,
+                "requests_clarification": route.requests_clarification,
+                "backend_fingerprint": dict(backend.fingerprint()), "environment_action_executed": False,
+                "user_reply_generated": False, "parser_semantics": "repository_compatible_clamp_and_action_fallback",
+                "history_entries": len(history)+1, "original_native_runner_parity_claimed": False})
+
+
+__all__ = ["UDCS_DETERMINISTIC_RELEASE", "UDCS_HISTORY_KEY", "UDCS_PAPER_SPEC",
+    "UDCSDeterministicRoute", "UDCSPaperSpecDeterministicPolicy", "route_udcs_decision"]

agentinputlab/algorithms/curate/__init__.py

@@ -0,0 +1,65 @@
+"""Context-curation algorithms."""
+
+from .acon import (
+    ACON_COMMON_SUPPORT_CONTEXT_RULE,
+    ACON_COMMON_SUPPORT_RELEASE,
+    ACON_UPSTREAM_COMMIT,
+    ACONArtifactIdentity,
+    ACONHistoryControls,
+    ACONHistoryRuntimeExternal,
+    ACONObservationCommonSupport,
+    ACONObservationControls,
+    ACONObservationRuntimeExternal,
+)
+from .llmlingua import (
+    LLMLingua2BertMultilingualOfficialAdapter,
+    LLMLingua2Config,
+    LLMLingua2OfficialAdapter,
+    LongLLMLinguaConfig,
+    LongLLMLinguaControlled,
+    LongLLMLinguaControlledBindings,
+    LongLLMLinguaOfficialAdapter,
+    SpanMapping,
+    parse_context_budget,
+)
+from .recomp import (
+    RECOMP_ABSTRACTIVE_INPUT_TEMPLATE,
+    RECOMP_ABSTRACTIVE_INPUT_TEMPLATE_SHA256,
+    RECOMP_CANDIDATE_UNIT_KIND,
+    RECOMP_UPSTREAM_COMMIT,
+    RECOMPAbstractiveControls,
+    RECOMPAbstractiveExternal,
+    RECOMPExtractiveControls,
+    RECOMPExtractiveExternal,
+    RECOMPSentenceScore,
+)
+
+__all__ = [
+    "ACON_COMMON_SUPPORT_CONTEXT_RULE",
+    "ACON_COMMON_SUPPORT_RELEASE",
+    "ACON_UPSTREAM_COMMIT",
+    "RECOMP_ABSTRACTIVE_INPUT_TEMPLATE",
+    "RECOMP_ABSTRACTIVE_INPUT_TEMPLATE_SHA256",
+    "RECOMP_CANDIDATE_UNIT_KIND",
+    "RECOMP_UPSTREAM_COMMIT",
+    "ACONArtifactIdentity",
+    "ACONHistoryControls",
+    "ACONHistoryRuntimeExternal",
+    "ACONObservationCommonSupport",
+    "ACONObservationControls",
+    "ACONObservationRuntimeExternal",
+    "LLMLingua2BertMultilingualOfficialAdapter",
+    "LLMLingua2Config",
+    "LLMLingua2OfficialAdapter",
+    "LongLLMLinguaConfig",
+    "LongLLMLinguaControlled",
+    "LongLLMLinguaControlledBindings",
+    "LongLLMLinguaOfficialAdapter",
+    "RECOMPAbstractiveControls",
+    "RECOMPAbstractiveExternal",
+    "RECOMPExtractiveControls",
+    "RECOMPExtractiveExternal",
+    "RECOMPSentenceScore",
+    "SpanMapping",
+    "parse_context_budget",
+]

agentinputlab/algorithms/curate/acon/__init__.py

@@ -0,0 +1,27 @@
+"""ACON history- and observation-runtime adapters."""
+
+from .common import (
+    ACON_UPSTREAM_COMMIT,
+    ACONArtifactIdentity,
+    ACONHistoryControls,
+    ACONObservationControls,
+)
+from .common_support import (
+    ACON_COMMON_SUPPORT_CONTEXT_RULE,
+    ACON_COMMON_SUPPORT_RELEASE,
+    ACONObservationCommonSupport,
+)
+from .history_bridge import ACONHistoryRuntimeExternal
+from .observation_bridge import ACONObservationRuntimeExternal
+
+__all__ = [
+    "ACON_COMMON_SUPPORT_CONTEXT_RULE",
+    "ACON_COMMON_SUPPORT_RELEASE",
+    "ACON_UPSTREAM_COMMIT",
+    "ACONArtifactIdentity",
+    "ACONHistoryControls",
+    "ACONHistoryRuntimeExternal",
+    "ACONObservationCommonSupport",
+    "ACONObservationControls",
+    "ACONObservationRuntimeExternal",
+]

agentinputlab/algorithms/curate/acon/common.py

@@ -0,0 +1,284 @@
+"""Shared controls and source-faithful helpers for ACON runtime bridges."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any
+
+from agentinputlab.contracts import (
+    AlgorithmOutputError,
+    Message,
+    ValidationError,
+)
+from agentinputlab.contracts.serialization import content_hash
+from agentinputlab.integrations.external_workers.method import (
+    dependency_fingerprint,
+    nonnegative_integer,
+    required_text,
+)
+
+ACON_UPSTREAM_COMMIT = "d63f9ae18959dc7215ff62899c94c5e8c56847ae"
+ACON_HISTORY_PROTOCOL = "agentinputlab.acon.history.v2"
+ACON_OBSERVATION_PROTOCOL = "agentinputlab.acon.observation.v2"
+ACON_RESERVED_OPT_ARGS = frozenset({"task", "observation", "history"})
+
+
+@dataclass(frozen=True, slots=True)
+class ACONArtifactIdentity:
+    """Frozen identities required for a fair ACON runtime comparison."""
+
+    optimizer_model_revision: str
+    target_model_revision: str
+    tokenizer_revision: str
+    prompt_artifact_hash: str
+    guideline_artifact_hash: str
+    optimizer_deployment_fingerprint_hash: str
+    target_backend_fingerprint_hash: str
+    tokenizer_fingerprint_hash: str
+
+    def __post_init__(self) -> None:
+        for name in (
+            "optimizer_model_revision",
+            "target_model_revision",
+            "tokenizer_revision",
+            "prompt_artifact_hash",
+            "guideline_artifact_hash",
+            "optimizer_deployment_fingerprint_hash",
+            "target_backend_fingerprint_hash",
+            "tokenizer_fingerprint_hash",
+        ):
+            value = getattr(self, name)
+            if not isinstance(value, str) or not value.strip():
+                raise ValidationError(f"ACON {name} must not be empty")
+            if name.endswith("_hash") and (
+                len(value) != 64 or any(character not in "0123456789abcdef" for character in value)
+            ):
+                raise ValidationError(f"ACON {name} must be a lowercase SHA-256 digest")
+
+    def as_payload(self) -> dict[str, str]:
+        return {
+            "optimizer_model_revision": self.optimizer_model_revision,
+            "target_model_revision": self.target_model_revision,
+            "tokenizer_revision": self.tokenizer_revision,
+            "prompt_artifact_hash": self.prompt_artifact_hash,
+            "guideline_artifact_hash": self.guideline_artifact_hash,
+            "optimizer_deployment_fingerprint_hash": (self.optimizer_deployment_fingerprint_hash),
+            "target_backend_fingerprint_hash": self.target_backend_fingerprint_hash,
+            "tokenizer_fingerprint_hash": self.tokenizer_fingerprint_hash,
+        }
+
+
+def target_backend_fingerprint(
+    backend: Any,
+    identity: ACONArtifactIdentity,
+) -> Mapping[str, Any]:
+    """Bind the actual target backend deployment to the declared ACON artifact."""
+
+    fingerprint = dependency_fingerprint(backend, label="ACON target backend", required=True)
+    if content_hash(fingerprint) != identity.target_backend_fingerprint_hash:
+        raise ValidationError(
+            "ACON target backend fingerprint disagrees with the frozen artifact identity"
+        )
+    if identity.target_model_revision not in _fingerprint_text_values(fingerprint):
+        raise ValidationError(
+            "ACON target_model_revision is not attested by the target backend fingerprint"
+        )
+    return fingerprint
+
+
+def validate_runtime_identity(
+    payload: Mapping[str, Any],
+    identity: ACONArtifactIdentity,
+) -> tuple[str, str, Mapping[str, Any]]:
+    """Validate worker profile, manifest and runtime-attestation echoes."""
+
+    validate_artifact_echo(payload, identity)
+    profile_id = required_text(payload, "profile_id", label="ACON response")
+    manifest_hash = required_text(
+        payload,
+        "compatibility_manifest_sha256",
+        label="ACON response",
+    )
+    if len(manifest_hash) != 64 or any(
+        character not in "0123456789abcdef" for character in manifest_hash
+    ):
+        raise AlgorithmOutputError("ACON compatibility manifest identity is invalid")
+    attestation = payload.get("runtime_attestation")
+    if not isinstance(attestation, Mapping):
+        raise AlgorithmOutputError("ACON response requires runtime_attestation")
+    expected = {
+        "optimizer_deployment_fingerprint_hash": (identity.optimizer_deployment_fingerprint_hash),
+        "target_backend_fingerprint_hash": identity.target_backend_fingerprint_hash,
+        "tokenizer_fingerprint_hash": identity.tokenizer_fingerprint_hash,
+    }
+    if dict(attestation) != expected:
+        raise AlgorithmOutputError("ACON runtime attestation disagrees with frozen artifacts")
+    return profile_id, manifest_hash, attestation
+
+
+def _fingerprint_text_values(value: Any) -> set[str]:
+    values: set[str] = set()
+    if isinstance(value, str):
+        values.add(value)
+    elif isinstance(value, Mapping):
+        for item in value.values():
+            values.update(_fingerprint_text_values(item))
+    elif isinstance(value, (tuple, list)):
+        for item in value:
+            values.update(_fingerprint_text_values(item))
+    return values
+
+
+@dataclass(frozen=True, slots=True)
+class ACONHistoryControls:
+    summarization_threshold: int = -1
+    preserve_last_k_turns: int = 1
+    summary_rule: str = "accumulate"
+    summary_interval: int = -1
+    history_version: int = 1
+
+    def __post_init__(self) -> None:
+        _validate_threshold(self.summarization_threshold)
+        if (
+            isinstance(self.preserve_last_k_turns, bool)
+            or not isinstance(self.preserve_last_k_turns, int)
+            or self.preserve_last_k_turns < 0
+        ):
+            raise ValidationError("ACON preserve_last_k_turns must be non-negative")
+        if self.summary_rule not in {"accumulate", "reset"}:
+            raise ValidationError("ACON summary_rule must be accumulate or reset")
+        if (
+            isinstance(self.summary_interval, bool)
+            or not isinstance(self.summary_interval, int)
+            or (self.summary_interval != -1 and self.summary_interval < 1)
+        ):
+            raise ValidationError("ACON summary_interval must be -1 or positive")
+        if (
+            isinstance(self.history_version, bool)
+            or not isinstance(self.history_version, int)
+            or self.history_version != 1
+        ):
+            raise ValidationError(
+                "pinned ACON MemoryManager does not wire history_version to V2; use version 1"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class ACONObservationControls:
+    summarization_threshold: int = -1
+    context_index: int = -1
+    add_previous_history_summary: bool = False
+    observation_version: int = 1
+
+    def __post_init__(self) -> None:
+        _validate_threshold(self.summarization_threshold)
+        if isinstance(self.context_index, bool) or not isinstance(self.context_index, int):
+            raise ValidationError("ACON context_index must be an integer")
+        if not isinstance(self.add_previous_history_summary, bool):
+            raise ValidationError("ACON add_previous_history_summary must be boolean")
+        if (
+            isinstance(self.observation_version, bool)
+            or not isinstance(self.observation_version, int)
+            or self.observation_version != 1
+        ):
+            raise ValidationError(
+                "pinned ACON MemoryManager does not wire obs_version to V2; use version 1"
+            )
+
+
+def validate_artifact_echo(payload: Mapping[str, Any], identity: ACONArtifactIdentity) -> None:
+    for key, expected in identity.as_payload().items():
+        if required_text(payload, key, label="ACON response") != expected:
+            raise AlgorithmOutputError(f"ACON {key} mismatch")
+
+
+def validate_threshold_response(
+    payload: Mapping[str, Any],
+    *,
+    threshold: int,
+) -> tuple[int, bool]:
+    token_count = nonnegative_integer(
+        payload.get("raw_input_tokens"), label="ACON raw_input_tokens"
+    )
+    expected = threshold == -1 or token_count > threshold
+    triggered = payload.get("threshold_triggered")
+    if not isinstance(triggered, bool):
+        raise AlgorithmOutputError("ACON threshold_triggered must be boolean")
+    if triggered is not expected:
+        comparator = "always" if threshold == -1 else "strictly_greater_than"
+        raise AlgorithmOutputError(
+            f"ACON threshold decision must use upstream {comparator} semantics"
+        )
+    return token_count, triggered
+
+
+def history_text(messages: tuple[Message, ...]) -> str:
+    """Mirror ``MemoryManager.convert_llm_history_to_text`` for v1."""
+
+    parts: list[str] = []
+    for index, message in enumerate(messages):
+        if index == 1 and message.role == "user":
+            continue
+        if message.role == "user":
+            parts.append(f"USER:\n{message.content}\n\n")
+        elif message.role == "assistant":
+            parts.append(f"ASSISTANT:\n{message.content}\n\n")
+    return "".join(parts).strip()
+
+
+def preserved_turn_indices(
+    messages: tuple[Message, ...], preserve_last_k_turns: int
+) -> tuple[int, ...]:
+    """Mirror ACON's assistant/user-pair scan without mutating session state."""
+
+    if not messages or preserve_last_k_turns <= 0:
+        return ()
+    turns: list[int] = []
+    index = len(messages) - 1
+    count = 0
+    while index >= 0 and count < preserve_last_k_turns:
+        if messages[index].role != "user":
+            index -= 1
+            continue
+        user_index = index
+        assistant_index = index - 1
+        while assistant_index >= 0 and messages[assistant_index].role != "assistant":
+            assistant_index -= 1
+        if assistant_index >= 0:
+            turns[0:0] = (assistant_index, user_index)
+            count += 1
+            index = assistant_index - 1
+        else:
+            turns.insert(0, user_index)
+            count += 1
+            index -= 1
+    first_user_content = messages[1].content if len(messages) > 1 else ""
+    return tuple(
+        item
+        for item in turns
+        if messages[item].role != "system"
+        and not (messages[item].role == "user" and messages[item].content == first_user_content)
+    )
+
+
+def _validate_threshold(value: int) -> None:
+    if isinstance(value, bool) or not isinstance(value, int) or value < -1:
+        raise ValidationError("ACON summarization threshold must be -1 or non-negative")
+
+
+__all__ = [
+    "ACON_HISTORY_PROTOCOL",
+    "ACON_OBSERVATION_PROTOCOL",
+    "ACON_RESERVED_OPT_ARGS",
+    "ACON_UPSTREAM_COMMIT",
+    "ACONArtifactIdentity",
+    "ACONHistoryControls",
+    "ACONObservationControls",
+    "history_text",
+    "preserved_turn_indices",
+    "target_backend_fingerprint",
+    "validate_artifact_echo",
+    "validate_runtime_identity",
+    "validate_threshold_response",
+]