DeepTutor: Lifelong Personalized Tutoring. https://deeptutor.info/.
Python ai-agentsai-tutorclawbotcli-tooldeepresearchinteractive-learninglearningmulti-agent-systemsrag
"""Resource selections preserve old access and narrow every runtime entry point."""
from pathlib import Path
from fastapi import HTTPException
import pytest
from deeptutor.core.errors import AccessError
from deeptutor.multi_user.knowledge_access import (
current_kb_manager,
list_visible_knowledge_bases,
resolve_kb,
)
from deeptutor.services.skill.runtime import runtime_skills, skill_manifest
from deeptutor.services.skill.service import get_skill_service
from deeptutor.services.workspace import ContentWorkspaceService, WorkspaceError
from deeptutor.services.workspace.context import workspace_context
from deeptutor.services.workspace.knowledge import (
knowledge_catalog,
library_request,
qualified_kb_id,
)
from deeptutor.services.workspace.resources import current_resources, resource_catalog
from deeptutor.tools.builtin import ReadSkillTool
def write_skill(root, name, text, *, always=False):
folder = root / name
folder.mkdir(parents=True, exist_ok=True)
(folder / "SKILL.md").write_text(
f"---\ndescription: {text}\nalways: {str(always).lower()}\n---\n{text}"
)
@pytest.mark.asyncio
async def test_legacy_and_selected_skills_and_local_shadow(as_user):
with as_user("alice"):
write_skill(get_skill_service().root, "research", "account version", always=True)
write_skill(get_skill_service().root, "other", "other version")
service = ContentWorkspaceService()
row = service.create_workspace("Research")
with workspace_context(row["workspace_id"]):
assert current_resources().skills is None
assert "account version" in skill_manifest()
write_skill(Path(row["path"]) / "skills", "research", "workspace version", always=True)
service.update_workspace(row["workspace_id"], resources={"skills": ["research"]})
with workspace_context(row["workspace_id"]):
assert set(runtime_skills()) == {"research"}
assert "workspace version" in skill_manifest()
assert "account version" not in skill_manifest()
assert not (await ReadSkillTool().execute(name="other")).success
assert "workspace version" in (await ReadSkillTool().execute(name="research")).content
service.update_workspace(row["workspace_id"], resources={"skills": []})
with workspace_context(row["workspace_id"]):
assert skill_manifest() == ""
assert not (await ReadSkillTool().execute(name="research")).success
with workspace_context():
assert "account version" in skill_manifest()
def test_knowledge_origins_selection_and_grants(as_user):
with as_user("alice"):
current_kb_manager().register_connected_entry(
"same", {"type": "obsidian", "vault_path": "/unused"}
)
service = ContentWorkspaceService()
a = service.create_workspace("A")
b = service.create_workspace("B")
with workspace_context(a["workspace_id"]):
current_kb_manager().register_connected_entry(
"same", {"type": "obsidian", "vault_path": "/unused-a"}
)
legacy_root = resolve_kb("same").base_dir
global_id = qualified_kb_id("same")
local_id = qualified_kb_id("same", a["workspace_id"])
assert {global_id, local_id} <= {r["id"] for r in knowledge_catalog()}
service.update_workspace(b["workspace_id"], resources={"knowledge_bases": [local_id]})
with workspace_context(b["workspace_id"]):
assert [r["id"] for r in list_visible_knowledge_bases()] == [local_id]
assert resolve_kb("same").base_dir == legacy_root
assert resolve_kb(local_id).base_dir == legacy_root
with pytest.raises(AccessError, match="not assigned"):
resolve_kb(global_id)
with pytest.raises(AccessError):
resolve_kb("admin:kb:same")
service.update_workspace(
b["workspace_id"], resources={"knowledge_bases": [global_id, local_id]}
)
with workspace_context(b["workspace_id"]):
with pytest.raises(AccessError):
resolve_kb("same")
assert resolve_kb(global_id).base_dir != resolve_kb(local_id).base_dir
service.update_workspace(b["workspace_id"], resources={"knowledge_bases": []})
with workspace_context(b["workspace_id"]):
assert list_visible_knowledge_bases() == []
with pytest.raises(AccessError):
resolve_kb(local_id)
token = library_request.set(True)
try:
assert len(list_visible_knowledge_bases()) == 2
assert resolve_kb(local_id).base_dir == legacy_root
finally:
library_request.reset(token)
with as_user("bob"):
with pytest.raises(AccessError):
resolve_kb(local_id)
with pytest.raises(WorkspaceError):
ContentWorkspaceService().create_workspace(
"Theft", resources={"knowledge_bases": [local_id]}
)
def test_inherited_workspace_keeps_account_subagents_without_sharing_kbs(as_user):
with as_user("alice"):
account_manager = current_kb_manager()
account_manager.register_connected_entry(
"notes", {"type": "obsidian", "vault_path": "/unused"}
)
account_manager.register_subagent_connection("my-agent", "codex")
workspace = ContentWorkspaceService().create_workspace("Research")
with workspace_context(workspace["workspace_id"]):
assert [item["id"] for item in list_visible_knowledge_bases()] == [
"account:kb:my-agent"
]
assert resolve_kb("account:kb:my-agent").name == "my-agent"
ContentWorkspaceService().update_workspace(
workspace["workspace_id"], resources={"knowledge_bases": []}
)
with workspace_context(workspace["workspace_id"]):
assert list_visible_knowledge_bases() == []
with pytest.raises(AccessError):
resolve_kb("account:kb:my-agent")
def test_explicit_learning_sources_allow_reads_without_changing_workspace_or_write_access(as_user):
from deeptutor.services.workspace.context import current_workspace_id
from deeptutor.services.workspace.knowledge import learning_source_access
with as_user("alice"):
current_kb_manager().register_connected_entry(
"notes", {"type": "obsidian", "vault_path": "/unused"}
)
source = qualified_kb_id("notes")
service = ContentWorkspaceService()
target = service.create_workspace("New books", resources={"knowledge_bases": []})[
"workspace_id"
]
with workspace_context(target):
with pytest.raises(AccessError):
resolve_kb(source)
with learning_source_access([source]):
assert resolve_kb(source).name == "notes"
assert current_workspace_id() == target
with pytest.raises(AccessError):
resolve_kb(source, require_write=True)
with pytest.raises(AccessError):
resolve_kb(source)
with as_user("bob"), learning_source_access([f"workspace:{target}:kb:notes"]):
with pytest.raises(AccessError):
resolve_kb(f"workspace:{target}:kb:notes")
def test_selection_persistence_missing_and_default(as_user):
with as_user("alice"):
service = ContentWorkspaceService()
write_skill(get_skill_service().root, "one", "one")
row = service.create_workspace("A", resources={"skills": ["one"], "mcp": []})
service.update_workspace(row["workspace_id"], name="Renamed")
with workspace_context(row["workspace_id"]):
assert current_resources().skills == ["one"]
assert current_resources().mcp == []
get_skill_service().delete("one")
service.update_workspace(row["workspace_id"], resources=row["resources"])
with workspace_context(row["workspace_id"]):
assert runtime_skills() == {}
with pytest.raises(WorkspaceError):
service.create_workspace("Invalid", resources={"skills": ["unknown"]})
general = service.general_binding()
service.update_workspace(general.workspace_id, resources={"skills": []})
with workspace_context():
assert skill_manifest() == ""
assert isinstance(resource_catalog()["mcp"], list)
@pytest.mark.asyncio
async def test_resource_api_roundtrip(as_user):
from deeptutor.api.routers.workspace import (
CreateWorkspacePayload,
UpdateWorkspacePayload,
create_workspace,
update_registered_workspace,
workspace_resource_catalog,
)
with as_user("alice"):
result = await create_workspace(
CreateWorkspacePayload(
name="Selected", resources={"skills": [], "mcp": [], "knowledge_bases": []}
)
)
assert result["workspace"]["resources"] == {"skills": [], "mcp": [], "knowledge_bases": []}
changed = await update_registered_workspace(
result["workspace"]["workspace_id"], UpdateWorkspacePayload(resources={"skills": None})
)
assert changed["workspace"]["resources"]["skills"] is None
assert set(await workspace_resource_catalog()) == {"skills", "mcp", "knowledge_bases"}
def test_migration_reports_workspaces_that_reference_the_source(as_user):
from deeptutor.services.workspace.resources import knowledge_migration_blockers, resource_usage
with as_user("alice"):
current_kb_manager().register_connected_entry(
"math", {"type": "obsidian", "vault_path": "/unused"}
)
service = ContentWorkspaceService()
row = service.create_workspace(
"Consumer", resources={"knowledge_bases": ["account:kb:math"]}
)
assert "Consumer" in knowledge_migration_blockers("")[0]
assert row["workspace_id"] in {
r["workspace_id"] for r in resource_usage("knowledge_bases", "account:kb:math")
}
service.update_workspace(row["workspace_id"], resources={"knowledge_bases": []})
assert knowledge_migration_blockers("") == []
@pytest.mark.asyncio
async def test_delete_kb_file_in_workspace(as_user):
from deeptutor.api.routers.knowledge import delete_kb_file
from deeptutor.services.workspace import ContentWorkspaceService
from deeptutor.services.workspace.context import workspace_context
with as_user("alice"):
service = ContentWorkspaceService()
ws = service.create_workspace("Chemistry")
ws_id = ws["workspace_id"]
kb_name = "初中化学"
with workspace_context(ws_id):
mgr = current_kb_manager()
kb_dir = mgr.base_dir / kb_name
kb_dir.mkdir(parents=True, exist_ok=True)
mgr.config.setdefault("knowledge_bases", {})[kb_name] = {
"rag_provider": "llamaindex",
"status": "ready",
}
mgr._save_config()
raw_dir = kb_dir / "raw"
raw_dir.mkdir(parents=True, exist_ok=True)
doc_file = raw_dir / "chapter1.pdf"
doc_file.write_text("chemical equations")
assert doc_file.exists()
qualified_ref = f"workspace:{ws_id}:kb:{kb_name}"
result = await delete_kb_file(qualified_ref, "chapter1.pdf")
assert result["status"] == "ok"
assert not doc_file.exists()