Skip to content

armgit / avibe

Public Imported from GitHub
0

Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.

12.6 KB
Raw Blame
"""C-5 orphan/ancestry projection risks not covered by message serialization."""

from copy import deepcopy

import pytest

from core.agent_core.harness.projection import INTERRUPTED, ProjectionError, context_view, project
from core.agent_core.harness.store import ContextEntry
from core.agent_core.messages import ImageBlock, ToolCallBlock, ToolResultMessage, UserMessage, text
from tests.agent_core.fakes import assistant, user


def test_unsettled_projection_is_deterministic_and_preserves_signed_calls():
    call = ToolCallBlock("call", "bash", signature="opaque Gemini signature")
    owner = ContextEntry("parent", 1, "response", "response", assistant(calls=[call]))
    rows = [owner]
    before = deepcopy(rows)
    projected = project(rows)
    assert projected == project(rows)
    assert projected.messages[0].tool_calls[0].signature == "opaque Gemini signature"
    assert projected.messages[1].content[0].text == INTERRUPTED
    assert projected.messages[1].is_error
    assert rows == before


def test_projection_sorts_rows_cuts_at_fork_restores_state_and_places_results_in_call_order():
    calls = [ToolCallBlock("a", "echo"), ToolCallBlock("b", "echo")]
    rows = [
        ContextEntry("parent", 1, "input", "input", user("start")),
        ContextEntry("parent", 2, "response", "response", assistant(calls=calls)),
        ContextEntry("parent", 3, "tool_result", "result-b", ToolResultMessage("b", "echo", (text("b"),))),
        ContextEntry("parent", 4, "agent_state", "state", payload={"version": 1, "state": {"counter": [1]}}),
        ContextEntry("child", 5, "input", "child-input", user("child")),
        ContextEntry("parent", 6, "context_edit", "later-edit", payload={}),
    ]
    output = project(list(reversed(rows)), fork_point=5, system="rebuilt system", rehydrated=[user("rehydrated")])
    assert output.system == "rebuilt system"
    assert output.context_seq == 5
    assert [getattr(message, "tool_call_id", None) for message in output.messages] == [None, None, None, "a", "b", None]
    assert output.messages[3].content[0].text == INTERRUPTED
    assert output.messages[4].content[0].text == "b"
    output.state["counter"].append(2)
    assert rows[3].payload["state"] == {"counter": [1]}


def _edit(seq, row_id, target, replacement):
    payload = {
        "version": 1,
        "target_event_id": target,
        "replacement": {"text": replacement},
        "reason": "clear_old_tool_result",
    }
    return ContextEntry("session", seq, "context_edit", row_id, payload=payload)


def _checkpoint_payload(first_kept_seq, *, summary="SUMMARY", state=("STATE",), **fields):
    payload = {
        "version": 1,
        "mode": "normal",
        "reason": "threshold",
        "summary": summary,
        "checkpoint": "checkpoint",
        "state": list(state),
        "first_kept_seq": first_kept_seq,
        "summarized_to_seq": first_kept_seq - 1,
        "previous_compaction_id": None,
        "kept_inputs": [],
        "files_read": ["a.py"],
        "files_modified": [],
        "files_modified_omitted": False,
        "files_read_omitted": False,
        "skills_omitted": False,
        "skills": [{"name": "s"}],
        "tokens_before": 10,
        "tokens_after_estimate": 5,
        "threshold": 8,
        "summarizer": {"origin": {"provider": "p", "api": "anthropic", "model": "m"}, "prompt_version": "v", "rounds": 0},
        "usage": {"input_tokens": 1, "output_tokens": 2, "cache_read_tokens": 0, "cache_write_tokens": 0},
    }
    payload.update(fields)
    return payload


def _checkpoint_row(seq, first_kept_seq, *, summary="SUMMARY", state=("STATE",), **fields):
    payload = _checkpoint_payload(first_kept_seq, summary=summary, state=state, **fields)
    return ContextEntry("session", seq, "compaction", f"checkpoint-{seq}", payload=payload)


