Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

111 KB
Raw Blame
from __future__ import annotations

import asyncio
import json
import sys
from copy import deepcopy
from types import MappingProxyType
from typing import Any

import pytest

pytest.importorskip("langchain_core")
pytest.importorskip("langgraph")
pytest.importorskip("langchain_openviking")

from langchain_core.messages import (
    AIMessage,
    ChatMessage,
    ChatMessageChunk,
    HumanMessage,
    HumanMessageChunk,
    SystemMessage,
    SystemMessageChunk,
    ToolMessage,
    convert_to_openai_messages,
)
from langchain_core.runnables import RunnableLambda
from langgraph.store.base import InvalidNamespaceError, PutOp, SearchOp
from openviking_sdk.errors import (
    InvalidArgumentError,
    NotFoundError,
    PermissionDeniedError,
    UnavailableError,
)

import langchain_openviking.client as client_helpers
from langchain_openviking import (
    InMemoryOpenVikingClient,
    OpenVikingChatMessageHistory,
    OpenVikingCommitPolicy,
    OpenVikingContextMiddleware,
    OpenVikingRetriever,
    OpenVikingSessionContextAssembler,
    OpenVikingSessionRecorder,
    OpenVikingStore,
    create_openviking_tools,
    with_openviking_context,
)
from langchain_openviking.client import (
    OpenVikingConnection,
    apply_commit_policy,
    call_openviking,
    ensure_client,
    get_latest_user_text,
)
from langchain_openviking.history import (
    langchain_message_to_openviking,
    openviking_message_to_langchain,
)
from langchain_openviking.middleware import _message_signature
from langchain_openviking.tools import _archive_grep_pattern, _resolve_resource_source


def test_langchain_client_exposes_apply_commit_policy_without_legacy_alias():
    assert hasattr(client_helpers, "apply_commit_policy")
    assert not hasattr(client_helpers, "maybe_commit_session")


def _tool_schema(tool: Any) -> dict[str, Any]:
    args_schema = tool.args_schema
    if hasattr(args_schema, "model_json_schema"):
        return args_schema.model_json_schema()
    return args_schema.schema()


def _schema_enums(schema: dict[str, Any]) -> set[str]:
    values: set[str] = set()
    if "enum" in schema:
        values.update(str(value) for value in schema["enum"])
    for child_key in ("anyOf", "oneOf", "allOf"):
        for child in schema.get(child_key, []):
            values.update(_schema_enums(child))
    return values


def _schema_has_description(schema: dict[str, Any]) -> bool:
    if schema.get("description"):
        return True
    return any(
        _schema_has_description(child)
        for child_key in ("anyOf", "oneOf", "allOf")
        for child in schema.get(child_key, [])
    )


def test_retriever_returns_langchain_documents():
    client = InMemoryOpenVikingClient(
        {
            "viking://~/memories/preferences.md": "The user prefers azure deploys.",
            "viking://resources/runbooks/release.md": "Release notes mention LangChain.",
        }
    )
    retriever = OpenVikingRetriever(
        client=client,
        target_uri=["viking://~/memories", "viking://resources"],
        limit=3,
    )

    docs = retriever.invoke("azure LangChain")

    assert {doc.metadata["openviking_uri"] for doc in docs} == {
        "viking://resources/runbooks/release.md",
        "viking://~/memories/preferences.md",
    }
    assert all(doc.page_content for doc in docs)


def test_retriever_keeps_peer_id_out_of_retrieval():
    client = InMemoryOpenVikingClient(
        {"viking://~/memories/preferences.md": "The peer prefers azure deploys."}
    )
    retriever = OpenVikingRetriever(
        client=client,
        target_uri="viking://~/memories",
        actor_peer_id="peer-1",
    )

    retriever.invoke("azure")

    assert "peer_id" not in client.find_calls[-1]


def test_retriever_passes_tags_to_retrieval():
    client = InMemoryOpenVikingClient(
        {"viking://resources/runbooks/release.md": "Release notes mention LangChain."}
    )
    retriever = OpenVikingRetriever(
        client=client,
        target_uri="viking://resources",
        tags=["env=prod", "team=search"],
    )

    retriever.invoke("LangChain")

    assert client.find_calls[-1]["tags"] == ["env=prod", "team=search"]


def test_create_openviking_tools_exposes_common_viking_primitives():
    client = InMemoryOpenVikingClient(
        {"viking://~/memories/profile.md": "The user likes LangGraph agents."}
    )
    tools = create_openviking_tools(client=client, profile="agent")
    names = {tool.name for tool in tools}

    assert {
        "viking_find",
        "viking_search",
        "viking_browse",
        "viking_read",
        "viking_grep",
        "viking_archive_search",
        "viking_archive_expand",
        "viking_store",
        "viking_add_resource",
        "viking_add_skill",
        "viking_health",
    }.issubset(names)
    assert "viking_forget" not in names

    find_tool = next(tool for tool in tools if tool.name == "viking_find")
    assert "viking://~/memories/profile.md" in find_tool.invoke({"query": "LangGraph", "limit": 2})

    store_tool = next(tool for tool in tools if tool.name == "viking_store")
    assert "explicit durable memories" in store_tool.description
    stored = store_tool.invoke(
        {
            "messages": [
                {"role": "user", "content": "Remember that azure is preferred."},
                {"role": "assistant", "content": "Noted."},
            ],
            "session_id": "test-session",
            "commit": False,
        }
    )
    assert '"messages_added":2' in stored
    assert len(client.sessions["test-session"]) == 2
    assert client.sessions["test-session"][0]["parts"][0]["text"] == (
        "Remember that azure is preferred."
    )

    add_resource_tool = next(tool for tool in tools if tool.name == "viking_add_resource")
    assert "resource-management operation" in add_resource_tool.description

    health_tool = next(tool for tool in tools if tool.name == "viking_health")
    health = health_tool.invoke({})
    assert '"backend": "OpenViking"' in health
    assert "VikingDB is internal vector/index storage" in health


@pytest.mark.parametrize("role", ["user", "assistant", "system", "tool"])
@pytest.mark.parametrize("text_format", ["string", "block"])
def test_viking_store_normalizes_langchain_text_blocks(role: str, text_format: str):
    content = [
        {"type": "text", "text": "Remember cobalt deployment."},
        {"type": "text", "text": "中文确认"},
    ]
    messages = {
        "user": HumanMessage(content=content),
        "assistant": AIMessage(content=content),
        "system": SystemMessage(content=content),
        "tool": ToolMessage(content=content, tool_call_id="call-normal", name="ordinary_tool"),
    }
    wire = convert_to_openai_messages([messages[role]], text_format=text_format)
    client = InMemoryOpenVikingClient()
    store = create_openviking_tools(client=client, tool_names=["viking_store"])[0]

    result = json.loads(
        store.invoke({"session_id": "text-blocks", "messages": wire, "commit": False})
    )

    assert result["messages_added"] == 1
    stored = client.sessions["text-blocks"][0]
    assert stored["role"] == ("assistant" if role in {"system", "tool"} else role)
    part = stored["parts"][0]
    assert (
        part["tool_output" if role == "tool" else "text"] == "Remember cobalt deployment.\n中文确认"
    )
    if role == "tool":
        assert part["tool_id"] == "call-normal"
        assert part["tool_name"] == "ordinary_tool"
        assert part["tool_status"] == "completed"


@pytest.mark.parametrize("content", [None, False, 0])
def test_viking_store_preserves_scalar_content(content: Any):
    client = InMemoryOpenVikingClient()
    store = create_openviking_tools(client=client, tool_names=["viking_store"])[0]

    store.invoke(
        {
            "session_id": "scalar",
            "messages": [{"role": "user", "content": content}],
            "commit": False,
        }
    )

    assert client.sessions["scalar"][0]["parts"] == [{"type": "text", "text": str(content)}]


@pytest.mark.parametrize("role", ["user", "system", "tool"])
def test_viking_store_preserves_native_parts(role: str):
    client = InMemoryOpenVikingClient()
    store = create_openviking_tools(client=client, tool_names=["viking_store"])[0]
    parts = [{"type": "text", "text": "explicit parts control"}]

    store.invoke(
        {
            "session_id": "native-parts",
            "messages": [
                {"role": role, "content": [{"type": "text", "text": "unused"}], "parts": parts}
            ],
            "commit": False,
        }
    )

    stored = client.sessions["native-parts"][0]
    assert stored["role"] == ("assistant" if role in {"system", "tool"} else role)
    assert stored["parts"] == parts


def test_create_openviking_tools_uses_peer_id_only_for_message_attribution():
    client = InMemoryOpenVikingClient(
        {"viking://~/memories/profile.md": "The peer likes LangGraph agents."}
    )
    tools = {
        tool.name: tool for tool in create_openviking_tools(client=client, peer_id="peer-tools")
    }

    assert "peer_id" not in _tool_schema(tools["viking_find"]).get("properties", {})

    tools["viking_find"].invoke({"query": "LangGraph"})
    tools["viking_search"].invoke({"query": "LangGraph", "session_id": "tool-session"})
    tools["viking_store"].invoke(
        {
            "messages": [{"role": "user", "content": "Remember peer tools."}],
            "commit": False,
        }
    )

    assert "peer_id" not in client.find_calls[-1]
    assert "peer_id" not in client.search_calls[-1]
    assert any(
        messages and messages[0].get("peer_id") == "peer-tools"
        for messages in client.sessions.values()
    )


def test_add_resource_resolves_existing_local_file_for_client_upload(tmp_path):
    class RecordingClient:
        def __init__(self):
            self.paths = []

        def add_resource(self, path, **_kwargs):
            self.paths.append(path)
            return {"uri": "viking://resources/report.md"}

    client = RecordingClient()
    resource_file = tmp_path / "report.md"
    resource_file.write_text("deployment notes", encoding="utf-8")
    tools = {
        tool.name: tool
        for tool in create_openviking_tools(
            client=client,
            tool_names=["viking_add_resource"],
        )
    }

    result = tools["viking_add_resource"].invoke({"path": str(resource_file)})

    assert client.paths == [str(resource_file)]
    assert "viking://resources/report.md" in result


def test_resolve_resource_source_handles_local_and_remote_sources(tmp_path):
    local_file = tmp_path / "resource with spaces.md"
    local_file.write_text("notes", encoding="utf-8")

    assert (
        _resolve_resource_source("https://example.com/repo.git") == "https://example.com/repo.git"
    )
    assert _resolve_resource_source("[email protected]:org/repo.git") == "[email protected]:org/repo.git"
    assert (
        _resolve_resource_source("ssh://[email protected]/org/repo.git")
        == "ssh://[email protected]/org/repo.git"
    )
    assert _resolve_resource_source("github.com/org/repo") == "github.com/org/repo"
    assert _resolve_resource_source(f"file://{local_file}") == str(local_file)
    assert (
        _resolve_resource_source("file://remote-host/tmp/report.md")["error"]
        == "unsupported_file_uri"
    )

    missing = _resolve_resource_source(str(tmp_path / "missing.md"))
    assert missing["error"] == "local_path_not_found"
    assert _resolve_resource_source("docs/missing.md")["error"] == "local_path_not_found"


def test_add_resource_keeps_explicit_local_clients_supported(tmp_path):
    client = InMemoryOpenVikingClient()
    resource_file = tmp_path / "report.md"
    resource_file.write_text("report", encoding="utf-8")
    tools = {
        tool.name: tool
        for tool in create_openviking_tools(
            client=client,
            tool_names=["viking_add_resource"],
        )
    }

    result = tools["viking_add_resource"].invoke({"path": str(resource_file)})

    assert "viking://resources/report.md" in result
    assert "viking://resources/report.md" in client.records


def test_create_openviking_tools_profiles_control_destructive_tools():
    client = InMemoryOpenVikingClient()

    retrieval_names = {
        tool.name for tool in create_openviking_tools(client=client, profile="retrieval")
    }
    assert "viking_store" not in retrieval_names
    assert "viking_add_resource" not in retrieval_names
    assert "viking_add_skill" not in retrieval_names
    assert "viking_forget" not in retrieval_names

    admin_names = {tool.name for tool in create_openviking_tools(client=client, profile="admin")}
    assert "viking_store" in admin_names
    assert "viking_add_resource" in admin_names
    assert "viking_add_skill" in admin_names
    assert "viking_forget" in admin_names

    explicit_names = {
        tool.name
        for tool in create_openviking_tools(
            client=client,
            tool_names=["viking_find", "viking_store"],
        )
    }
    assert explicit_names == {"viking_find", "viking_store"}


