iCode-TUI 0.29.1__py3-none-any.whl

chrys/service/profiles/models/resolver.py

@@ -0,0 +1,286 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Model profile resolution — pick the active profile for a given role.
+
+Resolution lives here (rather than in ``ModelProfileRegistry``) so the
+registry stays a pure data store.  Callers (``AgentEngine``, sub-agent
+construction, the approval judge, the buddy's replies) ask the resolver
+for the right ``ModelProfile`` to use; resolution policy can grow new
+roles or override layers without touching the registry.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, replace
+from typing import TYPE_CHECKING, Any, Literal
+
+from chrys.service.profiles.models.schema import (
+    DEFAULT_MAX_CONTEXT_TOKENS,
+    UNCONFIGURED_MODEL_ID,
+    ModelProfile,
+    is_model_profile_selectable,
+)
+
+if TYPE_CHECKING:
+    from chrys.foundation.config.settings import Settings
+    from chrys.foundation.config.settings_store import LoadedSettings
+    from chrys.foundation.config.spec import Source
+    from chrys.service.profiles.agents.schema import AgentProfile
+    from chrys.service.profiles.models.registry import ModelProfileRegistry
+
+_log = logging.getLogger(__name__)
+
+
+# Hardcoded fallback used when no profile is registered or the active
+# profile id can't be found.  ``model_id`` is deliberately set to a
+# non-functional placeholder — first-run without configuration should
+# fail loudly (the LLM API will reject "<Model Not Configured>") rather
+# than silently picking an arbitrary model the user may not want.
+_DEFAULT_PROFILE = ModelProfile(
+    id="",
+    name="Default",
+    provider="openai",
+    model_id=UNCONFIGURED_MODEL_ID,
+    max_context_tokens=DEFAULT_MAX_CONTEXT_TOKENS,
+    http_connect_timeout=10.0,
+    http_read_timeout=600.0,
+    http_max_retries=2,
+    stream=False,
+    vision=False,
+)
+
+
+@dataclass(frozen=True)
+class ModelSelection:
+    """A resolved model profile together with the policy branch that selected it."""
+
+    profile: ModelProfile
+    source: Literal["override", "agent", "inherited", "active", "default"]
+
+
+def default_profile() -> ModelProfile:
+    """Return a copy of the built-in fallback ``ModelProfile``.
+
+    Returned as a fresh instance so callers can mutate without affecting
+    the module-level singleton.
+    """
+    return replace(_DEFAULT_PROFILE)
+
+
+def resolve_profile_selector(registry: ModelProfileRegistry | None, selector: str) -> ModelProfile | None:
+    """Resolve a model profile selector by id or unique name."""
+    if registry is None:
+        return None
+    profile = registry.get(selector)
+    if profile is not None:
+        return profile
+
+    profiles = registry.list_profiles()
+    exact_name_matches = [profile for profile in profiles if profile.name == selector]
+    if len(exact_name_matches) == 1:
+        return exact_name_matches[0]
+    if len(exact_name_matches) > 1:
+        _log.warning("Model profile name %r is ambiguous; use a profile id instead", selector)
+        return None
+
+    folded = selector.casefold()
+    folded_name_matches = [profile for profile in profiles if profile.name.casefold() == folded]
+    if len(folded_name_matches) == 1:
+        return folded_name_matches[0]
+    if len(folded_name_matches) > 1:
+        _log.warning("Model profile name %r is ambiguous ignoring case; use a profile id instead", selector)
+    return None
+
+
+def resolve_selectable_profile(registry: ModelProfileRegistry | None, selector: str) -> ModelProfile | None:
+    """Resolve a selector to a structurally selectable profile, or ``None``.
+
+    A pointer that resolves to a stored-but-hollow profile (blank
+    ``model_id`` — e.g. an auto-seeded "Profile 1" the user never filled
+    in) is as unusable as a dangling one, so both map to ``None``.
+    """
+    profile = resolve_profile_selector(registry, selector)
+    if profile is None or not is_model_profile_selectable(profile):
+        return None
+    return profile
+
+
+def format_available_profile_labels(registry: ModelProfileRegistry) -> str:
+    """Return a compact human-facing list of available model profiles."""
+    profiles = sorted(registry.list_profiles(), key=lambda profile: profile.name.casefold())
+    return ", ".join(f"{profile.name} ({profile.id})" for profile in profiles)
+
+
+def settings_with_active_model_profile(settings: Settings, profile: ModelProfile) -> Settings:
+    """Return ``settings`` with the active fallback model profile set to ``profile``."""
+    return replace(settings, **_active_model_profile_fields(profile))
+
+
+def loaded_with_active_model_profile(loaded: LoadedSettings, profile: ModelProfile, layer: Source) -> LoadedSettings:
+    """Same selection, credited to the layer that made it.
+
+    ``--model`` is a command-line argument and a mid-session switch is not, so
+    the panel has to be able to tell them apart; both used to arrive as an
+    anonymous ``replace()`` and read back as whatever the file layers had said.
+    """
+    return loaded.overlay(layer, **_active_model_profile_fields(profile))
+
+
+def _active_model_profile_fields(profile: ModelProfile) -> dict[str, Any]:
+    """The fields selecting *profile* as the active fallback, in one place."""
+    return {
+        "model_profile": profile.id,
+        "model_profile_override": "",
+        "model_profile_override_sub_agents": False,
+    }
+
+
+def _resolve_active_selection(
+    registry: ModelProfileRegistry | None,
+    settings: Settings,
+) -> ModelSelection:
+    if registry is None or not settings.model_profile:
+        return ModelSelection(default_profile(), "default")
+    profile = resolve_profile_selector(registry, settings.model_profile)
+    if profile is None:
+        _log.warning(
+            "Active model profile %r not found in registry by id or name, falling back to default",
+            settings.model_profile,
+        )
+        return ModelSelection(default_profile(), "default")
+    if not is_model_profile_selectable(profile):
+        # A stored-but-hollow profile (e.g. an auto-seeded "Profile 1" that
+        # was never filled in) must not become the confirmed runtime model:
+        # its blank model_id would slip past the send guard whenever some
+        # other selectable profile exists.
+        _log.warning(
+            "Active model profile %r is not selectable (incomplete fields), falling back to default",
+            settings.model_profile,
+        )
+        return ModelSelection(default_profile(), "default")
+    return ModelSelection(profile, "active")
+
+
+def resolve_active_profile(
+    registry: ModelProfileRegistry | None,
+    settings: Settings,
+) -> ModelProfile:
+    """Resolve the main agent's active ``ModelProfile``.
+
+    Looks up ``settings.model_profile`` (the active profile id or unique name) in the
+    registry.  Falls back to :func:`default_profile` if the registry is
+    missing, the id is empty, or the id is not registered.
+    """
+    return _resolve_active_selection(registry, settings).profile
+
+
+def resolve_judge_profile(
+    registry: ModelProfileRegistry | None,
+    settings: Settings,
+    fallback: ModelProfile,
+) -> ModelProfile:
+    """Resolve the approval judge's ``ModelProfile``.
+
+    Preference order:
+      1. ``settings.approval_judge_model_profile``
+         (env: ``CHRYS_MODEL_PROFILE_APPROVAL_JUDGE``), matched by id or
+         unique name — the same selector syntax every side-call profile
+         env var accepts.
+      2. ``fallback`` (typically the main agent's active profile)
+    """
+    selector = settings.approval_judge_model_profile
+    if not selector or registry is None:
+        return fallback
+    profile = resolve_profile_selector(registry, selector)
+    if profile is None:
+        _log.warning(
+            "Approval judge model profile %r not found in registry, using main agent profile",
+            selector,
+        )
+        return fallback
+    return profile
+
+
+def resolve_session_title_profile(
+    registry: ModelProfileRegistry | None,
+    settings: Settings,
+    fallback: ModelProfile,
+) -> ModelProfile:
+    """Resolve the session-title summarizer's ``ModelProfile``.
+
+    Preference order:
+      1. ``settings.session_title_model_profile``
+         (env: ``CHRYS_MODEL_PROFILE_SESSION_TITLE``), matched by id or
+         unique name.
+      2. ``fallback`` (typically the main agent's active profile).
+    """
+    selector = settings.session_title_model_profile
+    if not selector or registry is None:
+        return fallback
+    profile = resolve_profile_selector(registry, selector)
+    if profile is None:
+        _log.warning(
+            "Session title model profile %r not found in registry by id or name, using the active profile",
+            selector,
+        )
+        return fallback
+    return profile
+
+
+def resolve_selection_for_agent(
+    registry: ModelProfileRegistry | None,
+    settings: Settings,
+    agent_profile: AgentProfile,
+    *,
+    fallback: ModelProfile | None = None,
+) -> ModelSelection:
+    """Resolve a model profile and its selection source for an agent.
+
+    Precedence (first match wins):
+
+    1. ``settings.model_profile_override`` if non-empty and either resolving
+       the main agent or ``settings.model_profile_override_sub_agents`` is true.
+       This id/name selector is reserved for explicit per-session overrides
+       such as ACP session model switches.
+    2. ``agent_profile.model.profile_id`` if non-empty **and** the id is
+       registered.  A set-but-missing id (e.g. the referenced profile was
+       deleted) logs a warning and falls through — never raises.
+    3. ``fallback`` if provided (sub-agents pass the parent's resolved
+       profile here so they transparently inherit).
+    4. :func:`resolve_active_profile` — the session-active profile from
+       ``settings.model_profile``.
+    """
+    if settings.model_profile_override and (fallback is None or settings.model_profile_override_sub_agents):
+        profile = resolve_profile_selector(registry, settings.model_profile_override)
+        if profile is not None:
+            return ModelSelection(profile, "override")
+        _log.warning(
+            "Explicit model profile override %r not found in registry by id or name, falling back to default",
+            settings.model_profile_override,
+        )
+        return ModelSelection(default_profile(), "override")
+    pid = agent_profile.model.profile_id if agent_profile.model else ""
+    if pid and registry is not None:
+        profile = registry.get(pid)
+        if profile is not None:
+            return ModelSelection(profile, "agent")
+        _log.warning(
+            "Agent %r references model profile id %r which is not registered; falling back to the active profile.",
+            agent_profile.name,
+            pid,
+        )
+    if fallback is not None:
+        return ModelSelection(fallback, "inherited")
+    return _resolve_active_selection(registry, settings)
+
+
+def resolve_for_agent(
+    registry: ModelProfileRegistry | None,
+    settings: Settings,
+    agent_profile: AgentProfile,
+    *,
+    fallback: ModelProfile | None = None,
+) -> ModelProfile:
+    """Resolve the ``ModelProfile`` for a given ``AgentProfile``."""
+    return resolve_selection_for_agent(registry, settings, agent_profile, fallback=fallback).profile

chrys/service/profiles/models/schema.py

@@ -0,0 +1,91 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""ModelProfile data model — defines the structure of a model profile configuration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+API_STYLE_CHAT_COMPLETIONS = "chat_completions"
+API_STYLE_RESPONSES = "responses"
+VALID_API_STYLES = frozenset({API_STYLE_CHAT_COMPLETIONS, API_STYLE_RESPONSES})
+VALID_PROVIDERS = frozenset({"openai", "anthropic", "deepseek-openai", "glm-openai", "mock"})
+UNCONFIGURED_MODEL_ID = "<Model Not Configured>"
+ApiStyle = Literal["chat_completions", "responses"]
+ThinkingBlockBinding = Literal["auto", "drop_block", "error", "off"]
+VALID_THINKING_BLOCK_BINDINGS: frozenset[str] = frozenset({"auto", "drop_block", "error", "off"})
+
+# Default per-response output-token cap for every provider.  Applied as the
+# live ``max_tokens`` default (``effective_chat_options``) and as the
+# LAST_WORDS note-call ceiling; models with a lower provider hard cap
+# (e.g. DeepSeek chat 8192) need an explicit lower value on the profile.
+DEFAULT_MAX_OUTPUT_TOKENS = 32_000
+DEFAULT_MAX_CONTEXT_TOKENS = 200_000
+
+
+@dataclass
+class ModelProfile:
+    """A named model configuration profile.
+
+    Each profile stores all settings needed to connect to an LLM provider:
+    provider, OpenAI API style, model ID, API credentials, HTTP transport
+    tuning, and extra options.  Profiles are stored as YAML files in
+    ``~/.chrys/models/`` with UUID-based filenames.
+    """
+
+    id: str  # UUID hex — disk filename stem
+    name: str  # Human-readable display name
+    provider: str = "openai"  # "openai", "anthropic", "deepseek-openai", or "glm-openai"
+    api_style: ApiStyle = API_STYLE_CHAT_COMPLETIONS  # OpenAI-compatible API wire style
+    model_id: str = ""  # Provider-specific model identifier (must be set before use)
+    max_context_tokens: int = DEFAULT_MAX_CONTEXT_TOKENS
+    max_output_tokens: int = DEFAULT_MAX_OUTPUT_TOKENS  # Output cap, always positive; live max_tokens default
+    base_url: str = ""
+    api_key: str = ""
+    http_connect_timeout: float = 10.0  # Provider connection timeout in seconds
+    http_read_timeout: float = 300.0  # Provider read timeout in seconds
+    http_max_retries: int = 2  # SDK-internal retries on top of the initial HTTP request
+    verify_ssl: bool = True  # Set False to skip TLS certificate verification (insecure)
+    bypass_proxy: bool = False  # Route this profile's LLM traffic around configured proxies
+    http_headers: str = ""  # JSON object of additional provider HTTP headers
+    chat_options: str = ""  # JSON object of provider request options
+    stream: bool = True  # Stream response
+    vision: bool = False  # Supports image input
+    # Chat Completions: a stream that ends without a finish reason fails as
+    # truncated instead of being accepted with a warning.
+    stream_requires_finish_reason: bool = False
+    # Anthropic: what a request tells the service to do with replayed thinking
+    # that no longer matches the conversation before it ("auto" chooses).
+    thinking_block_binding: ThinkingBlockBinding = "auto"
+    # Anthropic: add the interleaved-thinking beta to budgeted thinking.
+    auto_interleaved_thinking: bool = True
+
+
+def is_model_profile_selectable(profile: ModelProfile) -> bool:
+    """Return whether a profile is structurally complete enough to select."""
+    string_fields = (profile.id, profile.name, profile.provider, profile.api_style, profile.model_id)
+    if not all(isinstance(value, str) for value in string_fields):
+        return False
+    if not profile.id.strip() or not profile.name.strip():
+        return False
+    if profile.provider not in VALID_PROVIDERS or profile.api_style not in VALID_API_STYLES:
+        return False
+    if profile.provider != "mock" and (
+        not profile.model_id.strip() or profile.model_id.strip() == UNCONFIGURED_MODEL_ID
+    ):
+        return False
+    return all(
+        isinstance(value, int) and not isinstance(value, bool) and value > 0
+        for value in (profile.max_context_tokens, profile.max_output_tokens)
+    )
+
+
+def is_responses_wire_dialect(provider: str, api_style: str) -> bool:
+    """Return whether a provider uses the OpenAI Responses wire shape."""
+    return provider in {"openai", "deepseek-openai"} and api_style == API_STYLE_RESPONSES
+
+
+def uses_responses_wire_dialect(profile: ModelProfile) -> bool:
+    """Return whether a model profile uses the OpenAI Responses wire shape."""
+    return is_responses_wire_dialect(profile.provider, profile.api_style)

chrys/service/profiles/models/serializer.py

@@ -0,0 +1,76 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Model profile serializer — convert ModelProfile dataclasses to YAML-ready dicts."""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import MISSING, fields
+from typing import TYPE_CHECKING, Any
+
+from chrys.foundation.text.yaml_io import dump_yaml
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from chrys.service.profiles.models.schema import ModelProfile
+
+logger = logging.getLogger(__name__)
+
+
+def profile_to_dict(profile: ModelProfile) -> dict[str, Any]:
+    """Serialize a ModelProfile to a dict suitable for ``yaml.dump()``.
+
+    Fields at their default value are omitted (except ``id`` and ``name``
+    which are always emitted).
+    """
+    result: dict[str, Any] = {}
+    always_emit = {"id", "name"}
+    for f in fields(profile):
+        val = getattr(profile, f.name)
+        if f.name not in always_emit:
+            if f.default is not MISSING and val == f.default:
+                continue
+            if f.default_factory is not MISSING:
+                try:
+                    if val == f.default_factory():
+                        continue
+                except TypeError:
+                    pass
+        result[f.name] = val
+    return result
+
+
+def _user_profiles_dir() -> Path:
+    """Return the user model profiles directory."""
+    from chrys.foundation.platform import get_platform
+
+    return get_platform().config_dir / "models"
+
+
+def save_profile(profile: ModelProfile) -> Path:
+    """Serialize *profile* to YAML and write to ``~/.chrys/models/{id}.yaml``.
+
+    Returns the path written.
+    """
+    target_dir = _user_profiles_dir()
+    target_dir.mkdir(parents=True, exist_ok=True)
+    path = target_dir / f"{profile.id}.yaml"
+    data = profile_to_dict(profile)
+    text = dump_yaml(data)
+    path.write_text(text, encoding="utf-8")
+    logger.debug("Saved model profile to %s", path)
+    return path
+
+
+def delete_profile(profile_id: str) -> bool:
+    """Delete the model profile YAML file for *profile_id*.
+
+    Returns True if the file existed and was removed, False otherwise.
+    """
+    path = _user_profiles_dir() / f"{profile_id}.yaml"
+    if path.is_file():
+        path.unlink()
+        logger.debug("Deleted model profile %s", path)
+        return True
+    return False

chrys/service/session/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Session lifecycle, history, and persistence helpers."""

chrys/service/session/checkpoint.py

@@ -0,0 +1,156 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Crash-recovery checkpoint shaping for in-flight session turns."""
+
+from __future__ import annotations
+
+import copy
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+from chrys.foundation.i18n.formatting import format_message
+from chrys.foundation.models.history_markers import SESSION_CLOSED_MESSAGE, HistoryMarkerKind
+from chrys.foundation.trajectory.metadata import read_analytics_item_id
+from chrys.service.agent_middleware.reminders.archive_pointer import CATALOG_POINTER_RECORD_COUNT_STATE_KEY
+from chrys.service.session.history import SessionHistoryManager, stamp_history_item_ids
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+    from chrys.foundation.models.turns import UserMessageKind
+    from chrys.kernel import LoopRecorder
+    from chrys.service.agent_middleware.injection import ConsumedInjection
+    from chrys.service.mutations.tracker import MutationTracker
+    from chrys.service.session.runtime_metadata import SessionRuntimeMetadata
+
+
+class _DetachedLoopRecorder:
+    """Recorder view whose mergeable messages cannot mutate live framework objects."""
+
+    def __init__(self, loop_recorder: LoopRecorder) -> None:
+        self.initial_count = loop_recorder.initial_count
+        loop_messages = loop_recorder.loop_messages
+        self.loop_messages = copy.deepcopy(loop_messages) if loop_messages is not None else None
+        # Only used for debug logging in ``merge_loop_messages`` when no loop messages exist.
+        self.captured_count = None if self.loop_messages is None else len(self.loop_messages)
+
+
+def shape_checkpoint_interruption(
+    manager: SessionHistoryManager,
+    loop_recorder: LoopRecorder,
+    *,
+    source: str = "",
+    consumed_injections: list[ConsumedInjection] | None = None,
+    insert_index: int | None = None,
+) -> None:
+    """Shape history into canonical interrupted form without draining live state.
+
+    Merge recorder messages before replaying injections: the recorder may
+    already contain the clean wire copy carried across a tool iteration.
+    Replay can then deduplicate against the complete attempt before trimming.
+    """
+    manager.merge_loop_messages(_DetachedLoopRecorder(loop_recorder), insert_index=insert_index)
+    if consumed_injections:
+        manager.replay_consumed_injections(consumed_injections)
+    manager.trim_to_last_complete_tool_results()
+    manager.remove_trailing_agent_text()
+    manager.insert_interrupted_marker(
+        reason=format_message(SESSION_CLOSED_MESSAGE.bind()),
+        source=source,
+        status_code=HistoryMarkerKind.STATUS_SESSION_CLOSED,
+    )
+    manager.insert_turn_marker()
+
+
+def build_recovery_state(
+    live_state: dict[str, Any] | None,
+    loop_recorder: LoopRecorder,
+    *,
+    mutation_tracker: MutationTracker | None,
+    runtime_meta: SessionRuntimeMetadata,
+    user_text: str | None,
+    user_contents: list[Any] | None,
+    user_created_at: datetime | str | None,
+    user_kind: UserMessageKind = "opener",
+    user_reminder_source: Mapping[str, Any] | None = None,
+    consumed_injections: list[ConsumedInjection] | None = None,
+    insert_index: int | None = None,
+    last_words: str | None = None,
+    last_words_manifest: list[dict[str, Any]] | None = None,
+    last_words_breaker: dict[str, Any] | None = None,
+    catalog_pointer_record_count: int | None = None,
+    todos: list[dict[str, str]] | None = None,
+) -> dict[str, Any] | None:
+    """Return an interrupted-shaped recovery state for the current turn.
+
+    The result goes to a writer thread while the turn keeps changing live
+    state, so it shares no mutable object with any input. That holds with one
+    whole-history copy: ``live_state`` is deep-copied once, every value merged
+    over that copy is deep-copied on its own, ``_DetachedLoopRecorder`` copies
+    the recorder's loop messages, and shaping adds only objects it mints
+    (markers, replayed injection messages). A new merged input needs its own
+    copy; ``tests/architecture/test_copy_freshness.py`` walks the result for
+    objects shared with the inputs.
+    """
+    if live_state is None:
+        return None
+
+    copied = copy.deepcopy(live_state)
+    if mutation_tracker is not None:
+        copied["chrys_mutations"] = copy.deepcopy(mutation_tracker.serialize())
+    copied.update(copy.deepcopy(runtime_meta.to_state_dict()))
+    # The Phase 4 LAST_WORDS note replaces the dropped tool-call history of
+    # the in-flight turn — recovering without it would resume from an
+    # amputated transcript.
+    if last_words:
+        copied["last_words"] = last_words
+    else:
+        copied.pop("last_words", None)
+    if last_words_manifest:
+        copied["last_words_manifest"] = copy.deepcopy(last_words_manifest)
+    else:
+        copied.pop("last_words_manifest", None)
+    # Breaker truth is unconditional: failed attempts commonly have no note
+    # or manifest, and must still survive a crash/retry boundary.
+    if last_words_breaker:
+        copied["last_words_breaker"] = copy.deepcopy(last_words_breaker)
+    else:
+        copied.pop("last_words_breaker", None)
+    if catalog_pointer_record_count is not None:
+        copied[CATALOG_POINTER_RECORD_COUNT_STATE_KEY] = catalog_pointer_record_count
+    else:
+        copied.pop(CATALOG_POINTER_RECORD_COUNT_STATE_KEY, None)
+    if todos:
+        copied["chrys_todos"] = copy.deepcopy(todos)
+    else:
+        copied.pop("chrys_todos", None)
+
+    manager = SessionHistoryManager()
+    stamp_history_item_ids(copied)
+    manager.bind(copied)
+    if user_text or user_contents:
+        # The recorded prompt contents are the live turn's objects; the
+        # reminder record is copied entry by entry. The live input's item id
+        # is the one the trajectory announced, so the rebuilt copy keeps it.
+        manager.ensure_user_message(
+            user_text or "",
+            created_at=user_created_at,
+            contents=copy.deepcopy(user_contents),
+            kind=user_kind,
+            item_id=read_analytics_item_id(user_reminder_source),
+            reminder_source=user_reminder_source,
+        )
+    # Consumed injections reach history only at finalization, so a mid-run
+    # checkpoint must replay them or a hard crash loses them. Replay belongs
+    # after recorder merge but before trimming and terminal markers. They need
+    # no copy: replay reads their immutable text, ids and timestamps into
+    # messages it mints, copies their live reminder record entry by entry,
+    # and never merges an injection object itself.
+    shape_checkpoint_interruption(
+        manager,
+        loop_recorder,
+        source="",
+        consumed_injections=consumed_injections,
+        insert_index=insert_index,
+    )
+    return copied