Skip to content

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

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

import asyncio
import contextvars
import json
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock

import pytest

from openviking.server.identity import RequestContext, Role
from openviking.storage.viking_fs import VikingFS
from openviking_cli.retrieve.types import ContextType, MatchedContext, QueryResult
from openviking_cli.session.user_id import UserIdentifier
from openviking_cli.utils.config.retrieval_config import RetrievalConfig


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


def _make_viking_fs(*, enable_intent: bool) -> VikingFS:
    fs = VikingFS.__new__(VikingFS)
    fs.agfs = MagicMock()
    fs.acl_manager = None
    fs.query_embedder = MagicMock(name="embedder")
    fs.rerank_config = None
    fs.retrieval_config = RetrievalConfig(enable_intent=enable_intent)
    fs.vector_store = MagicMock(name="vector_store")
    fs._bound_ctx = contextvars.ContextVar("vikingfs_bound_ctx_intent_test", default=None)
    fs._ensure_access = AsyncMock()
    fs._get_vector_store = MagicMock(return_value=fs.vector_store)
    fs._get_embedder = MagicMock(return_value=fs.query_embedder)
    fs._ctx_or_default = MagicMock(return_value=_ctx())
    fs.abstract = AsyncMock(return_value="")
    return fs


def test_retrieval_config_enable_intent_defaults_true():
    cfg = RetrievalConfig()
    assert cfg.enable_intent is True


def test_retrieval_config_enable_intent_can_disable():
    cfg = RetrievalConfig(enable_intent=False)
    assert cfg.enable_intent is False


@pytest.mark.asyncio
async def test_search_skips_intent_and_uses_raw_query_when_disabled(monkeypatch):
    fs = _make_viking_fs(enable_intent=False)
    captured = {}

    class ForbiddenIntentAnalyzer:
        def __init__(self, *args, **kwargs):
            raise AssertionError("intent analysis must not run when disabled")

    class FakeRetriever:
        def __init__(self, storage, embedder, rerank_config):
            pass

        async def retrieve(self, typed_query, **kwargs):
            captured["typed_query"] = typed_query
            return QueryResult(
                query=typed_query,
                matched_contexts=[],
                searched_directories=typed_query.target_directories,
            )

    monkeypatch.setattr(
        "openviking.retrieve.intent_analyzer.IntentAnalyzer",
        ForbiddenIntentAnalyzer,
    )
    monkeypatch.setattr(
        "openviking.retrieve.hierarchical_retriever.HierarchicalRetriever",
        FakeRetriever,
    )

    result = await fs.search(
        "raw query",
        target_uri="viking://resources/docs",
        session_info={
            "latest_archive_overview": "previous summary",
            "current_messages": [{"role": "user", "content": "previous turn"}],
        },
        ctx=_ctx(),
    )

    assert result.query_plan is None
    assert captured["typed_query"].query == "raw query"
    assert captured["typed_query"].intent == ""
    assert captured["typed_query"].target_directories == ["viking://resources/docs"]


def test_search_service_is_intent_enabled_follows_config():
    from openviking.service.search_service import SearchService

    svc = SearchService(_make_viking_fs(enable_intent=False))
    assert svc.is_intent_enabled() is False

    svc.set_viking_fs(_make_viking_fs(enable_intent=True))
    assert svc.is_intent_enabled() is True

    empty = SearchService()
    assert empty.is_intent_enabled() is True


@pytest.mark.asyncio
async def test_search_service_skips_session_context_when_intent_disabled():
    from openviking.service.search_service import SearchService

    fs = _make_viking_fs(enable_intent=False)
    fs.search = AsyncMock(return_value=MagicMock(name="find_result", query_plan=None, total=0))
    session = MagicMock()
    session.get_context_for_search = AsyncMock(
        side_effect=AssertionError("must not scan session when intent disabled")
    )

    svc = SearchService(fs)
    await svc.search(query="hello", ctx=_ctx(), session=session, target_uri="")

    session.get_context_for_search.assert_not_awaited()
    assert fs.search.await_args.kwargs.get("session_info") is None


@pytest.mark.asyncio
async def test_search_service_loads_session_context_when_intent_enabled():
    from openviking.service.search_service import SearchService

    fs = _make_viking_fs(enable_intent=True)
    fs.search = AsyncMock(return_value=MagicMock(name="find_result", query_plan=None, total=0))
    session_info = {"latest_archive_overview": "ov", "current_messages": []}
    session = MagicMock()
    session.get_context_for_search = AsyncMock(return_value=session_info)

    svc = SearchService(fs)
    await svc.search(query="hello", ctx=_ctx(), session=session, target_uri="")

    session.get_context_for_search.assert_awaited_once()
    assert fs.search.await_args.kwargs.get("session_info") is session_info