def test_openviking_tools_read_l0_l1_l2_content_modes():
    client = InMemoryOpenVikingClient(
        {"viking://resources/runbooks/release.md": "Release runbook full details."}
    )
    tools = {tool.name: tool for tool in create_openviking_tools(client=client)}
    read_tool = tools["viking_read"]

    abstract = read_tool.invoke(
        {
            "uris": "viking://resources/runbooks/release.md",
            "content_mode": "abstract",
        }
    )
    overview = read_tool.invoke(
        {
            "uris": "viking://resources/runbooks/release.md",
            "content_mode": "overview",
        }
    )
    full = read_tool.invoke(
        {
            "uris": "viking://resources/runbooks/release.md",
            "content_mode": "read",
        }
    )
    uppercase = read_tool.invoke(
        {
            "uris": "viking://resources/runbooks/release.md",
            "content_mode": "READ",
        }
    )

    assert '"content_mode": "abstract"' in abstract
    assert '"content_mode": "overview"' in overview
    assert '"content_mode": "read"' in full
    assert '"content_mode": "read"' in uppercase
    assert "Release runbook full details." in full


def test_openviking_read_tool_schema_describes_file_and_directory_contract():
    client = InMemoryOpenVikingClient()
    tools = {tool.name: tool for tool in create_openviking_tools(client=client)}
    read_tool = tools["viking_read"]
    browse_tool = tools["viking_browse"]

    read_schema = _tool_schema(read_tool)
    content_mode_schema = read_schema["properties"]["content_mode"]

    assert "Directory URIs are not readable" in read_tool.description
    assert "file/document" in read_schema["properties"]["uris"]["description"]
    assert "viking_browse" in read_tool.description
    assert _schema_enums(content_mode_schema) == {"abstract", "overview", "read"}
    assert "List child entries" in browse_tool.description
    assert "namespace or directory" in _tool_schema(browse_tool)["properties"]["uri"]["description"]


def test_openviking_tool_schemas_describe_model_visible_arguments():
    client = InMemoryOpenVikingClient()
    tools = create_openviking_tools(client=client, profile="admin", allow_forget=True)

    for tool in tools:
        schema = _tool_schema(tool)
        for name, property_schema in schema.get("properties", {}).items():
            assert _schema_has_description(property_schema), (
                f"{tool.name}.{name} lacks a description"
            )


@pytest.mark.parametrize(
    ("status", "expected_state"),
    [
        ({"status": "degraded"}, "degraded"),
        ({"is_healthy": True}, "healthy"),
        ({"is_healthy": False}, "unhealthy"),
        ({"healthy": False, "is_healthy": True}, "unhealthy"),
        ({"ok": True, "is_healthy": False}, "healthy"),
        ({"status": "degraded", "is_healthy": True}, "degraded"),
        ({"state": "ready", "is_healthy": False}, "healthy"),
        ({"is_healthy": "true"}, "unknown"),
    ],
)
def test_openviking_health_tool_returns_safe_summary(status, expected_state):
    class StatusClient(InMemoryOpenVikingClient):
        def get_status(self) -> dict[str, Any]:
            return {
                **status,
                "state_detail": "service is starting up and loading initial data from the persistence layer",
                "hostname": "internal-openviking.local",
                "database_url": "postgres://user:[email protected]/db",
                "errors": ["postgres://user:[email protected]/db"],
                "components": {"storage": {"status": "ok"}},
            }

    tools = {tool.name: tool for tool in create_openviking_tools(client=StatusClient())}
    payload = json.loads(tools["viking_health"].invoke({}))

    assert payload["backend"] == "OpenViking"
    assert payload["state"] == expected_state
    assert payload["healthy"] is (expected_state == "healthy")
    assert payload["summary"] == {
        **status,
        "state_detail": "service is starting up and loading initial data from the pers...",
        "component_count": 1,
    }
    assert "internal-openviking.local" not in json.dumps(payload)
    assert "postgres://" not in json.dumps(payload)


def test_openviking_read_directory_uri_returns_recoverable_tool_result_for_all_modes():
    class DirectoryReadClient(InMemoryOpenVikingClient):
        def read(self, uri: str, offset: int = 0, limit: int = -1) -> str:
            raise InvalidArgumentError(
                f"Directory cannot be used here: {uri}",
                details={"resource": uri, "expected": "file", "actual": "directory"},
            )

    client = DirectoryReadClient()
    tools = {tool.name: tool for tool in create_openviking_tools(client=client)}

    for content_mode in ("abstract", "overview", "read"):
        result = tools["viking_read"].invoke(
            {
                "uris": "viking://user/default/memories/events/2026/05/09",
                "content_mode": content_mode,
            }
        )

        payload = json.loads(result)
        assert payload == [
            {
                "uri": "viking://user/default/memories/events/2026/05/09",
                "content_mode": content_mode,
                "error": "directory_uri_not_readable",
                "message": (
                    "This URI is a directory. Use viking_browse on this URI to list children, "
                    "then call viking_read on file/document URIs."
                ),
            }
        ]


def test_ensure_client_defaults_to_http_client(monkeypatch):
    created = {}

    class FakeHTTPClient:
        def __init__(self, **kwargs):
            created.update(kwargs)
            self._initialized = False

        def initialize(self):
            self._initialized = True

    import openviking_sdk as client_module

    monkeypatch.setattr(client_module, "SyncHTTPClient", FakeHTTPClient)

    client = ensure_client(
        OpenVikingConnection(
            api_key="test-key",
            user_id="test-user",
        )
    )

    assert client._initialized is True
    assert isinstance(client.get(), FakeHTTPClient)
    assert created["api_key"] == "test-key"
    assert created["user_id"] == "test-user"
    assert created["url"] is None


def test_openviking_client_retries_recoverable_read_with_fresh_client(monkeypatch):
    instances = []

    class FlakyHTTPClient:
        def __init__(self, **_kwargs):
            self.index = len(instances)
            self.closed = False
            self._initialized = False
            instances.append(self)

        def initialize(self):
            self._initialized = True

        def close(self):
            self.closed = True

        def find(self, **_kwargs):
            if self.index == 0:
                raise ConnectionError("OpenViking server was not ready")
            return {
                "memories": [
                    {
                        "uri": "viking://user/default/memories/profile.md",
                        "abstract": "OpenViking recovered",
                        "overview": "OpenViking recovered",
                    }
                ],
                "resources": [],
                "skills": [],
            }

    import openviking_sdk as client_module

    monkeypatch.setattr(client_module, "SyncHTTPClient", FlakyHTTPClient)

    client = ensure_client(OpenVikingConnection(url="http://localhost:1933"))
    result = call_openviking(client, "find", query="recover")

    assert result["memories"][0]["abstract"] == "OpenViking recovered"
    assert len(instances) == 2
    assert instances[0].closed is True
    assert instances[1]._initialized is True


def test_openviking_client_handle_filters_kwargs_for_direct_calls(monkeypatch):
    class FakeHTTPClient:
        def __init__(self, **_kwargs):
            self._initialized = False

        def initialize(self):
            self._initialized = True

        def find(self, query):
            return {"query": query}

    import openviking_sdk as client_module

    monkeypatch.setattr(client_module, "SyncHTTPClient", FakeHTTPClient)

    client = ensure_client(OpenVikingConnection(url="http://localhost:1933"))
    result = client.find("recover", unsupported="ignored")

    assert result == {"query": "recover"}


def test_call_openviking_adapts_flat_kwargs_to_sdk_options():
    calls = []

    class OptionsClient:
        def find(self, query, options=None):
            calls.append(("find", query, options))
            return {"query": query}

        def create_session(self, options=None):
            calls.append(("create_session", options))
            return {"session_id": options["session_id"]}

        def add_message(self, session_id, message):
            calls.append(("add_message", session_id, message))
            return {"ok": True}

        def write(self, uri, content, options=None):
            calls.append(("write", uri, content, options))
            return {"ok": True}

    client = OptionsClient()

    call_openviking(
        client,
        "find",
        query="recover",
        target_uri="viking://resources",
        limit=5,
    )
    call_openviking(client, "create_session", session_id="session-1")
    call_openviking(
        client,
        "add_message",
        session_id="session-1",
        role="user",
        content="hello",
    )
    call_openviking(
        client,
        "write",
        uri="viking://resources/a.md",
        content="hello",
        mode="replace",
        wait=False,
    )

    assert calls == [
        (
            "find",
            "recover",
            {"target_uri": "viking://resources", "limit": 5},
        ),
        ("create_session", {"session_id": "session-1"}),
        (
            "add_message",
            "session-1",
            {"role": "user", "content": "hello"},
        ),
        (
            "write",
            "viking://resources/a.md",
            "hello",
            {"mode": "replace", "wait": False},
        ),
    ]


def test_openviking_client_evicts_but_does_not_retry_mutating_call(monkeypatch):
    instances = []

    class FlakyHTTPClient:
        def __init__(self, **_kwargs):
            self.closed = False
            self._initialized = False
            instances.append(self)

        def initialize(self):
            self._initialized = True

        def close(self):
            self.closed = True

        def add_message(self, **_kwargs):
            raise ConnectionError("OpenViking connection dropped during write")

    import openviking_sdk as client_module

    monkeypatch.setattr(client_module, "SyncHTTPClient", FlakyHTTPClient)

    client = ensure_client(OpenVikingConnection(url="http://localhost:1933"))
    with pytest.raises(ConnectionError):
        call_openviking(
            client,
            "add_message",
            session_id="session-1",
            role="user",
            parts=[{"type": "text", "text": "hello"}],
        )

    assert len(instances) == 1
    assert instances[0].closed is True


def test_retriever_recovers_from_stale_cached_remote_client(monkeypatch):
    instances = []

    class FlakyHTTPClient:
        def __init__(self, **_kwargs):
            self.index = len(instances)
            self.closed = False
            self._initialized = False
            instances.append(self)

        def initialize(self):
            self._initialized = True

        def close(self):
            self.closed = True

        def find(self, **_kwargs):
            if self.index == 0:
                raise RuntimeError("Event loop is closed")
            return {
                "memories": [],
                "resources": [
                    {
                        "uri": "viking://resources/recovered.md",
                        "level": 1,
                        "abstract": "Recovered resource",
                        "overview": "Recovered resource overview",
                        "score": 1.0,
                    }
                ],
                "skills": [],
            }

    import openviking_sdk as client_module

    monkeypatch.setattr(client_module, "SyncHTTPClient", FlakyHTTPClient)

    retriever = OpenVikingRetriever(url="http://localhost:1933")
    docs = retriever.invoke("recover")

    assert [doc.metadata["openviking_uri"] for doc in docs] == ["viking://resources/recovered.md"]
    assert len(instances) == 2
    assert instances[0].closed is True


def test_in_memory_openviking_client_batch_add_messages_records_messages():
    client = InMemoryOpenVikingClient()

    result = client.batch_add_messages(
        "batch-session",
        [
            {"role": "user", "content": "hello"},
            {
                "role": "assistant",
                "parts": [{"type": "text", "text": "hi"}],
                "peer_id": "agent-1",
                "created_at": "2026-05-26T00:00:00+00:00",
            },
        ],
    )

    assert result["session_id"] == "batch-session"
    assert result["message_count"] == 2
    assert result["added"] == 2
    assert result["pending_tokens"] > 0
    assert [message["role"] for message in client.sessions["batch-session"]] == [
        "user",
        "assistant",
    ]
    assert client.sessions["batch-session"][0]["parts"][0]["text"] == "hello"
    assert client.sessions["batch-session"][1]["parts"][0]["text"] == "hi"
    assert client.sessions["batch-session"][1]["peer_id"] == "agent-1"
    assert client.sessions["batch-session"][1]["created_at"] == "2026-05-26T00:00:00+00:00"


@pytest.mark.asyncio
@pytest.mark.parametrize("asynchronous", [False, True])
@pytest.mark.parametrize(
    "second_query,new_turn,second_output",
    [
        ("deployment", True, "deployment notes found."),
        ("Tokyo", True, "Tokyo notes found."),
        ("Tokyo", False, "Tokyo notes found."),
        ("deployment", False, "done"),
        ("deployment", False, "deployment notes found."),
        ("deployment", False, None),
    ],
)
async def test_chat_message_history_preserves_tool_parts(
    asynchronous, second_query, new_turn, second_output
):
    client = InMemoryOpenVikingClient()
    history = OpenVikingChatMessageHistory(
        session_id="history-session", client=client, async_client=client
    )

    messages = []
    outputs = ["deployment notes found.", second_output]
    for index, (query, output) in enumerate(
        zip(("deployment", second_query), outputs, strict=True)
    ):
        if index == 0 or new_turn:
            messages.append(HumanMessage(content=f"Find {query} notes."))
        messages.extend(
            [
                AIMessage(
                    content="Searching.",
                    tool_calls=[
                        {
                            "id": "call-1",
                            "name": "viking_find",
                            "args": {"query": query},
                        }
                    ],
                ),
            ]
        )
        if output is not None:
            messages.append(ToolMessage(content=output, tool_call_id="call-1", name="viking_find"))
    try:
        if asynchronous:
            await history.aadd_messages(messages)
            restored = await history.aget_messages()
        else:
            history.add_messages(messages)
            restored = history.messages
    finally:
        await history.aclose()

    stored = client.sessions["history-session"]
    assert stored[1]["parts"][1]["type"] == "tool"
    assert stored[2]["parts"][0]["tool_output"] == "deployment notes found."

    assert [type(message) for message in restored] == (
        [HumanMessage, AIMessage, ToolMessage]
        + ([HumanMessage] if new_turn else [])
        + [AIMessage]
        + ([ToolMessage] if second_output is not None else [])
    )
    restored_ai_messages = [message for message in restored if isinstance(message, AIMessage)]
    restored_tool_messages = [message for message in restored if isinstance(message, ToolMessage)]
    assert [message.tool_calls for message in restored_ai_messages] == [
        [{"id": "call-1", "name": "viking_find", "args": {"query": query}, "type": "tool_call"}]
        for query in ("deployment", second_query)
    ]
    expected_outputs = [output for output in outputs if output is not None]
    assert [message.tool_call_id for message in restored_tool_messages] == ["call-1"] * len(
        expected_outputs
    )
    assert [message.content for message in restored_tool_messages] == expected_outputs