def _checkpointed_rows():
    read, bash = ToolCallBlock("a", "read", {"path": "x"}), ToolCallBlock("b", "bash", {"command": "ls"})
    return [
        ContextEntry("session", 1, "input", "in-1", user("start")),
        ContextEntry("session", 2, "response", "r-1", assistant(calls=[read])),
        ContextEntry("session", 3, "input", "in-2", user("next")),
        ContextEntry("session", 4, "response", "r-2", assistant(calls=[bash])),
        # A late recovery result of a call the checkpoint summarizes.
        ContextEntry("session", 5, "tool_result", "res-a", ToolResultMessage("a", "read", (text("A"),))),
        ContextEntry("session", 6, "tool_result", "res-b", ToolResultMessage("b", "bash", (text("B"),), True)),
        _edit(7, "edit-1", "res-b", "first placeholder"),
        _edit(8, "edit-2", "res-b", "latest placeholder"),
        _checkpoint_row(9, 3, state=("STATE-1", "STATE-2")),
        ContextEntry("session", 10, "input", "in-3", user("after")),
    ]


def test_checkpoints_and_edits_project_purely_and_deterministically():
    rows = _checkpointed_rows()
    before = deepcopy(rows)
    projected = project(list(reversed(rows)), system="system", rehydrated=[user("rehydrated")])
    assert projected == project(rows, system="system", rehydrated=[user("rehydrated")])
    assert rows == before
    checkpoint, *rest = projected.messages[1:]
    assert [block.text for block in checkpoint.content] == ["SUMMARY", "STATE-1", "STATE-2"]
    assert [type(message).__name__ for message in rest] == [
        "UserMessage",
        "AssistantMessage",
        "ToolResultMessage",
        "UserMessage",
    ]
    cleared = rest[2]
    assert (cleared.tool_call_id, cleared.tool_name, cleared.is_error) == ("b", "bash", True)
    assert cleared.content[0].text == "latest placeholder"
    # The summarized call's late result left with it: no orphan reaches a provider.
    assert all(getattr(message, "tool_call_id", None) != "a" for message in projected.messages)


@pytest.mark.parametrize(
    "fork_point,result_b",
    [(8, "latest placeholder"), (7, "first placeholder"), (6, "B")],
)
def test_a_fork_before_a_checkpoint_or_edit_projects_the_original_context(fork_point, result_b):
    projected = project(_checkpointed_rows(), fork_point=fork_point)
    assert [getattr(message, "tool_call_id", None) for message in projected.messages] == [
        None,
        None,
        "a",
        None,
        None,
        "b",
    ]
    assert projected.messages[2].content[0].text == "A"
    assert projected.messages[5].content[0].text == result_b


@pytest.mark.parametrize(
    "row",
    [
        _edit(2, "edit", "in-1", "x"),
        _edit(2, "edit", "missing", "x"),
        ContextEntry("session", 2, "context_edit", "edit", payload={"version": 1, "target_event_id": "in-1"}),
        _checkpoint_row(2, 3),
        ContextEntry("session", 2, "compaction", "checkpoint", payload={"version": 1, "first_kept_seq": 1}),
        # Every field the C-9 rules read later is checked when the row loads, not when it is next used.
        _checkpoint_row(2, 1, skills=[{}]),
        _checkpoint_row(2, 1, files_read="a.py"),
        _checkpoint_row(2, 1, files_modified=[1]),
        _checkpoint_row(2, 1, mode="partial"),
        # Every checkpoint row records the inputs it keeps, and a kept input must be an input row before the kept rows.
        ContextEntry(
            "session", 2, "compaction", "checkpoint",
            payload={key: value for key, value in _checkpoint_payload(1).items() if key != "kept_inputs"},
        ),
        _checkpoint_row(2, 1, kept_inputs=[1]),
        _checkpoint_row(2, 2, kept_inputs=[9]),
        _checkpoint_row(2, 2, kept_inputs=["1"]),
        _checkpoint_row(2, 1, summarized_to_seq="1"),
        _checkpoint_row(2, 1, threshold=1.5),
        _checkpoint_row(2, 1, summarizer={"origin": {}, "prompt_version": "v", "rounds": 0}),
        _checkpoint_row(2, 1, usage={"input_tokens": -1}),
        _checkpoint_row(2, 1, unexpected=True),
        ContextEntry("session", 2, "agent_state", "state", payload={"version": 1, "state": {}, "unexpected": True}),
    ],
)
def test_malformed_context_rows_fail_explicitly_instead_of_projecting_a_wrong_context(row):
    with pytest.raises(ProjectionError):
        project([ContextEntry("session", 1, "input", "in-1", user("start")), row])


def test_a_complete_checkpoint_row_loads():
    rows = [
        ContextEntry("session", 1, "input", "in-1", user("start")),
        ContextEntry("session", 2, "agent_state", "state", payload={"version": 1, "state": {}}),
        _checkpoint_row(3, 1, summarizer=None),
    ]
    projected = project(rows)
    assert [block.text for block in projected.messages[0].content] == ["SUMMARY", "STATE"]


