Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
# SPDX-License-Identifier: AGPL-3.0
"""MCP wire-result tests for tool execution failures."""
from types import SimpleNamespace
from unittest.mock import AsyncMock
import pytest
from mcp.types import CallToolRequest, CallToolRequestParams
import openviking.server.mcp_endpoint as mcp_endpoint
from openviking.server.identity import RequestContext, Role
from openviking_cli.exceptions import InvalidArgumentError, PermissionDeniedError
from openviking_cli.session.user_id import UserIdentifier
@pytest.fixture(autouse=True)
def _set_mcp_identity():
context = RequestContext(
user=UserIdentifier.the_default_user("mcp-error-test"),
role=Role.ROOT,
)
token = mcp_endpoint._mcp_ctx.set(context)
yield
mcp_endpoint._mcp_ctx.reset(token)
async def _call_tool(name: str, arguments: dict) -> dict:
handler = mcp_endpoint.mcp._mcp_server.request_handlers[CallToolRequest]
request = CallToolRequest(
params=CallToolRequestParams(name=name, arguments=arguments),
)
return (await handler(request)).root.model_dump(by_alias=True, exclude_none=True)
async def test_whole_call_failure_sets_error_result(monkeypatch):
uri = "viking://resources/a.md"
service = SimpleNamespace(
fs=SimpleNamespace(
write=AsyncMock(
side_effect=PermissionDeniedError("write permission required", resource=uri)
)
)
)
monkeypatch.setattr(mcp_endpoint, "get_service", lambda: service)
result = await _call_tool("write", {"uri": uri, "content": "denied"})
assert result["isError"] is True
assert result["content"] == [
{"type": "text", "text": "PERMISSION_DENIED: write permission required"}
]
assert result["structuredContent"]["error"] == {
"code": "PERMISSION_DENIED",
"message": "write permission required",
"details": {"resource": uri},
}
async def test_remote_resource_business_failure_sets_error_result(monkeypatch):
service = SimpleNamespace(
resources=SimpleNamespace(
add_resource=AsyncMock(
return_value={"status": "error", "message": "processor rejected"}
)
)
)
monkeypatch.setattr(mcp_endpoint, "get_service", lambda: service)
arguments = {"path": "https://example.com/article"}
direct_result = await mcp_endpoint.add_resource(**arguments)
result = await _call_tool("add_resource", arguments)
assert direct_result == "Error adding resource: processor rejected"
assert type(direct_result) is str
assert result["isError"] is True
assert result["content"] == [{"type": "text", "text": direct_result}]
async def test_skill_install_business_failure_sets_error_result(monkeypatch):
monkeypatch.setattr(
mcp_endpoint,
"install_skills",
AsyncMock(return_value={"status": "error", "message": "invalid skill"}),
)
arguments = {"data": "---\nname: example\ndescription: Example\n---\nBody"}
direct_result = await mcp_endpoint.add_skill(**arguments)
result = await _call_tool("add_skill", arguments)
assert direct_result == "Error adding skill: invalid skill"
assert type(direct_result) is str
assert result["isError"] is True
assert result["content"] == [{"type": "text", "text": direct_result}]
async def test_grep_partial_failure_without_matches_stays_partial(monkeypatch):
async def grep(_uri, pattern, **_kwargs):
if pattern == "bad":
raise RuntimeError("storage offline")
return {"matches": []}
monkeypatch.setattr(
mcp_endpoint,
"get_service",
lambda: SimpleNamespace(fs=SimpleNamespace(grep=grep)),
)
arguments = {"uri": "viking://resources", "pattern": ["good", "bad"]}
direct_result = await mcp_endpoint.grep(**arguments)
result = await _call_tool("grep", arguments)
assert direct_result == (
"No matches found for successful pattern(s): good\n"
"Patterns that could not be searched:\n bad: RuntimeError: storage offline"
)
assert result["isError"] is False
assert result["content"] == [{"type": "text", "text": direct_result}]
async def test_read_all_failures_set_error_result(monkeypatch):
read_visible = AsyncMock(side_effect=PermissionDeniedError("read permission required"))
monkeypatch.setattr(
mcp_endpoint,
"get_service",
lambda: SimpleNamespace(fs=SimpleNamespace(read_visible=read_visible)),
)
arguments = {
"uris": ["viking://resources/a.md", "viking://resources/b.md"],
}
direct_result = await mcp_endpoint.read(**arguments)
result = await _call_tool(
"read",
arguments,
)
assert type(direct_result) is str
assert direct_result == (
"=== viking://resources/a.md ===\nPERMISSION_DENIED: read permission required\n\n"
"=== viking://resources/b.md ===\nPERMISSION_DENIED: read permission required"
)
assert result["isError"] is True
assert "PERMISSION_DENIED: read permission required" in result["content"][0]["text"]
assert "structuredContent" not in result
async def test_read_partial_failure_remains_a_success_result(monkeypatch):
async def read_visible(uri, **kwargs):
if uri.endswith("bad.md"):
raise InvalidArgumentError("not readable")
return "visible content"
monkeypatch.setattr(
mcp_endpoint,
"get_service",
lambda: SimpleNamespace(fs=SimpleNamespace(read_visible=read_visible)),
)
arguments = {
"uris": [
"viking://resources/good.md",
"viking://resources/bad.md",
]
}
direct_result = await mcp_endpoint.read(**arguments)
result = await _call_tool(
"read",
arguments,
)
assert type(direct_result) is str
assert "visible content" in direct_result
assert "not readable" in direct_result
assert result["isError"] is False
assert "visible content" in result["content"][0]["text"]
assert "not readable" in result["content"][0]["text"]
async def test_health_unavailable_remains_diagnostic_data(monkeypatch):
def unavailable():
raise RuntimeError("not initialized")
monkeypatch.setattr(mcp_endpoint, "get_service", unavailable)
result = await _call_tool("health", {})
assert result["isError"] is False
assert result["content"] == [
{"type": "text", "text": "OpenViking is unhealthy: not initialized"}
]