def test_chat_message_history_writes_peer_id_to_messages():
    client = InMemoryOpenVikingClient()
    history = OpenVikingChatMessageHistory(
        session_id="peer-history-session",
        client=client,
        peer_id="peer-history",
    )

    history.add_messages(
        [
            HumanMessage(content="Remember peer history."),
            AIMessage(content="Stored."),
        ]
    )

    assert [message.get("peer_id") for message in client.sessions["peer-history-session"]] == [
        "peer-history",
        "peer-history",
    ]


@pytest.mark.parametrize(
    "fields",
    [{}, {"tool_input": None}, {"tool_input": {"a": 1}, "tool_name": ""}],
)
def test_openviking_tool_result_restores_without_duplicate_ai_tool_call(fields):
    message = {
        "role": "assistant",
        "parts": [
            {
                "type": "tool",
                "tool_id": "call-1",
                "tool_name": "viking_find",
                "tool_output": "Azure deployment notes found.",
                "tool_status": "completed",
                **fields,
            }
        ],
    }
    restored = openviking_message_to_langchain(message)

    assert len(restored) == 1
    assert isinstance(restored[0], ToolMessage)
    assert restored[0].tool_call_id == "call-1"
    client = InMemoryOpenVikingClient()
    client.add_message("orphan-result", "assistant", parts=message["parts"])
    history = OpenVikingChatMessageHistory("orphan-result", client=client)
    try:
        assert history.messages == []
    finally:
        history.close()


@pytest.mark.asyncio
@pytest.mark.parametrize("asynchronous", [False, True])
@pytest.mark.parametrize(
    "followup",
    [
        "none",
        "duplicate",
        "next_turn",
        "approval",
        "updated_output",
        "updated_status",
        "coalesced_poll",
    ],
)
@pytest.mark.parametrize("tool_input", [{"release": "stable"}, {}])
@pytest.mark.parametrize("status,output", [("completed", "Friday"), ("error", "")])
async def test_history_restores_completed_tool_part_with_input(
    asynchronous, followup, tool_input, status, output
):
    client = InMemoryOpenVikingClient()
    completed = {
        "type": "tool",
        "tool_id": "release-2",
        "tool_name": "read_notes",
        "tool_input": tool_input,
        "tool_output": output,
        "tool_status": status,
    }
    initial = deepcopy(completed)
    if followup == "approval":
        initial.pop("tool_output")
        initial["tool_status"] = "pending"
    following = deepcopy(completed)
    if followup == "updated_output":
        following["tool_output"] = f"{output} updated"
    elif followup == "updated_status":
        following["tool_status"] = "error" if status == "completed" else "completed"
    initial_parts = [initial]
    following_parts = [following]
    if followup == "coalesced_poll":
        pending = {**completed, "tool_status": "pending"}
        pending.pop("tool_output")
        initial_parts.insert(0, deepcopy(pending))
        following_parts.insert(0, deepcopy(pending))
    client.add_message(
        "combined-tool",
        "assistant",
        parts=initial_parts,
    )
    if followup != "none":
        if followup in ("next_turn", "approval"):
            client.add_message(
                "combined-tool",
                "user",
                content="Approved." if followup == "approval" else "Run the same tool again.",
            )
        for _ in range(2 if followup == "approval" else 1):
            client.add_message("combined-tool", "assistant", parts=deepcopy(following_parts))
    history = OpenVikingChatMessageHistory(
        session_id="combined-tool", client=client, async_client=client
    )
    stored = deepcopy(client.sessions["combined-tool"])
    try:
        messages = await history.aget_messages() if asynchronous else history.messages
    finally:
        await history.aclose()

    expected_types = {
        "next_turn": [AIMessage, ToolMessage, HumanMessage, AIMessage, ToolMessage],
        "approval": [AIMessage, HumanMessage, ToolMessage],
        "updated_output": [AIMessage, ToolMessage, AIMessage, ToolMessage],
        "updated_status": [AIMessage, ToolMessage, AIMessage, ToolMessage],
        "coalesced_poll": [AIMessage, ToolMessage, AIMessage, ToolMessage],
    }.get(followup, [AIMessage, ToolMessage])
    assert [type(message) for message in messages] == expected_types
    ai = [message for message in messages if isinstance(message, AIMessage)][-1]
    tool = messages[-1]
    assert isinstance(ai, AIMessage)
    assert ai.tool_calls[0]["id"] == "release-2"
    assert ai.tool_calls[0]["name"] == "read_notes"
    assert ai.tool_calls[0]["args"] == tool_input
    assert isinstance(tool, ToolMessage)
    assert tool.tool_call_id == "release-2"
    assert tool.content == following["tool_output"]
    assert tool.status == ("error" if following["tool_status"] == "error" else "success")
    assert client.sessions["combined-tool"] == stored


@pytest.mark.asyncio
@pytest.mark.parametrize("asynchronous", [False, True])
@pytest.mark.parametrize("tool_input", [{"a": 1}, {}])
@pytest.mark.parametrize(
    "layout", ["split", "coalesced", "mixed", "result_only", "approved_result_only"]
)
async def test_history_does_not_duplicate_pending_call_for_completed_tool_part(
    asynchronous, tool_input, layout
):
    client = InMemoryOpenVikingClient()
    approved = layout == "approved_result_only"
    if approved:
        layout = "result_only"
    pending = {
        "type": "tool",
        "tool_id": "c1",
        "tool_name": "read_notes",
        "tool_input": tool_input,
        "tool_status": "pending",
    }
    completed = {**pending, "tool_status": "completed", "tool_output": "ok"}
    if layout == "result_only":
        completed.pop("tool_input")
    if layout != "coalesced":
        client.add_message("split-tool", "assistant", parts=[pending])
    if approved:
        client.add_message("split-tool", "user", content="Approved.")
    parts = [pending, completed] if layout == "coalesced" else [completed]
    if layout in ("mixed", "result_only"):
        parts.append({"type": "text", "text": "Lookup complete."})
    if layout == "mixed":
        parts.append({**completed, "tool_id": "c2"})
    client.add_message("split-tool", "assistant", parts=parts)
    history = OpenVikingChatMessageHistory(
        session_id="split-tool", client=client, async_client=client
    )
    stored = deepcopy(client.sessions["split-tool"])
    try:
        messages = await history.aget_messages() if asynchronous else history.messages
    finally:
        await history.aclose()
    expected_types = [AIMessage, ToolMessage] * (2 if layout == "mixed" else 1)
    if layout == "result_only":
        expected_types.append(AIMessage)
    if approved:
        expected_types.insert(1, HumanMessage)
    assert [type(message) for message in messages] == expected_types
    assert [
        call["id"]
        for message in messages
        if isinstance(message, AIMessage)
        for call in message.tool_calls
    ] == (["c1", "c2"] if layout == "mixed" else ["c1"])
    assert [message.tool_call_id for message in messages if isinstance(message, ToolMessage)] == (
        ["c1", "c2"] if layout == "mixed" else ["c1"]
    )
    if layout in ("mixed", "result_only"):
        assert messages[3 if approved else 2].content == "Lookup complete."
    assert client.sessions["split-tool"] == stored


@pytest.mark.asyncio
@pytest.mark.parametrize("asynchronous", [False, True])
@pytest.mark.parametrize("earlier_result", ["pending", "combined", "result_only"])
async def test_history_keeps_new_combined_call_when_an_older_call_reuses_its_id(
    asynchronous, earlier_result
):
    client = InMemoryOpenVikingClient()
    pending = {
        "type": "tool",
        "tool_id": "call_0",
        "tool_name": "weather",
        "tool_input": {"city": "Paris"},
        "tool_status": "pending",
    }
    client.add_message("overlapping-id", "assistant", parts=[pending])
    client.add_message("overlapping-id", "user", content="Check Tokyo instead.")
    if earlier_result != "pending":
        result = {**pending, "tool_status": "completed", "tool_output": "18C"}
        if earlier_result == "result_only":
            result.pop("tool_input")
        for _ in range(2):
            client.add_message("overlapping-id", "assistant", parts=deepcopy([result]))
    client.add_message(
        "overlapping-id",
        "assistant",
        parts=[
            {
                **pending,
                "tool_input": {"city": "Tokyo"},
                "tool_status": "completed",
                "tool_output": "22C",
            }
        ],
    )
    stored = deepcopy(client.sessions["overlapping-id"])
    history = OpenVikingChatMessageHistory("overlapping-id", client=client, async_client=client)
    try:
        messages = await history.aget_messages() if asynchronous else history.messages
    finally:
        await history.aclose()
    assert [type(message) for message in messages] == (
        [AIMessage, HumanMessage]
        + ([] if earlier_result == "pending" else [ToolMessage])
        + [AIMessage, ToolMessage]
    )
    assert messages[0].tool_calls[0]["args"] == {"city": "Paris"}
    assert messages[-2].tool_calls[0]["args"] == {"city": "Tokyo"}
    assert [message.content for message in messages if isinstance(message, ToolMessage)] == (
        ["22C"] if earlier_result == "pending" else ["18C", "22C"]
    )
    assert client.sessions["overlapping-id"] == stored


def test_empty_human_message_uses_empty_text_part():
    payloads = langchain_message_to_openviking(HumanMessage(content=""))

    assert payloads == [{"role": "user", "parts": [{"type": "text", "text": ""}]}]


def test_system_messages_are_never_persisted_to_openviking_history():
    payloads = langchain_message_to_openviking(
        SystemMessage(content="Never persist runtime policy."),
        persist_system_messages=True,
    )

    assert payloads == []


@pytest.mark.asyncio
@pytest.mark.parametrize("entry", ["history", "ahistory", "recorder", "arecorder"])
@pytest.mark.parametrize("message_type", [ChatMessage, ChatMessageChunk])
@pytest.mark.parametrize(
    "role,expected",
    [
        ("user", "user"),
        ("human", "user"),
        ("system", None),
        ("developer", None),
        ("assistant", "assistant"),
    ],
)
async def test_generic_chat_message_roles_in_session_history(entry, message_type, role, expected):
    client = InMemoryOpenVikingClient()
    message = message_type(role=role, content="Role-specific conversation text.")
    history = OpenVikingChatMessageHistory("chat-roles", client=client, async_client=client)
    recorder = OpenVikingSessionRecorder(client=client, async_client=client)
    try:
        if entry == "history":
            history.add_messages([message])
        elif entry == "ahistory":
            await history.aadd_messages([message])
        elif entry == "recorder":
            recorder.record("chat-roles", [message])
        else:
            await recorder.arecord("chat-roles", [message])
        expected_roles = [] if expected is None else [expected]
        assert [item["role"] for item in client.sessions["chat-roles"]] == expected_roles
        restored = await history.aget_messages()
        assert [item.type for item in restored] == [
            "human" if value == "user" else "ai" for value in expected_roles
        ]
        assert [item.content for item in restored] == [message.content] * len(expected_roles)
    finally:
        await history.aclose()
        await recorder.aclose()


@pytest.mark.parametrize(
    "message,expected",
    [
        (ChatMessage(role="user", content="Current question."), "Current question."),
        (ChatMessage(role="human", content="Current question."), "Current question."),
        (ChatMessageChunk(role="human", content="Current question."), "Current question."),
        ({"type": "chat", "role": "human", "content": "Current question."}, "Current question."),
        ({"type": "chat", "role": "user", "content": "Current question."}, "Current question."),
        (ChatMessage(role="system", content="Runtime policy."), "Earlier question."),
        (ChatMessage(role="developer", content="Runtime policy."), "Earlier question."),
        (ChatMessageChunk(role="developer", content="Runtime policy."), "Earlier question."),
        ({"type": "chat", "role": "developer", "content": "Runtime policy."}, "Earlier question."),
        (ChatMessage(role="critic", content="Critique."), "Earlier question."),
        (HumanMessage(content="Current question.", role="system"), "Current question."),
        (HumanMessageChunk(content="Current question.", role="system"), "Current question."),
        (SystemMessageChunk(content="Runtime policy.", role="user"), "Earlier question."),
        (ChatMessage(role="user", content=""), "Earlier question."),
    ],
)
def test_generic_chat_message_roles_in_recall_query(message, expected):
    assert get_latest_user_text([HumanMessage(content="Earlier question."), message]) == expected


