Skip to content

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

10.5 KB
Raw Blame
# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
# SPDX-License-Identifier: AGPL-3.0

import pytest

from openviking.message import Message, ToolPart
from openviking.server.identity import RequestContext, Role
from openviking.session.memory.dataclass import ResolvedOperation, ResolvedOperations
from openviking.session.memory.experience_lineage import (
    collect_read_experience_uris,
    experience_source_tag,
    normalize_trajectory_outcome,
    trajectory_outcome_tag,
)
from openviking.session.train.components.trajectory_analyzer import (
    _trajectory_search_tags_by_uri,
)
from openviking.utils.tags import build_search_tags_filter, merge_search_tags, normalize_search_tags
from openviking_cli.session.user_id import UserIdentifier


def _ctx() -> RequestContext:
    return RequestContext(user=UserIdentifier("account", "alice"), role=Role.USER)


def test_collect_read_experience_uris_supports_generic_openviking_reads():
    uri = "viking://user/alice/memories/experiences/order-exchange.md"
    opencode_uri = "viking://user/alice/memories/experiences/opencode.md"
    messages = [
        Message(
            id="call",
            role="assistant",
            parts=[
                ToolPart(
                    tool_id="read-1",
                    tool_name="mcp__openviking__read",
                    tool_input={"uris": "viking://~/memories/experiences/order-exchange.md"},
                    tool_status="pending",
                ),
                ToolPart(
                    tool_id="search-1",
                    tool_name="mcp__openviking__find",
                    tool_input={"query": "exchange"},
                    tool_status="completed",
                    tool_output='{"results":[{"uri":"%s"}]}' % uri,
                ),
            ],
        ),
        Message(
            id="result",
            role="user",
            parts=[
                ToolPart(
                    tool_id="read-1",
                    tool_name="mcp__openviking__read",
                    tool_status="completed",
                    tool_output="Experience body without a URI.",
                ),
                ToolPart(
                    tool_id="read-2",
                    tool_name="openviking_read",
                    tool_input={"uri": "viking://user/bob/memories/experiences/other.md"},
                    tool_status="completed",
                ),
                ToolPart(
                    tool_id="read-2-current-user",
                    tool_name="openviking_read",
                    tool_input={"uri": opencode_uri},
                    tool_status="completed",
                ),
                ToolPart(
                    tool_id="read-3",
                    tool_name="read",
                    tool_input={"uris": "viking://~/memories/experiences/failed.md"},
                    tool_status="error",
                ),
                ToolPart(
                    tool_id="read-4",
                    tool_name="read",
                    tool_input={"uris": uri},
                    tool_status="completed",
                    tool_output="The same experience read through its canonical URI.",
                ),
                ToolPart(
                    tool_id="read-5",
                    tool_name="read",
                    tool_input={"uris": "viking://~/memories/experiences/unfinished.md"},
                    tool_status="running",
                ),
                ToolPart(
                    tool_id="read-6",
                    tool_name="read",
                    tool_input={
                        "uris": [
                            "file:///tmp/experience.md",
                            "viking://~/memories/experiences/.abstract.md",
                            "viking://~/memories/experiences/../other.md",
                            "viking://~/memories/experiences/example.md?offset=1",
                            "viking://~/memories/experiences/example.md#section",
                        ]
                    },
                    tool_status="completed",
                ),
            ],
        ),
    ]

    assert collect_read_experience_uris(messages, ctx=_ctx()) == [uri, opencode_uri]


@pytest.mark.parametrize(
    "tool_name",
    [
        "mcp__plugin_openviking-memory_openviking__read",
        "mcp__PLUGIN_openviking-memory_OpenViking__READ",
    ],
)
def test_collect_read_experience_uris_supports_plugin_namespaced_reads(tool_name):
    uri = "viking://user/alice/memories/experiences/plugin-read.md"
    messages = [
        Message(
            id="plugin-read",
            role="user",
            parts=[
                ToolPart(
                    tool_id="plugin-read-1",
                    tool_name=tool_name,
                    tool_input={"uri": uri},
                    tool_status="completed",
                )
            ],
        )
    ]

    assert collect_read_experience_uris(messages, ctx=_ctx()) == [uri]


@pytest.mark.parametrize(
    "tool_name",
    [
        "multi_read",
        "openviking_multi_read",
        "mcp__plugin_openviking-memory_openviking__multi_read",
        "mcp__PLUGIN_openviking-memory_OpenViking__MULTI_READ",
    ],
)
def test_collect_read_experience_uris_filters_failed_multi_read_results(tool_name):
    first_uri = "viking://user/alice/memories/experiences/first.md"
    failed_uri = "viking://user/alice/memories/experiences/failed.md"
    messages = [
        Message(
            id="multi-read",
            role="user",
            parts=[
                ToolPart(
                    tool_id="multi-read-1",
                    tool_name=tool_name,
                    tool_input={"uris": [first_uri, failed_uri]},
                    tool_status="completed",
                    tool_output=(
                        '{"results":['
                        f'{{"uri":"{first_uri}","success":true}},'
                        f'{{"uri":"{failed_uri}","success":false}}]}}'
                    ),
                )
            ],
        )
    ]

    assert collect_read_experience_uris(messages, ctx=_ctx()) == [first_uri]