def test_the_kept_inputs_of_a_turn_stay_whole_in_order_before_the_checkpoint():
    # The in-flight Turn's input and a steer it accepted, both before the cut: each stays as it was, in order.
    call = ToolCallBlock("r1", "read", {"path": "a.py"})
    rows = [
        ContextEntry("session", 1, "input", "in-1", user("read f10 to f18")),
        ContextEntry("session", 2, "response", "out-1", assistant(calls=[call])),
        ContextEntry("session", 3, "tool_result", "res-1", ToolResultMessage("r1", "read", (text("f10"),))),
        ContextEntry("session", 4, "input", "steer-1", user("also note each file's size")),
        ContextEntry("session", 5, "response", "out-2", assistant("f11 next")),
        _checkpoint_row(6, 5, kept_inputs=[1, 4]),
    ]
    messages = project(rows).messages
    assert [message.content[0].text for message in messages] == [
        "read f10 to f18",
        "also note each file's size",
        "SUMMARY",
        "f11 next",
    ]


def test_a_checkpoint_that_splits_a_turn_keeps_the_turn_input_whole_before_it_and_the_tail():
    # The cut fell inside the turn: the turn's input stays as it was, image included, right before the checkpoint,
    # whose state is then the latest environment the model reads; what came before the input is summarized.
    image = UserMessage(
        (
            text("<environment>\ndate: 2026-10-04\n</environment>"),
            text("what is in this trace?"),
            ImageBlock("image/png", "media-1", name="trace.png"),
        )
    )
    call = ToolCallBlock("r1", "read", {"path": "a.py"})
    rows = [
        ContextEntry("session", 1, "input", "in-1", user("an older turn")),
        ContextEntry("session", 2, "response", "out-1", assistant("done")),
        ContextEntry("session", 3, "input", "in-2", image),
        ContextEntry("session", 4, "response", "out-2", assistant(calls=[call])),
        ContextEntry("session", 5, "tool_result", "res-2", ToolResultMessage("r1", "read", (text("a"),))),
        ContextEntry("session", 6, "response", "out-3", assistant("the trace shows a stall")),
        _checkpoint_row(7, 6, state=("<environment>\ndate: 2026-10-05\n</environment>",), kept_inputs=[3]),
    ]
    messages = project(rows).messages
    assert [type(message).__name__ for message in messages] == ["UserMessage", "UserMessage", "AssistantMessage"]
    assert messages[0] == image and messages[1].content[0].text == "SUMMARY"
    assert messages[2].content[0].text == "the trace shows a stall"
    # The date changed after the input was consumed: the checkpoint's state, read later, says the current one.
    before_tail = "\n".join(getattr(block, "text", None) or "" for message in messages[:2] for block in message.content)
    assert before_tail.rsplit("date: ", 1)[1].startswith("2026-10-05")
    # A cut at an input splits nothing: the checkpoint comes first, then the tail from that input.
    rows[-1] = _checkpoint_row(7, 3)
    messages = project(rows).messages
    assert messages[0].content[0].text == "SUMMARY" and messages[1] == image and len(messages) == 5


def test_malformed_or_duplicate_results_are_not_silently_dropped():
    result = ContextEntry("session", 2, "tool_result", "result", ToolResultMessage("a", "echo", (text("a"),)))
    with pytest.raises(ProjectionError, match="no preceding call"):
        project([result])
    response = ContextEntry("session", 1, "response", "response", assistant(calls=[ToolCallBlock("a", "echo")]))
    with pytest.raises(ProjectionError, match="duplicate tool result"):
        project([response, result, ContextEntry("session", 3, "tool_result", "duplicate", result.message)])


@pytest.mark.parametrize("arguments", [{"nested": {1: "value"}}, {"nested": (1, 2)}])
def test_projection_revalidates_mutable_arguments_in_loaded_ancestry(arguments):
    # Admission cannot protect rows supplied by a store/fork loader from later
    # mutation. Projection must reject them without normalizing the input.
    call = ToolCallBlock("call", "echo")
    call.arguments.update(arguments)
    rows = [ContextEntry("parent", 1, "response", "response", assistant(calls=[call]))]
    original = deepcopy(rows)
    with pytest.raises(ProjectionError, match="call.*response"):
        project(rows)
    assert rows == original