@pytest.mark.parametrize("metadata_prefix", ["openviking", "recall", "", "my_recall"])
@pytest.mark.parametrize(
    "uri, context_type",
    [
        ("viking://resources/runbooks/deploy.md", "resource"),
        ("viking://user/default/memories/preferences/deploy.md", "memory"),
        ("viking://skills/deploy.md", "skill"),
    ],
)
def test_session_context_assembler_uses_archive_active_messages_and_recall(
    metadata_prefix, uri, context_type
):
    content = "Azure deployments use OpenViking context. " * 20
    client = InMemoryOpenVikingClient({uri: content})
    client.add_message("assembler-session", "user", content="Earlier user turn")
    client.add_message("assembler-session", "assistant", content="Earlier assistant turn")
    client.commit_session("assembler-session", enable_working_memory=True)
    client.add_message("assembler-session", "user", content="Active turn")

    assembler = OpenVikingSessionContextAssembler(
        include_session_context=True,
        client=client,
        retriever=OpenVikingRetriever(
            client=client, target_uri=uri, metadata_prefix=metadata_prefix, search_mode="search"
        ),
    )
    assembled = assembler.assemble(session_id="assembler-session", query="azure context")

    assert client.search_calls[-1]["session_id"] == "assembler-session"
    assert "Session archive overview" in assembled.block
    assert "Earlier user turn" in assembled.block
    assert "Active session messages" in assembled.block
    assert "Active turn" in assembled.block
    assert "Azure deployments" in assembled.block
    assert assembled.context_parts == [
        {"type": "context", "uri": uri, "context_type": context_type, "abstract": content[:240]}
    ]
    recorder = OpenVikingSessionRecorder(client=client)
    recorder.record(
        "assembler-session",
        [HumanMessage(content="Deployment question"), AIMessage(content="Deployment answer")],
        context_parts=assembled.context_parts,
    )
    assert [
        part
        for message in client.sessions["assembler-session"][-2:]
        for part in message["parts"]
        if part["type"] == "context"
    ] == assembled.context_parts
    asyncio.run(recorder.aclose())
    asyncio.run(assembler.aclose())


def test_session_context_assembler_keeps_peer_id_out_of_recall():
    client = InMemoryOpenVikingClient(
        {"viking://~/memories/peer.md": "Peer memory mentions azure."}
    )
    assembler = OpenVikingSessionContextAssembler(
        client=client,
        target_uri="viking://~/memories",
        actor_peer_id="peer-assembler",
    )

    assembler.assemble(session_id="assembler-peer-session", query="azure")

    assert "peer_id" not in client.search_calls[-1]


def test_session_context_assembler_creates_only_after_not_found():
    class RecordingClient(InMemoryOpenVikingClient):
        def __init__(self):
            super().__init__()
            self.create_calls = 0
            self.context_calls = 0

        def create_session(self, session_id=None):
            self.create_calls += 1
            return super().create_session(session_id=session_id)

        def get_session_context(self, session_id, token_budget=128_000, **kwargs):
            self.context_calls += 1
            return super().get_session_context(
                session_id,
                token_budget=token_budget,
                **kwargs,
            )

    client = RecordingClient()
    assembler = OpenVikingSessionContextAssembler(
        include_session_context=True,
        client=client,
        include_recall=False,
    )

    assembler.assemble(session_id="read-before-create", query="")
    assembler.assemble(session_id="read-before-create", query="")

    assert client.context_calls == 2
    assert client.create_calls == 1
    assert "read-before-create" in client.sessions


def test_session_context_assembler_creates_on_code_not_found():
    class ForeignNotFound(Exception):
        def __init__(self):
            super().__init__("session missing")
            self.code = "NOT_FOUND"

    class RecordingClient(InMemoryOpenVikingClient):
        def __init__(self):
            super().__init__()
            self.create_calls = 0

        def create_session(self, session_id=None):
            self.create_calls += 1
            return super().create_session(session_id=session_id)

        def get_session_context(self, session_id, token_budget=128_000, **kwargs):
            if session_id not in self.sessions:
                raise ForeignNotFound()
            return super().get_session_context(
                session_id,
                token_budget=token_budget,
                **kwargs,
            )

    client = RecordingClient()
    assembler = OpenVikingSessionContextAssembler(
        client=client,
        include_recall=False,
    )

    assembler.assemble(session_id="foreign-not-found", query="")

    assert client.create_calls == 1
    assert "foreign-not-found" in client.sessions


def test_with_openviking_context_wraps_runnable_with_history():
    client = InMemoryOpenVikingClient(
        {"viking://resources/runbooks/deploy.md": "Azure is the deployment color."}
    )

    def answer(messages):
        assert "Azure is the deployment color" in messages[0].content
        return AIMessage(content="OpenViking says azure.")

    runnable = with_openviking_context(
        RunnableLambda(answer),
        client=client,
        session_id="wrapped-session",
        target_uri="viking://resources",
    )

    result = runnable.invoke(
        [HumanMessage(content="What deployment color?")],
    )

    assert result.content == "OpenViking says azure."
    assert len(client.sessions["wrapped-session"]) == 2
    assert any(part["type"] == "context" for part in client.sessions["wrapped-session"][1]["parts"])


def test_with_openviking_context_dynamic_session_requires_config():
    client = InMemoryOpenVikingClient()
    runnable = with_openviking_context(
        RunnableLambda(lambda _messages: AIMessage(content="ok")),
        client=client,
    )

    with pytest.raises(ValueError, match="Missing keys .*session_id"):
        runnable.invoke([HumanMessage(content="hi")])


def test_with_openviking_context_dynamic_session_uses_configured_session():
    client = InMemoryOpenVikingClient(
        {"viking://resources/runbooks/deploy.md": "Azure dynamic context."}
    )

    def answer(messages):
        assert "Azure dynamic context" in messages[0].content
        return AIMessage(content="dynamic ok")

    runnable = with_openviking_context(
        RunnableLambda(answer),
        client=client,
        target_uri="viking://resources",
    )

    result = runnable.invoke(
        [HumanMessage(content="What dynamic context?")],
        config={"configurable": {"session_id": "dynamic-session"}},
    )

    assert result.content == "dynamic ok"
    assert client.search_calls[-1]["session_id"] == "dynamic-session"
    assert len(client.sessions["dynamic-session"]) == 2


def test_with_openviking_context_dynamic_session_can_use_thread_id_key():
    client = InMemoryOpenVikingClient(
        {"viking://resources/runbooks/deploy.md": "Thread dynamic context."}
    )
    runnable = with_openviking_context(
        RunnableLambda(lambda _messages: AIMessage(content="thread ok")),
        client=client,
        target_uri="viking://resources",
        session_id_config_key="thread_id",
    )

    result = runnable.invoke(
        [HumanMessage(content="What thread context?")],
        config={"configurable": {"thread_id": "thread-session"}},
    )

    assert result.content == "thread ok"
    assert client.search_calls[-1]["session_id"] == "thread-session"
    assert len(client.sessions["thread-session"]) == 2


def test_with_openviking_context_dynamic_peer_uses_config_for_recall_and_history():
    client = InMemoryOpenVikingClient(
        {"viking://resources/runbooks/deploy.md": "Thread peer dynamic context."}
    )
    runnable = with_openviking_context(
        RunnableLambda(lambda _messages: AIMessage(content="peer ok")),
        client=client,
        target_uri="viking://resources",
        session_id_config_key="thread_id",
    )

    result = runnable.invoke(
        [HumanMessage(content="What peer context?")],
        config={"configurable": {"thread_id": "thread-peer-session", "peer_id": "peer-dynamic"}},
    )

    assert result.content == "peer ok"
    assert client.search_calls[-1]["session_id"] == "thread-peer-session"
    assert "peer_id" not in client.search_calls[-1]
    assert [message.get("peer_id") for message in client.sessions["thread-peer-session"]] == [
        "peer-dynamic",
        "peer-dynamic",
    ]


def test_with_openviking_context_clears_pending_context_after_failure():
    client = InMemoryOpenVikingClient(
        {"viking://resources/runbooks/deploy.md": "Azure failure context."}
    )
    calls = {"count": 0}

    def answer(_messages):
        calls["count"] += 1
        if calls["count"] == 1:
            raise RuntimeError("synthetic model failure")
        return AIMessage(content="Recovered.")

    runnable = with_openviking_context(
        RunnableLambda(answer),
        client=client,
        session_id="failure-session",
        target_uri="viking://resources",
    )

    with pytest.raises(RuntimeError, match="synthetic model failure"):
        runnable.invoke([HumanMessage(content="What deployment color?")])

    client.records.clear()
    result = runnable.invoke([HumanMessage(content="No context this time.")])

    assert result.content == "Recovered."
    assistant_parts = client.sessions["failure-session"][-1]["parts"]
    assert not any(part["type"] == "context" for part in assistant_parts)


def test_with_openviking_context_dynamic_error_clears_pending_context():
    client = InMemoryOpenVikingClient(
        {"viking://resources/runbooks/deploy.md": "Azure dynamic failure context."}
    )
    calls = {"count": 0}

    def answer(_messages):
        calls["count"] += 1
        if calls["count"] == 1:
            raise RuntimeError("synthetic dynamic failure")
        return AIMessage(content="recovered")

    runnable = with_openviking_context(
        RunnableLambda(answer),
        client=client,
        target_uri="viking://resources",
    )

    with pytest.raises(RuntimeError, match="synthetic dynamic failure"):
        runnable.invoke(
            [HumanMessage(content="What dynamic failure context?")],
            config={"configurable": {"session_id": "dynamic-failure-session"}},
        )

    client.records.clear()
    result = runnable.invoke(
        [HumanMessage(content="No context now.")],
        config={"configurable": {"session_id": "dynamic-failure-session"}},
    )

    assert result.content == "recovered"
    assistant_parts = client.sessions["dynamic-failure-session"][-1]["parts"]
    assert not any(part["type"] == "context" for part in assistant_parts)


def test_archive_tools_search_and_expand_committed_session():
    client = InMemoryOpenVikingClient()
    client.add_message("archive-session", "user", content="Remember cobalt archive detail.")
    client.add_message("archive-session", "assistant", content="Cobalt archive detail stored.")
    commit = client.commit_session("archive-session")
    assert commit["archive_id"] == "archive_001"

    tools = {tool.name: tool for tool in create_openviking_tools(client=client)}
    searched = tools["viking_archive_search"].invoke(
        {
            "session_id": "archive-session",
            "archive_id": "archive_001",
            "query": "cobalt archive",
        }
    )
    expanded = tools["viking_archive_expand"].invoke(
        {"session_id": "archive-session", "archive_id": "archive_001"}
    )

    assert "Cobalt archive detail" in searched
    assert "archive_001" in expanded
    assert "Remember cobalt archive detail" in expanded


def test_archive_search_without_archive_id_searches_raw_history():
    client = InMemoryOpenVikingClient()
    client.add_message("archive-search-session", "user", content="Hidden cobalt archive detail.")
    commit = client.commit_session("archive-search-session")
    assert commit["archive_id"] == "archive_001"
    client.archives["archive-search-session"][0]["overview"] = "compressed summary"
    client.archives["archive-search-session"][0]["abstract"] = "compressed summary"

    tools = {tool.name: tool for tool in create_openviking_tools(client=client)}
    searched = tools["viking_archive_search"].invoke(
        {
            "session_id": "archive-search-session",
            "query": "hidden cobalt archive",
        }
    )

    assert "Hidden cobalt archive detail" in searched
    assert "viking://user/default/sessions/archive-search-session/history" in searched


def test_archive_grep_pattern_uses_backend_safe_token_regex():
    assert _archive_grep_pattern("hidden cobalt archive") == "hidden"
    assert "(?=" not in _archive_grep_pattern("hidden cobalt archive")


def test_commit_policy_commits_when_threshold_is_reached():
    client = InMemoryOpenVikingClient()
    history = OpenVikingChatMessageHistory(
        session_id="commit-session",
        client=client,
        commit_policy=OpenVikingCommitPolicy(
            mode="pending_tokens",
            pending_token_threshold=1,
        ),
    )

    history.add_messages(
        [
            HumanMessage(content="first message"),
            AIMessage(content="second message"),
        ]
    )

    assert client.archives["commit-session"]
    assert client.sessions["commit-session"] == []