def test_collect_read_experience_uris_ignores_other_plugin_read_tools():
    messages = [
        Message(
            id="other-plugin-read",
            role="user",
            parts=[
                ToolPart(
                    tool_id="other-plugin-read-1",
                    tool_name="mcp__plugin_other-memory_other__read",
                    tool_input={"uri": "viking://user/alice/memories/experiences/other.md"},
                    tool_status="completed",
                )
            ],
        )
    ]

    assert collect_read_experience_uris(messages, ctx=_ctx()) == []


def test_collect_read_experience_uris_ignores_removed_dedicated_tool():
    messages = [
        Message(
            id="legacy-read",
            role="user",
            parts=[
                ToolPart(
                    tool_id="legacy-read-1",
                    tool_name="read_experience",
                    tool_input={"uri": "viking://user/alice/memories/experiences/legacy.md"},
                    tool_status="completed",
                )
            ],
        )
    ]

    assert collect_read_experience_uris(messages, ctx=_ctx()) == []


@pytest.mark.parametrize(
    "uri",
    [
        "viking://user/alice/memories/experiences/cfg_streaming.md",
        "viking://user/alice/memories/experiences/无订单号换货处理.md",
        "viking://user/alice/memories/experiences/vikingdb_fe_repo_workflows.md",
        "viking://user/alice/memories/experiences/" + "nested/" * 40 + "workflow.md",
    ],
)
def test_experience_source_tag_uses_experience_uri_as_key(uri):
    tag = experience_source_tag(uri)

    assert tag == f"{uri}=1"
    assert tag.count("=") == 1
    assert normalize_search_tags([tag], discard_invalid=True) == [tag]
    assert merge_search_tags([tag], ["env=stg"]) == [tag, "env=stg"]
    assert build_search_tags_filter([tag]) == {
        "op": "must",
        "field": "search_tags",
        "conds": [tag],
    }


def test_experience_source_tag_preserves_case_and_escapes_equals_without_collisions():
    uppercase_uri = "viking://user/Alice/memories/experiences/Exchange=Flow.md"
    lowercase_uri = "viking://user/alice/memories/experiences/exchange=flow.md"

    uppercase_tag = experience_source_tag(uppercase_uri)
    lowercase_tag = experience_source_tag(lowercase_uri)

    assert uppercase_tag == ("viking://user/%41lice/memories/experiences/%45xchange%3d%46low.md=1")
    assert lowercase_tag == "viking://user/alice/memories/experiences/exchange%3dflow.md=1"
    assert uppercase_tag != lowercase_tag
    assert uppercase_tag.count("=") == 1
    assert lowercase_tag.count("=") == 1
    assert merge_search_tags([uppercase_tag], [lowercase_tag]) == [uppercase_tag, lowercase_tag]


def test_source_experiences_create_transient_tags_for_every_generated_trajectory():
    first_uri = "viking://user/alice/memories/experiences/exchange.md"
    second_uri = "viking://user/alice/memories/experiences/refund.md"
    operations = ResolvedOperations(
        upsert_operations=[
            ResolvedOperation(
                memory_fields={"trajectory_name": "exchange", "outcome": "success"},
                memory_type="trajectories",
                uris=["viking://user/alice/memories/trajectories/exchange.md"],
            ),
            ResolvedOperation(
                memory_fields={"trajectory_name": "refund", "outcome": "failure"},
                memory_type="trajectories",
                uris=["viking://user/alice/memories/trajectories/refund.md"],
            ),
        ],
        delete_file_contents=[],
        errors=[],
    )

    tags_by_uri = _trajectory_search_tags_by_uri(
        operations,
        [first_uri, second_uri, first_uri],
    )

    assert tags_by_uri == {
        "viking://user/alice/memories/trajectories/exchange.md": [
            experience_source_tag(first_uri),
            experience_source_tag(second_uri),
            "trajectory_outcome=success",
        ],
        "viking://user/alice/memories/trajectories/refund.md": [
            experience_source_tag(first_uri),
            experience_source_tag(second_uri),
            "trajectory_outcome=failure",
        ],
    }
    for operation in operations.upsert_operations:
        assert "source_experience_uris" not in operation.memory_fields


def test_trajectory_outcome_tag_normalizes_unknown_values():
    assert trajectory_outcome_tag(" SUCCESS ") == "trajectory_outcome=success"
    assert trajectory_outcome_tag("unexpected") == "trajectory_outcome=unknown"
    assert normalize_trajectory_outcome(None) == "unknown"