@pytest.mark.asyncio
@pytest.mark.parametrize(
    ("scope", "planned", "expected"),
    [
        ("memory", "resource", "memory"),
        (["memory"], "skill", "memory"),
        ("resource", "memory", "resource"),
        (["memory", "resource"], "memory", "memory"),
        (["memory", "resource"], "skill", None),
        (None, "skill", "skill"),
    ],
)
async def test_session_search_plan_respects_explicit_context_scope(
    monkeypatch, scope, planned, expected
):
    # #5544: planner classification must not contradict the caller's REST scope.
    from starlette.requests import Request

    from openviking.server.routers import search as search_router
    from openviking.service.search_service import SearchService

    fs = _make_viking_fs(enable_intent=True)
    planner = SimpleNamespace(
        get_completion_async=AsyncMock(
            return_value=json.dumps(
                {"queries": [{"query": "known record", "context_type": planned}]}
            )
        )
    )
    fs._vlm_resolver = SimpleNamespace(get_query_planner=AsyncMock(return_value=planner))
    session = SimpleNamespace(
        load=AsyncMock(),
        get_context_for_search=AsyncMock(
            return_value={"latest_archive_overview": "previous discussion"}
        ),
    )
    service = SimpleNamespace(
        search=SearchService(fs),
        sessions=SimpleNamespace(session=lambda *args: session),
    )

    class FakeRetriever:
        def __init__(self, **kwargs):
            pass

        async def retrieve(self, typed_query, **kwargs):
            return QueryResult(query=typed_query, matched_contexts=[], searched_directories=[])

    monkeypatch.setattr(search_router, "get_service", lambda: service)
    monkeypatch.setattr(
        "openviking.retrieve.hierarchical_retriever.HierarchicalRetriever", FakeRetriever
    )
    response = await search_router.search(
        search_router.SearchRequest(query="known record", session_id="fixture", context_type=scope),
        Request({"type": "http"}),
        _ctx(),
    )

    assert response["status"] == "ok"
    assert response["result"]["query_plan"]["queries"][0]["context_type"] == expected


@pytest.mark.asyncio
@pytest.mark.parametrize("failure", ["timeout", "provider"])
async def test_session_search_falls_back_when_intent_planning_fails(monkeypatch, failure):
    from starlette.requests import Request

    from openviking.server.routers import search as search_router
    from openviking.service.search_service import SearchService

    fs = _make_viking_fs(enable_intent=True)
    fs.retrieval_config = RetrievalConfig(recall_intent_timeout_s=0.02)

    async def failed_completion(prompt):
        if failure == "timeout":
            await asyncio.Event().wait()
        raise RuntimeError("provider overloaded")

    planner = SimpleNamespace(get_completion_async=failed_completion)
    fs._vlm_resolver = SimpleNamespace(get_query_planner=AsyncMock(return_value=planner))
    session = SimpleNamespace(
        load=AsyncMock(),
        get_context_for_search=AsyncMock(
            return_value={"latest_archive_overview": "previous discussion"}
        ),
    )
    service = SimpleNamespace(
        search=SearchService(fs),
        sessions=SimpleNamespace(session=lambda *args: session),
    )
    match = MatchedContext(
        uri="viking://resources/docs/answer.md", context_type=ContextType.RESOURCE
    )

    async def retrieve(typed_query, **kwargs):
        assert typed_query.query == "raw query"
        assert typed_query.target_directories == ["viking://resources/docs"]
        return QueryResult(
            query=typed_query,
            matched_contexts=[match],
            searched_directories=typed_query.target_directories,
        )

    monkeypatch.setattr(search_router, "get_service", lambda: service)
    monkeypatch.setattr(
        "openviking.retrieve.hierarchical_retriever.HierarchicalRetriever",
        lambda **kwargs: SimpleNamespace(retrieve=retrieve),
    )
    response = await asyncio.wait_for(
        search_router.search(
            search_router.SearchRequest(
                query="raw query", session_id="fixture", target_uri="viking://resources/docs"
            ),
            Request({"type": "http"}),
            _ctx(),
        ),
        timeout=1.0,
    )

    assert response["status"] == "ok"
    assert response["result"]["resources"][0]["uri"] == match.uri
    assert "query_plan" not in response["result"]