def test_history_is_empty_after_commit_archives_tool_messages():
    client = InMemoryOpenVikingClient()
    history = OpenVikingChatMessageHistory(
        session_id="orphan-tool-session",
        client=client,
        commit_policy=OpenVikingCommitPolicy(
            mode="pending_tokens",
            pending_token_threshold=1,
        ),
    )

    history.add_messages(
        [
            HumanMessage(content="Find release notes."),
            AIMessage(
                content="Searching.",
                tool_calls=[
                    {
                        "id": "call-orphan",
                        "name": "viking_find",
                        "args": {"query": "release"},
                    }
                ],
            ),
            ToolMessage(
                content="Release notes found.",
                tool_call_id="call-orphan",
                name="viking_find",
            ),
        ]
    )

    assert client.sessions["orphan-tool-session"] == []
    assert history.messages == []


def test_chat_message_history_clear_raises_when_delete_fails():
    class DeleteDeniedClient(InMemoryOpenVikingClient):
        def delete_session(self, session_id: str) -> None:
            raise PermissionError(f"cannot delete {session_id}")

    client = DeleteDeniedClient()
    history = OpenVikingChatMessageHistory(session_id="clear-session", client=client)
    history.add_messages([HumanMessage(content="private stale context")])

    with pytest.raises(PermissionError, match="cannot delete clear-session"):
        history.clear()

    assert len(client.sessions["clear-session"]) == 1


@pytest.mark.parametrize(
    "invalid_namespace",
    [(), ("users", "", "ada"), ("users", 1), ("users", "ada.profile"), ("langgraph", "ada")],
)
def test_langgraph_store_round_trip_and_semantic_search(invalid_namespace):
    client = InMemoryOpenVikingClient()
    store = OpenVikingStore(client=client)

    store.put(
        ("users", "ada"),
        "preferences",
        {"color": "azure", "framework": "langgraph", "nested": {"rank": 3}},
    )
    store.put(("users", "ada"), "profile", {"color": "teal", "framework": "langgraph"})
    store.put(
        ("users", "ada"),
        "bad-rank",
        {"color": "navy", "framework": "langgraph", "nested": {"rank": "high"}},
    )

    item = store.get(("users", "ada"), "preferences")
    assert item.value["framework"] == "langgraph"

    filtered = store.search(("users",), filter={"nested.rank": {"$gte": 3}}, limit=5)
    assert [item.key for item in filtered] == ["preferences"]

    bad_in_filter = store.search(("users",), filter={"framework": {"$in": 3}}, limit=5)
    assert bad_in_filter == []

    semantic = store.search(("users",), query="azure", limit=5)
    assert semantic[0].namespace == ("users", "ada")
    assert semantic[0].value["color"] == "azure"

    assert store.list_namespaces(prefix=("users",)) == [("users", "ada")]

    records = dict(client.records)
    for value in ({"color": "invalid"}, None):
        with pytest.raises(InvalidNamespaceError):
            store.put(invalid_namespace, "preferences", value)
        assert client.records == records
        with pytest.raises(InvalidNamespaceError):
            asyncio.run(store.aput(invalid_namespace, "preferences", value))
        assert client.records == records

    # A None value is a deletion in LangGraph's BaseStore contract.
    store.put(("users", "ada"), "profile", None)
    assert store.get(("users", "ada"), "profile") is None
    assert "profile" not in {found.key for found in store.search(("users",), limit=5)}

    # Deleting a missing key is idempotent and must not create a record.
    store.put(("users", "ada"), "absent", None)
    assert store.get(("users", "ada"), "absent") is None

    store.put(("users", "ada"), "preferences", None)
    store.put(("users", "ada"), "bad-rank", None)
    assert store.search(("users",), limit=5) == []
    assert store.list_namespaces(prefix=("users",)) == []


@pytest.mark.parametrize("method", ["put", "aput", "batch", "abatch", "delete", "adelete"])
@pytest.mark.parametrize("existing", [False, True])
def test_langgraph_store_none_deletes_through_public_store_methods(
    method: str, existing: bool
) -> None:
    store = OpenVikingStore(client=InMemoryOpenVikingClient())
    namespace = ("users", "ada", "memories")
    other_namespace = ("users", "grace", "memories")
    store.put(other_namespace, "keep", {"text": "independent memory"})
    if existing:
        store.put(namespace, "item", {"text": "memory to remove"})

    if method == "put":
        store.put(namespace, "item", None)
    elif method == "aput":
        asyncio.run(store.aput(namespace, "item", None))
    elif method == "batch":
        store.batch([PutOp(namespace, "item", None)])
    elif method == "abatch":
        asyncio.run(store.abatch([PutOp(namespace, "item", None)]))
    elif method == "delete":
        store.delete(namespace, "item")
    else:
        asyncio.run(store.adelete(namespace, "item"))

    assert store.get(namespace, "item") is None
    assert store.search(namespace) == []
    assert store.search(namespace, query="memory to remove") == []
    assert store.list_namespaces() == [other_namespace]
    assert store.get(other_namespace, "keep").value == {"text": "independent memory"}


@pytest.mark.parametrize("index", [False, ["text"]])
@pytest.mark.parametrize("existing", [False, True])
def test_langgraph_store_put_none_deletes_with_index_overrides(
    index: bool | list[str], existing: bool
) -> None:
    store = OpenVikingStore(client=InMemoryOpenVikingClient())
    namespace = ("users", "ada")
    if existing:
        store.put(namespace, "item", {"text": "memory to remove"})

    store.put(namespace, "item", None, index=index)

    assert store.get(namespace, "item") is None
    assert store.search(namespace) == []
    assert store.search(namespace, query="memory to remove") == []
    assert store.list_namespaces() == []


@pytest.mark.parametrize("method", ["put", "aput"])
@pytest.mark.parametrize("value", [{}, {"number": 0}, {"text": "saved memory"}])
def test_langgraph_store_dictionary_values_remain_stored(method: str, value: dict) -> None:
    store = OpenVikingStore(client=InMemoryOpenVikingClient())
    namespace = ("users", "ada")
    if method == "put":
        store.put(namespace, "item", value)
    else:
        asyncio.run(store.aput(namespace, "item", value))

    assert store.get(namespace, "item").value == value
    assert store.search(namespace)[0].value == value
    assert store.list_namespaces() == [namespace]


@pytest.mark.parametrize("method", ["put", "aput"])
@pytest.mark.parametrize("value", [None, {"text": "replacement"}])
def test_langgraph_store_unsupported_ttl_still_rejects_before_mutation(
    method: str, value: dict | None
) -> None:
    store = OpenVikingStore(client=InMemoryOpenVikingClient())
    namespace = ("users", "ada")
    original = {"text": "original memory"}
    store.put(namespace, "item", original)

    with pytest.raises(NotImplementedError, match="TTL"):
        if method == "put":
            store.put(namespace, "item", value, ttl=60)
        else:
            asyncio.run(store.aput(namespace, "item", value, ttl=60))

    assert store.get(namespace, "item").value == original


@pytest.mark.parametrize("use_batch", [False, True])
def test_langgraph_store_accepts_mapping_values(use_batch):
    store = OpenVikingStore(client=InMemoryOpenVikingClient())
    original = {"color": "azure", "nested": {"rank": 3}}
    value = MappingProxyType(original)

    if use_batch:
        store.batch([PutOp(namespace=("users", "ada"), key="preferences", value=value)])
    else:
        store.put(("users", "ada"), "preferences", value)

    item = store.get(("users", "ada"), "preferences")
    assert item.value == original
    assert isinstance(item.value, dict)
    assert store.search(("users",), query="azure")[0].value == original
    assert original == {"color": "azure", "nested": {"rank": 3}}


@pytest.mark.parametrize(
    ("method", "collection", "deindex"),
    [
        (method, collection, False)
        for method in ("delete", "adelete", "put", "aput", "batch", "abatch")
        for collection in ("data", "index")
    ]
    + [(method, "index", True) for method in ("put", "aput", "batch", "abatch")],
)
@pytest.mark.parametrize(
    "error", [PermissionDeniedError(), UnavailableError(), TimeoutError("removal timed out")]
)
async def test_langgraph_store_removal_errors_remain_visible_and_retryable(
    method, collection, deindex, error
):
    class FailingRemoveClient(InMemoryOpenVikingClient):
        fail = True

        def rm(self, uri, recursive=False):
            if self.fail and f"/{collection}/" in uri:
                raise error
            if uri not in self.records:
                raise NotFoundError(uri)
            return super().rm(uri, recursive=recursive)

    client = FailingRemoveClient()
    store = OpenVikingStore(client=client)
    namespace, key, value = ("users",), "ada", {"color": "azure"}
    store.put(namespace, key, value)
    store.put(("other",), key, {"color": "teal"})

    async def mutate():
        replacement = value if deindex else None
        index = False if deindex else None
        if method == "delete":
            store.delete(namespace, key)
        elif method == "adelete":
            await store.adelete(namespace, key)
        elif method == "put":
            store.put(namespace, key, replacement, index=index)
        elif method == "aput":
            await store.aput(namespace, key, replacement, index=index)
        else:
            ops = [
                PutOp(namespace, key, replacement, index=index),
                PutOp(namespace, "later", {"written": True}),
            ]
            if method == "batch":
                store.batch(ops)
            else:
                await store.abatch(ops)

    with pytest.raises(type(error)) as caught:
        await mutate()
    assert str(caught.value) == str(error)
    assert getattr(caught.value, "code", None) == getattr(error, "code", None)
    assert bool(store.get(namespace, key)) is (deindex or collection == "data")
    assert store.get(namespace, "later") is None
    assert store.get(("other",), key).value == {"color": "teal"}

    client.fail = False
    await mutate()
    assert store.search(namespace, query="azure") == []
    item = store.get(namespace, key)
    assert (item.value if item else None) == (value if deindex else None)
    if method in ("batch", "abatch"):
        assert store.get(namespace, "later").value == {"written": True}


@pytest.mark.parametrize("missing_error", [FileNotFoundError, NotFoundError])
def test_langgraph_store_removal_keeps_missing_targets_idempotent(missing_error):
    class StrictRemoveClient(InMemoryOpenVikingClient):
        def rm(self, uri, recursive=False):
            if uri not in self.records:
                raise missing_error(uri)
            return super().rm(uri, recursive=recursive)

    store = OpenVikingStore(client=StrictRemoveClient())
    namespace, key, value = ("users",), "ada", {"color": "azure"}
    store.delete(namespace, key)
    store.put(namespace, key, value, index=False)
    assert store.get(namespace, key).value == value
    store.put(namespace, key, value)
    assert len(store.search(namespace, query="azure")) == 1
    store.delete(namespace, key)
    store.delete(namespace, key)
    assert store.get(namespace, key) is None
    assert store.search(namespace, query="azure") == []


@pytest.mark.asyncio
@pytest.mark.parametrize("query", [None, "doc"])
@pytest.mark.parametrize(
    "filter, expected",
    [
        ({"metadata": {"color": "blue"}}, ["alpha"]),
        ({"metadata": {"nested": {"owner": "ada"}}}, ["alpha"]),
        ({"metadata": {"nested": {"rank": {"$gte": 2}}}}, ["alpha"]),
        ({"metadata": {"detail.region": "eu"}}, ["alpha"]),
        ({"tags": [{"role": "reviewer"}, "memory"]}, ["alpha"]),
        ({"tags": [{"role": "reviewer"}]}, []),
        ({"metadata": {}}, ["alpha", "beta"]),
        ({"metadata": {"color": "black"}}, []),
        ({"metadata.nested.rank": {"gte": 2}}, ["alpha"]),
        ({"metadata.nested": {"$eq": {"rank": 3, "owner": "ada"}}}, ["alpha"]),
        ({"metadata": {"eq": "blue", "label": "blue"}}, ["scalar"]),
        ({"metadata": {"$unknown": "blue"}}, ["scalar"]),
        ({"tags": ["reviewer", "memory"]}, ["scalar"]),
        ({"kind": "doc"}, ["alpha", "beta", "scalar"]),
    ],
)
async def test_langgraph_store_structured_filters(filter, expected, query):
    store = OpenVikingStore(client=InMemoryOpenVikingClient())
    for key, value in {
        "alpha": {
            "kind": "doc",
            "metadata": {
                "color": "blue",
                "nested": {"rank": 3, "owner": "ada"},
                "detail.region": "eu",
            },
            "tags": [{"role": "reviewer", "active": True}, "memory"],
        },
        "beta": {
            "kind": "doc",
            "metadata": {"color": "red", "nested": {"rank": 1, "owner": "bob"}},
            "tags": [{"role": "reader", "active": True}, "memory"],
        },
        "scalar": {"kind": "doc", "metadata": "blue", "tags": ["reviewer", "memory"]},
    }.items():
        store.put(("users", "ada"), key, value)

    op = SearchOp(("users",), filter=filter, query=query)
    results = [
        store.search(("users",), filter=filter, query=query),
        await store.asearch(("users",), filter=filter, query=query),
        store.batch([op])[0],
        (await store.abatch([op]))[0],
    ]
    assert all(sorted(item.key for item in items) == expected for items in results)


def test_langgraph_store_semantic_search_keeps_peer_id_out_of_retrieval():
    client = InMemoryOpenVikingClient()
    store = OpenVikingStore(client=client, actor_peer_id="peer-store")

    store.put(("users",), "ada", {"color": "azure"})
    store.search(("users",), query="azure", limit=5)

    assert "peer_id" not in client.find_calls[-1]


def test_langgraph_store_rejects_ttl_writes():
    store = OpenVikingStore(client=InMemoryOpenVikingClient())

    with pytest.raises(NotImplementedError, match="TTL is not supported"):
        store.put(("users", "ada"), "temporary", {"note": "expires"}, ttl=60)


@pytest.mark.parametrize("use_default", [False, True])
@pytest.mark.parametrize(
    ("field", "query", "expected_match"),
    [
        ("$", "solstice", True),
        ("", "solstice", True),
        ("items[0].text", "pulsar", True),
        ("items[-1].text", "galaxy", True),
        ("items[*].text", "galaxy", True),
        ("nested[*].parts[*].text", "aurora", True),
        ("metadata.*", "quasar", True),
        ("{text,metadata.title}", "nebula", True),
        ("text", "nebula", True),
        ("metadata.title", "quasar", True),
        ("absent", "solstice", False),
        ("literal[0]", "nova", True),
    ],
)
@pytest.mark.asyncio
async def test_langgraph_store_indexes_selected_field_paths(
    field, query, expected_match, use_default
):
    value = {
        "text": "nebula",
        "metadata": {"title": "quasar"},
        "items": [{"text": "pulsar"}, {"text": "galaxy"}],
        "nested": [{"parts": [{"text": "aurora"}]}],
        "literal[0]": "nova",
        "ignored": "solstice",
    }
    original = deepcopy(value)
    for mode in ("put", "aput", "batch", "abatch"):
        client = InMemoryOpenVikingClient()
        store = OpenVikingStore(client=client, index=[field] if use_default else None)
        index = None if use_default else [field]
        if mode == "put":
            store.put(("documents",), "note", value, index=index)
        elif mode == "aput":
            await store.aput(("documents",), "note", value, index=index)
        elif mode == "batch":
            store.batch([PutOp(("documents",), "note", value, index=index)])
        else:
            await store.abatch([PutOp(("documents",), "note", value, index=index)])

        assert store.get(("documents",), "note").value == value
        assert value == original
        expected_keys = ["note"] if expected_match else []
        assert [item.key for item in store.search(("documents",), query=query)] == expected_keys
        filter = {"metadata": {"title": "quasar"}}
        op = SearchOp(("documents",), query=query, filter=filter)
        results = [
            store.search(("documents",), query=query, filter=filter),
            await store.asearch(("documents",), query=query, filter=filter),
            store.batch([op])[0],
            (await store.abatch([op]))[0],
        ]
        assert all([item.key for item in items] == expected_keys for items in results)
        assert (
            store.search(("documents",), query=query, filter={"metadata": {"title": "absent"}})
            == []
        )
        if field not in {"$", ""}:
            assert store.search(("documents",), query="solstice") == []


def test_langgraph_store_batch_rejects_ttl_writes():
    store = OpenVikingStore(client=InMemoryOpenVikingClient())

    with pytest.raises(NotImplementedError, match="TTL is not supported"):
        store.batch(
            [
                PutOp(
                    namespace=("users", "ada"),
                    key="temporary",
                    value={"note": "expires"},
                    ttl=60,
                )
            ]
        )


@pytest.mark.parametrize(
    ("root_uri", "alias_prefix", "canonical_prefix"),
    [
        (
            "viking://~/memories/langgraph_store",
            "viking://~/memories",
            "viking://user/default/memories",
        ),
        (
            "viking://~/peers/support/memories/langgraph_store",
            "viking://~/peers/support/memories",
            "viking://user/default/peers/support/memories",
        ),
        (
            "viking://~/peers/support/resources/langgraph_store",
            "viking://~/peers/support/resources",
            "viking://user/default/peers/support/resources",
        ),
        (
            "viking://user/default/peers/support/memories/langgraph_store",
            "viking://user/default/peers/support/memories",
            "viking://user/default/peers/support/memories",
        ),
    ],
    ids=[
        "user-memory",
        "peer-memory",
        "peer-resource",
        "explicit-peer-memory",
    ],
)
@pytest.mark.parametrize("asynchronous", [False, True])
def test_langgraph_store_accepts_canonical_result_uris_for_home_alias_root(
    root_uri,
    alias_prefix,
    canonical_prefix,
    asynchronous,
):
    class CanonicalizingClient(InMemoryOpenVikingClient):
        def _canonicalize(self, value):
            if isinstance(value, str):
                return value.replace(f"{alias_prefix}/", f"{canonical_prefix}/", 1)
            if isinstance(value, list):
                return [self._canonicalize(item) for item in value]
            return value

        def write(self, uri, content, mode="replace", **kwargs):
            return super().write(self._canonicalize(uri), content, mode=mode, **kwargs)

        def read(self, uri, *args, **kwargs):
            return super().read(self._canonicalize(uri), *args, **kwargs)

        def glob(self, pattern, uri="viking://"):
            return super().glob(pattern, self._canonicalize(uri))

        def find(self, query, target_uri="", **kwargs):
            return super().find(query, self._canonicalize(target_uri), **kwargs)

        def rm(self, uri, recursive=False):
            return super().rm(self._canonicalize(uri), recursive=recursive)

    client = CanonicalizingClient()
    store = OpenVikingStore(client=client, root_uri=root_uri)

    store.put(("users", "ada"), "preferences", {"color": "azure"})

    async def read_results():
        return (
            await store.aget(("users", "ada"), "preferences"),
            await store.asearch(("users",)),
            await store.alist_namespaces(prefix=("users", "*")),
            await store.asearch(("users",), query="azure", limit=5),
        )

    direct, ordinary, namespaces, semantic = (
        asyncio.run(read_results())
        if asynchronous
        else (
            store.get(("users", "ada"), "preferences"),
            store.search(("users",)),
            store.list_namespaces(prefix=("users", "*")),
            store.search(("users",), query="azure", limit=5),
        )
    )
    assert direct.value == {"color": "azure"}
    assert [item.key for item in ordinary] == ["preferences"]
    assert namespaces == [("users", "ada")]
    assert [(item.namespace, item.key, item.value) for item in semantic] == [
        (("users", "ada"), "preferences", {"color": "azure"})
    ]


def test_langgraph_store_ignores_unrelated_canonical_result_uris():
    store = OpenVikingStore(
        client=InMemoryOpenVikingClient(),
        root_uri="viking://~/memories/langgraph_store",
    )

    assert (
        store._parse_index_uri(
            "viking://user/default/agent/support/memories/other_store/index/users/ada.md"
        )
        is None
    )
    assert (
        store._parse_index_uri("viking://user/support/memories/other_store/index/users/ada.md")
        is None
    )

    peer_store = OpenVikingStore(
        client=InMemoryOpenVikingClient(),
        root_uri="viking://~/peers/support/memories/langgraph_store",
    )
    for unrelated_root in (
        "viking://user/default/peers/other/memories/langgraph_store",
        "viking://user/default/memories/langgraph_store",
        "viking://agent/support/memories/langgraph_store",
        "viking://user/default/peers/support/memories/other_store",
        "viking://user/default/peers/support/resources/langgraph_store",
    ):
        assert peer_store._parse_index_uri(f"{unrelated_root}/index/users/ada.md") is None


def test_langgraph_store_waits_for_indexing_by_default():
    class RecordingClient(InMemoryOpenVikingClient):
        def __init__(self):
            super().__init__()
            self.write_wait_values = []

        def write(self, *args, wait=False, **kwargs):
            self.write_wait_values.append(wait)
            return super().write(*args, wait=wait, **kwargs)

    client = RecordingClient()
    store = OpenVikingStore(client=client)

    store.put(("users",), "ada", {"color": "azure"})

    assert client.write_wait_values
    assert all(wait is True for wait in client.write_wait_values)

    async_client = RecordingClient()
    async_store = OpenVikingStore(client=async_client, wait=False)
    async_store.put(("users",), "ada", {"color": "green"})

    assert async_client.write_wait_values
    assert all(wait is False for wait in async_client.write_wait_values)


def test_langgraph_store_uses_create_first_and_preserves_created_at_on_replace():
    class RecordingClient(InMemoryOpenVikingClient):
        def __init__(self):
            super().__init__()
            self.write_modes = []

        def write(self, uri, content, mode="replace", **kwargs):
            self.write_modes.append((uri, mode))
            return super().write(uri, content, mode=mode, **kwargs)

    client = RecordingClient()
    store = OpenVikingStore(client=client)

    store.put(("users",), "ada", {"color": "azure"})
    first = store.get(("users",), "ada")
    store.put(("users",), "ada", {"color": "teal"})
    second = store.get(("users",), "ada")

    data_uri = "viking://~/memories/langgraph_store/data/users/ada.json"
    assert client.write_modes[0] == (data_uri, "create")
    assert (data_uri, "replace") in client.write_modes
    assert second.created_at == first.created_at
    assert second.updated_at >= first.updated_at
    assert second.value["color"] == "teal"


def test_pending_token_commit_does_not_create_missing_session():
    client = InMemoryOpenVikingClient()
    result = apply_commit_policy(
        client,
        "missing-commit-session",
        OpenVikingCommitPolicy(mode="pending_tokens", pending_token_threshold=1),
    )

    assert result is None
    assert "missing-commit-session" not in client.sessions


def test_pending_token_commit_uses_persisted_value_without_session_lookup():
    class RecordingClient(InMemoryOpenVikingClient):
        def __init__(self):
            super().__init__()
            self.get_session_calls = 0

        def get_session(self, session_id, auto_create=False):
            self.get_session_calls += 1
            return super().get_session(session_id, auto_create=auto_create)

    client = RecordingClient()
    client.create_session("persisted-hint-session")

    result = apply_commit_policy(
        client,
        "persisted-hint-session",
        OpenVikingCommitPolicy(mode="pending_tokens", pending_token_threshold=1),
        persisted_pending_tokens=0,
    )

    assert result is None
    assert client.get_session_calls == 0


@pytest.mark.parametrize("shape", ["human", "chat", "chat_chunk", "dict"])
@pytest.mark.parametrize("structured", [False, True])
def test_langgraph_middleware_injects_recall_and_captures_messages(shape, structured):
    client = InMemoryOpenVikingClient(
        {"viking://~/memories/profile.md": "The user prefers azure deployments."}
    )
    middleware = OpenVikingContextMiddleware(
        client=client,
        target_uri="viking://~/memories",
        session_id_resolver=lambda state, runtime: "middleware-session",
        commit_on_after_agent=True,
    )

    captured_request = {}
    content = "What deployment color?"
    if structured:
        content = [
            {"type": "text", "text": content},
            {"type": "image_url", "image_url": {"url": "https://example.com/deployment.png"}},
        ]
    values = {
        "id": "middleware-user-1",
        "name": "customer",
        "content": content,
        "additional_kwargs": {"host_field": {"keep": True}},
    }
    if shape == "dict":
        user = {"role": "user", **values}
    elif shape == "human":
        user = HumanMessage(**values)
    else:
        message_type = ChatMessage if shape == "chat" else ChatMessageChunk
        user = message_type(role="user", **values)
    original = deepcopy(user)
    system = SystemMessage(
        id="policy",
        content=[{"type": "text", "text": "Stable agent policy."}],
        additional_kwargs={"host_field": {"keep": True}},
    )

    class Request:
        def __init__(self, state=None):
            self.state = state or {}
            self.messages = [user]
            self.system_message = system

        def override(self, **overrides):
            new_request = Request(self.state)
            new_request.messages = overrides.get("messages", self.messages)
            new_request.system_message = overrides.get("system_message", self.system_message)
            return new_request

    def handler(request):
        captured_request["request"] = request
        return AIMessage(content="ok")

    middleware.wrap_model_call(Request(), handler)
    first_request = captured_request["request"]
    recall_update = middleware.after_model({}, runtime=None)
    assert recall_update is not None
    assert first_request.system_message is system
    injected = first_request.messages[0]
    injected_values = injected if isinstance(injected, dict) else injected.model_dump()
    original_values = original if isinstance(original, dict) else original.model_dump()
    assert "azure deployments" in str(injected_values["content"])
    assert {k: v for k, v in injected_values.items() if k != "content"} == {
        k: v for k, v in original_values.items() if k != "content"
    }
    if structured:
        assert injected_values["content"][1:] == content
    assert user == original

    # A later model call for the same user turn replays the recorded block,
    # without another search or dropping context parts needed by capture.
    middleware.wrap_model_call(Request(recall_update), handler)
    replayed_request = captured_request["request"]
    assert replayed_request.messages == first_request.messages
    assert len(client.search_calls) == 1

    # Editing the same message ID requires fresh recall rather than a stale replay.
    client.records["viking://~/memories/profile.md"] = "Azure deployments must use Singapore."
    edited_request = Request(recall_update)
    edited_request.messages = [
        {**user, "content": "Which azure region?"}
        if isinstance(user, dict)
        else user.model_copy(update={"content": "Which azure region?"})
    ]
    middleware.wrap_model_call(edited_request, handler)
    assert len(client.search_calls) == 2
    edited = captured_request["request"].messages[0]
    edited_content = edited["content"] if isinstance(edited, dict) else edited.content
    assert "Singapore" in edited_content
    assert user == original

    middleware.after_agent(
        {
            **recall_update,
            "messages": [
                HumanMessage(content="Remember this."),
                AIMessage(content="I will."),
            ],
        },
        runtime=None,
    )
    assert client.sessions["middleware-session"] == []
    assert client.archives["middleware-session"]
    archived_messages = client.archives["middleware-session"][0]["messages"]
    assert len(archived_messages) == 2
    assistant_parts = archived_messages[1]["parts"]
    assert any(part["type"] == "context" for part in assistant_parts)


@pytest.mark.parametrize("asynchronous", [False, True])
@pytest.mark.parametrize("streaming", [False, True])
@pytest.mark.parametrize("capture", [False, True])
@pytest.mark.parametrize("interrupt_tools", [False, True])
@pytest.mark.asyncio
async def test_langgraph_middleware_replays_exact_recall_prefix_after_restart(
    asynchronous, streaming, capture, interrupt_tools
):
    from langchain.agents import create_agent
    from langchain_core.language_models.chat_models import BaseChatModel
    from langchain_core.messages import AIMessageChunk
    from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult
    from langgraph.checkpoint.memory import InMemorySaver
    from pydantic import Field

    class RecordingModel(BaseChatModel):
        requests: list[list[Any]] = Field(default_factory=list)
        response_count: int = 0

        @property
        def _llm_type(self):
            return "recording"

        def bind_tools(self, tools, **kwargs):
            return self

        def _reply(self, messages):
            self.requests.append(list(messages))
            self.response_count += 1
            if messages[-1].type == "tool":
                return AIMessage(content=f"answer-{self.response_count}")
            user = next(message for message in reversed(messages) if message.type == "human")
            return AIMessage(
                content="Checking the deployment.",
                tool_calls=[{"id": f"lookup-{user.id}", "name": "lookup_deployment", "args": {}}],
            )

        def _generate(self, messages, stop=None, run_manager=None, **kwargs):
            return ChatResult(generations=[ChatGeneration(message=self._reply(messages))])

        def _stream(self, messages, stop=None, run_manager=None, **kwargs):
            response = self._reply(messages)
            yield ChatGenerationChunk(
                message=AIMessageChunk(content=response.content, tool_calls=response.tool_calls)
            )

        async def _astream(self, messages, stop=None, run_manager=None, **kwargs):
            for chunk in self._stream(messages, stop, run_manager, **kwargs):
                yield chunk

    def lookup_deployment() -> str:
        """Check the current deployment status."""
        return "The deployment is ready."

    def request_bytes(messages):
        wire = convert_to_openai_messages(messages, text_format="block")
        return json.dumps(wire, ensure_ascii=False, separators=(",", ":")).encode()

    client = InMemoryOpenVikingClient(
        {"viking://~/memories/profile.md": "The user prefers azure deployments."}
    )
    checkpointer = InMemorySaver()
    config = {"configurable": {"thread_id": "prefix-session"}}

    def build_agent(model, *, pause_before_tools=False):
        return create_agent(
            model,
            tools=[lookup_deployment],
            system_prompt="Stable agent policy.",
            middleware=[
                OpenVikingContextMiddleware(
                    client=client,
                    target_uri="viking://~/memories",
                    capture_on_after_agent=capture,
                    # Python 3.10 async tasks cannot resolve the graph's config context.
                    session_id_resolver=lambda _state, _runtime: "prefix-session",
                )
            ],
            checkpointer=checkpointer,
            interrupt_before=["tools"] if pause_before_tools else None,
        )

    async def run(agent, text):
        payload = None if text is None else {"messages": [{"role": "user", "content": text}]}
        if streaming:
            events = (
                [
                    event
                    async for event in agent.astream(
                        payload, config, stream_mode=["messages", "updates"]
                    )
                ]
                if asynchronous
                else list(agent.stream(payload, config, stream_mode=["messages", "updates"]))
            )
            assert any(mode == "updates" for mode, _ in events)
            # Python 3.10 lacks implicit async callback propagation in LangChain 1.0.
            if not asynchronous or sys.version_info >= (3, 11):
                assert any(
                    mode == "messages" and isinstance(event[0], AIMessageChunk)
                    for mode, event in events
                )
        elif asynchronous:
            await agent.ainvoke(payload, config)
        else:
            agent.invoke(payload, config)

    model = RecordingModel()
    agent = build_agent(model)
    for schema in (agent.get_input_schema(), agent.get_output_schema()):
        assert "openviking_recall_ledger" not in schema.model_json_schema().get("properties", {})
        assert "openviking_pending_context" not in schema.model_json_schema().get("properties", {})
    await run(agent, "first azure deployment prompt")
    client.records["viking://~/memories/profile.md"] = "Azure deployments must use Singapore."
    if interrupt_tools:
        agent = build_agent(model, pause_before_tools=True)
    await run(agent, "second azure deployment prompt")
    state = agent.get_state(config).values

    assert len(client.search_calls) == 2
    assert all(message.id for message in state["messages"] if message.type == "human")
    assert [message.content for message in state["messages"] if message.type == "human"] == [
        "first azure deployment prompt",
        "second azure deployment prompt",
    ]
    assert sum(len(ledger) for ledger in state["openviking_recall_ledger"].values()) == 2
    assert len(model.requests) == (3 if interrupt_tools else 4)
    assert "azure deployments" in model.requests[0][1].content
    assert "Singapore" in model.requests[2][-1].content

    # A fresh middleware and graph recover the ledger from the same checkpointer.
    restarted_model = RecordingModel()
    restarted_agent = build_agent(restarted_model)
    if interrupt_tools:
        assert agent.get_state(config).next == ("tools",)
        await run(restarted_agent, None)
        assert len(client.search_calls) == 2
        references = [
            part
            for message in client.sessions["prefix-session"]
            for part in message.get("parts", [])
            if part["type"] == "context"
        ]
        assert len(references) == (2 if capture else 0)
        if capture:
            assert references[-1] == {
                "type": "context",
                "uri": "viking://~/memories/profile.md",
                "context_type": "memory",
                "abstract": "Azure deployments must use Singapore.",
            }
    await run(restarted_agent, "third azure deployment prompt")
    restarted_state = restarted_agent.get_state(config).values

    assert len(client.search_calls) == 3
    requests = model.requests + restarted_model.requests
    for previous, current in zip(requests, requests[1:], strict=False):
        assert request_bytes(current[: len(previous)]) == request_bytes(previous)
        assert current[0].content == "Stable agent policy."
    assert sum(len(ledger) for ledger in restarted_state["openviking_recall_ledger"].values()) == 3
    captured = client.sessions["prefix-session"]
    if capture:
        assert len(captured) == 12
        parts = [part for message in captured for part in message.get("parts", [])]
        assert not any(
            "<openviking_context>" in part.get("text", "")
            for part in parts
            if part["type"] == "text"
        )
        assert len([part for part in parts if part["type"] == "tool"]) == 6
        assert len([part for part in parts if part["type"] == "context"]) == 3
        assert [
            message.content for message in restarted_state["messages"] if message.type == "human"
        ] == [
            "first azure deployment prompt",
            "second azure deployment prompt",
            "third azure deployment prompt",
        ]
        assert not restarted_state.get("openviking_pending_context")
    else:
        assert captured == []


@pytest.mark.parametrize("has_context", [False, True])
@pytest.mark.parametrize("error_type", [RuntimeError, KeyboardInterrupt])
def test_langgraph_middleware_discards_recall_when_model_call_fails(has_context, error_type):
    client = InMemoryOpenVikingClient(
        {"viking://~/memories/profile.md": "Azure deployments use a stale region."}
        if has_context
        else {}
    )
    middleware = OpenVikingContextMiddleware(
        client=client,
        session_id_resolver=lambda _state, _runtime: "empty-failure-session",
    )

    class Request:
        state = {}
        runtime = None
        messages = [HumanMessage(id="empty-failure-user", content="Find azure deployments.")]
        system_message = None

        def override(self, **overrides):
            request = Request()
            request.messages = overrides.get("messages", self.messages)
            return request

    def handler(_request):
        raise error_type("model failed")

    with pytest.raises(error_type, match="model failed"):
        middleware.wrap_model_call(Request(), handler)

    assert middleware.after_model({"messages": Request.messages}, runtime=None) is None
    client.records["viking://~/memories/profile.md"] = "Azure deployments now use Singapore."
    seen = []
    middleware.wrap_model_call(Request(), lambda request: seen.append(request))
    assert len(client.search_calls) == 2
    assert "Singapore" in seen[0].messages[0].content


def test_langgraph_middleware_batches_persistence_before_separate_commit():
    class RecordingClient(InMemoryOpenVikingClient):
        def __init__(self):
            super().__init__()
            self.events = []
            self._inside_batch = False

        def add_message(self, *args, **kwargs):
            if not self._inside_batch:
                self.events.append("add_message")
            return super().add_message(*args, **kwargs)

        def batch_add_messages(self, *args, **kwargs):
            self.events.append("batch_add_messages")
            self._inside_batch = True
            try:
                return super().batch_add_messages(*args, **kwargs)
            finally:
                self._inside_batch = False

        def get_session(self, *args, **kwargs):
            self.events.append("get_session")
            return super().get_session(*args, **kwargs)

        def commit_session(self, *args, **kwargs):
            self.events.append("commit_session")
            return super().commit_session(*args, **kwargs)

    client = RecordingClient()
    middleware = OpenVikingContextMiddleware(
        client=client,
        session_id_resolver=lambda state, runtime: "middleware-batch-commit",
        commit_policy=OpenVikingCommitPolicy(
            mode="pending_tokens",
            pending_token_threshold=1,
        ),
    )

    middleware.after_agent(
        {
            "messages": [
                HumanMessage(content="Persist me in one batch."),
                AIMessage(content="Then commit separately."),
            ]
        },
        runtime=None,
    )

    assert client.events == ["batch_add_messages", "commit_session"]
    assert client.archives["middleware-batch-commit"]


def test_langgraph_middleware_uses_peer_id_only_for_message_capture():
    client = InMemoryOpenVikingClient(
        {"viking://~/memories/profile.md": "The middleware peer prefers azure."}
    )
    middleware = OpenVikingContextMiddleware(
        client=client,
        target_uri="viking://~/memories",
        session_id_resolver=lambda state, runtime: "middleware-peer-session",
    )

    class Request:
        state = {"peer_id": "peer-middleware"}
        messages = [HumanMessage(content="What peer color?")]
        system_message = None

        def override(self, **overrides):
            new_request = Request()
            new_request.messages = overrides.get("messages", self.messages)
            new_request.system_message = overrides.get("system_message", self.system_message)
            new_request.state = self.state
            return new_request

    middleware.wrap_model_call(Request(), lambda request: AIMessage(content="ok"))
    middleware.after_agent(
        {
            "peer_id": "peer-middleware",
            "messages": [
                HumanMessage(content="Remember middleware peer."),
                AIMessage(content="Stored."),
            ],
        },
        runtime=None,
    )

    assert "peer_id" not in client.search_calls[-1]
    assert [message.get("peer_id") for message in client.sessions["middleware-peer-session"]] == [
        "peer-middleware",
        "peer-middleware",
    ]


def test_langgraph_middleware_does_not_duplicate_active_messages_in_context():
    client = InMemoryOpenVikingClient(
        {"viking://~/memories/profile.md": "Middleware recall uses green context."}
    )
    client.add_message(
        "middleware-active-session",
        "user",
        content="OpenViking active duplicate user turn.",
    )
    client.add_message(
        "middleware-active-session",
        "assistant",
        content="OpenViking active duplicate assistant turn.",
    )
    middleware = OpenVikingContextMiddleware(
        client=client,
        target_uri="viking://~/memories",
        session_id_resolver=lambda state, runtime: "middleware-active-session",
    )
    captured_request = {}

    class Request:
        messages = [HumanMessage(content="What middleware recall?")]
        system_message = None

        def override(self, **overrides):
            new_request = Request()
            new_request.messages = overrides.get("messages", self.messages)
            new_request.system_message = overrides.get("system_message", self.system_message)
            return new_request

    def handler(request):
        captured_request["request"] = request
        return AIMessage(content="ok")

    middleware.wrap_model_call(Request(), handler)
    recalled_content = captured_request["request"].messages[0].content
    assert captured_request["request"].system_message is None
    assert "Middleware recall uses green context" in recalled_content
    assert "OpenViking active duplicate user turn" not in recalled_content
    assert "OpenViking active duplicate assistant turn" not in recalled_content


def test_langgraph_middleware_uses_runtime_thread_id():
    client = InMemoryOpenVikingClient(
        {"viking://~/memories/profile.md": "Runtime thread users prefer teal."}
    )
    middleware = OpenVikingContextMiddleware(
        client=client,
        target_uri="viking://~/memories",
    )
    captured_request = {}

    class Runtime:
        config = {"configurable": {"thread_id": "runtime-thread"}}

    class Request:
        state = {}
        runtime = Runtime()
        messages = [HumanMessage(content="What runtime color?")]
        system_message = None

        def override(self, **overrides):
            new_request = Request()
            new_request.messages = overrides.get("messages", self.messages)
            new_request.system_message = overrides.get("system_message", self.system_message)
            return new_request

    def handler(request):
        captured_request["request"] = request
        return AIMessage(content="ok")

    middleware.wrap_model_call(Request(), handler)
    assert captured_request["request"].system_message is None
    assert "Runtime thread users prefer teal" in captured_request["request"].messages[0].content
    assert client.search_calls[-1]["session_id"] == "runtime-thread"

    middleware.after_agent(
        {
            "messages": [
                HumanMessage(content="Remember runtime thread."),
                AIMessage(content="Stored for runtime thread."),
            ]
        },
        Runtime(),
    )
    assert len(client.sessions["runtime-thread"]) == 2


def test_langgraph_middleware_requires_explicit_session_id():
    client = InMemoryOpenVikingClient(
        {"viking://~/memories/profile.md": "Shared fallback should never be used."}
    )
    middleware = OpenVikingContextMiddleware(
        client=client,
        target_uri="viking://~/memories",
    )

    class Request:
        state = {}
        runtime = None
        messages = [HumanMessage(content="What context?")]
        system_message = None

        def override(self, **overrides):
            new_request = Request()
            new_request.messages = overrides.get("messages", self.messages)
            new_request.system_message = overrides.get("system_message", self.system_message)
            return new_request

    def handler(request):
        return AIMessage(content="ok")

    with pytest.raises(ValueError, match="thread_id"):
        middleware.wrap_model_call(Request(), handler)

    with pytest.raises(ValueError, match="session_id"):
        middleware.after_agent(
            {
                "messages": [
                    HumanMessage(content="Remember this."),
                    AIMessage(content="Stored."),
                ]
            },
            runtime=None,
        )

    assert "langgraph-default" not in client.sessions


def test_langgraph_middleware_captures_cumulative_state_once():
    client = InMemoryOpenVikingClient()
    middleware = OpenVikingContextMiddleware(
        client=client,
        session_id_resolver=lambda state, runtime: "middleware-cumulative",
    )
    first_turn = [
        HumanMessage(content="Remember first turn."),
        AIMessage(content="First turn stored."),
    ]
    second_turn = first_turn + [
        HumanMessage(content="Remember second turn."),
        AIMessage(content="Second turn stored."),
    ]

    middleware.after_agent({"messages": first_turn}, runtime=None)
    middleware.after_agent({"messages": second_turn}, runtime=None)
    middleware.after_agent({"messages": second_turn}, runtime=None)

    assert [
        message["parts"][0]["text"] for message in client.sessions["middleware-cumulative"]
    ] == [
        "Remember first turn.",
        "First turn stored.",
        "Remember second turn.",
        "Second turn stored.",
    ]


def test_langgraph_middleware_captures_latest_only_state_each_turn():
    client = InMemoryOpenVikingClient()
    middleware = OpenVikingContextMiddleware(
        client=client,
        session_id_resolver=lambda state, runtime: "middleware-latest-only",
    )
    first_turn = [
        HumanMessage(content="Remember latest first."),
        AIMessage(content="Latest first stored."),
    ]
    replayed_first_turn = [
        HumanMessage(content="Remember latest first."),
        AIMessage(content="Latest first stored."),
    ]
    second_turn = [
        HumanMessage(content="Remember latest second."),
        AIMessage(content="Latest second stored."),
    ]

    middleware.after_agent({"messages": first_turn}, runtime=None)
    middleware.after_agent({"messages": replayed_first_turn}, runtime=None)
    middleware.after_agent({"messages": second_turn}, runtime=None)

    assert [
        message["parts"][0]["text"] for message in client.sessions["middleware-latest-only"]
    ] == [
        "Remember latest first.",
        "Latest first stored.",
        "Remember latest second.",
        "Latest second stored.",
    ]


def test_langgraph_middleware_captures_in_place_message_mutation():
    client = InMemoryOpenVikingClient()
    middleware = OpenVikingContextMiddleware(
        client=client,
        session_id_resolver=lambda state, runtime: "middleware-mutated",
    )
    messages = [
        HumanMessage(content="Remember mutable first."),
        AIMessage(content="Mutable first stored."),
    ]

    middleware.after_agent({"messages": messages}, runtime=None)
    messages[0].content = "Remember mutable second."
    messages[1].content = "Mutable second stored."
    middleware.after_agent({"messages": messages}, runtime=None)

    assert [message["parts"][0]["text"] for message in client.sessions["middleware-mutated"]] == [
        "Remember mutable first.",
        "Mutable first stored.",
        "Remember mutable second.",
        "Mutable second stored.",
    ]


def test_langgraph_middleware_captures_same_id_changed_content():
    client = InMemoryOpenVikingClient()
    middleware = OpenVikingContextMiddleware(
        client=client,
        session_id_resolver=lambda state, runtime: "middleware-same-id",
    )

    middleware.after_agent(
        {
            "messages": [
                HumanMessage(content="Remember same id first.", id="user-stable"),
                AIMessage(content="Same id first stored.", id="assistant-stable"),
            ]
        },
        runtime=None,
    )
    middleware.after_agent(
        {
            "messages": [
                HumanMessage(content="Remember same id second.", id="user-stable"),
                AIMessage(content="Same id second stored.", id="assistant-stable"),
            ]
        },
        runtime=None,
    )

    assert [message["parts"][0]["text"] for message in client.sessions["middleware-same-id"]] == [
        "Remember same id first.",
        "Same id first stored.",
        "Remember same id second.",
        "Same id second stored.",
    ]


def test_langgraph_middleware_signature_includes_dict_tool_output():
    first = {
        "role": "tool",
        "tool_call_id": "call-dict",
        "name": "viking_find",
        "tool_output": "first output",
    }
    second = {
        "role": "tool",
        "tool_call_id": "call-dict",
        "name": "viking_find",
        "tool_output": "second output",
    }

    assert _message_signature(first) != _message_signature(second)
    assert _message_signature(second) == _message_signature(dict(second))


def test_langgraph_middleware_clears_pending_context_on_duplicate_retry():
    client = InMemoryOpenVikingClient({"viking://~/memories/profile.md": "Retry cleanup context."})
    middleware = OpenVikingContextMiddleware(
        client=client,
        target_uri="viking://~/memories",
        session_id_resolver=lambda state, runtime: "middleware-pending-cleanup",
    )

    class Request:
        messages = [HumanMessage(content="What retry context?")]
        system_message = None

        def override(self, **overrides):
            new_request = Request()
            new_request.messages = overrides.get("messages", self.messages)
            new_request.system_message = overrides.get("system_message", self.system_message)
            return new_request

    def handler(request):
        return AIMessage(content="Retry context stored.")

    middleware.wrap_model_call(Request(), handler)
    middleware.after_agent(
        {
            "messages": [
                HumanMessage(content="What retry context?"),
                AIMessage(content="Retry context stored."),
            ]
        },
        runtime=None,
    )
    middleware.wrap_model_call(Request(), handler)
    middleware.after_agent(
        {
            "messages": [
                HumanMessage(content="What retry context?"),
                AIMessage(content="Retry context stored."),
            ]
        },
        runtime=None,
    )
    middleware.after_agent(
        {
            "messages": [
                HumanMessage(content="Remember unrelated turn."),
                AIMessage(content="Unrelated turn stored."),
            ]
        },
        runtime=None,
    )

    unrelated_assistant_parts = client.sessions["middleware-pending-cleanup"][-1]["parts"]
    assert unrelated_assistant_parts == [{"type": "text", "text": "Unrelated turn stored."}]


def test_langgraph_middleware_retries_failed_batch_with_pending_context():
    class FailFirstBatchClient(InMemoryOpenVikingClient):
        def __init__(self):
            super().__init__({"viking://~/memories/profile.md": "Retained retry context."})
            self.batch_attempts = 0

        def batch_add_messages(self, session_id, messages, **kwargs):
            self.batch_attempts += 1
            if self.batch_attempts == 1:
                raise RuntimeError("batch write failed")
            return super().batch_add_messages(session_id, messages, **kwargs)

    client = FailFirstBatchClient()
    middleware = OpenVikingContextMiddleware(
        client=client,
        target_uri="viking://~/memories",
        session_id_resolver=lambda state, runtime: "middleware-batch-retry",
    )

    class Request:
        messages = [HumanMessage(content="What retry context?")]
        system_message = None

        def override(self, **overrides):
            new_request = Request()
            new_request.messages = overrides.get("messages", self.messages)
            new_request.system_message = overrides.get("system_message", self.system_message)
            return new_request

    middleware.wrap_model_call(Request(), lambda request: AIMessage(content="ok"))
    state = {
        "messages": [
            HumanMessage(content="What retry context?"),
            AIMessage(content="Retry context stored."),
        ]
    }

    with pytest.raises(RuntimeError, match="batch write failed"):
        middleware.after_agent(state, runtime=None)
    middleware.after_agent(state, runtime=None)

    assert client.batch_attempts == 2
    assert len(client.sessions["middleware-batch-retry"]) == 2
    assistant_parts = client.sessions["middleware-batch-retry"][1]["parts"]
    assert sum(part["type"] == "context" for part in assistant_parts) == 1


def test_langgraph_middleware_chunks_batches_at_server_limit():
    class CappedBatchClient(InMemoryOpenVikingClient):
        def __init__(self):
            super().__init__()
            self.batch_sizes = []

        def batch_add_messages(self, session_id, messages, **kwargs):
            if len(messages) > 100:
                raise RuntimeError("server batch limit exceeded")
            self.batch_sizes.append(len(messages))
            return super().batch_add_messages(session_id, messages, **kwargs)

    client = CappedBatchClient()
    middleware = OpenVikingContextMiddleware(
        client=client,
        session_id_resolver=lambda state, runtime: "middleware-large-batch",
    )
    state = {"messages": [HumanMessage(content=f"Message {index}") for index in range(101)]}

    middleware.after_agent(state, runtime=None)
    middleware.after_agent(state, runtime=None)

    assert client.batch_sizes == [100, 1]
    assert len(client.sessions["middleware-large-batch"]) == 101


def test_langgraph_middleware_retries_only_failed_batch_chunk():
    class FailSecondBatchClient(InMemoryOpenVikingClient):
        def __init__(self):
            super().__init__()
            self.batch_sizes = []

        def batch_add_messages(self, session_id, messages, **kwargs):
            self.batch_sizes.append(len(messages))
            if len(self.batch_sizes) == 2:
                raise RuntimeError("second batch failed")
            return super().batch_add_messages(session_id, messages, **kwargs)

    client = FailSecondBatchClient()
    middleware = OpenVikingContextMiddleware(
        client=client,
        session_id_resolver=lambda state, runtime: "middleware-chunk-retry",
    )
    middleware._pending_context_parts[("middleware-chunk-retry", "")] = [
        {"type": "context", "uri": "viking://resources/retry.md"}
    ]
    messages = [HumanMessage(content="First"), AIMessage(content="Context holder")]
    messages.extend(HumanMessage(content=f"Message {index}") for index in range(98))
    messages.append(AIMessage(content="Retry only this message"))
    state = {"messages": messages}

    with pytest.raises(RuntimeError, match="second batch failed"):
        middleware.after_agent(state, runtime=None)
    middleware.after_agent(state, runtime=None)
    middleware.after_agent(state, runtime=None)

    assert client.batch_sizes == [100, 1, 1]
    stored = client.sessions["middleware-chunk-retry"]
    assert len(stored) == 101
    assert sum(part["type"] == "context" for message in stored for part in message["parts"]) == 1