Skip to content

Enterprise agent platform for building, deploying, and operating AI teammates.

7.7 KB
Raw Blame
from dataclasses import fields
from typing import Callable

import pytest

from xagent import skills
from xagent.skills.library import (
    CompositeSkillLibraryProvider,
    FilesystemSkillLibraryProvider,
    SkillRecord,
    SkillScopeContext,
    SkillWriteContext,
)
from xagent.skills.manager import SkillManager


def test_skill_scope_context_contains_only_detached_runtime_identity() -> None:
    context = SkillScopeContext(user_id=7, metadata={"team_id": 11})

    assert {field.name for field in fields(context)} == {"user_id", "metadata"}
    assert context.user_id == 7
    assert context.metadata == {"team_id": 11}


def test_skill_scope_context_rejects_request_owned_metadata() -> None:
    with pytest.raises(TypeError, match="detached scalar"):
        SkillScopeContext(user_id=7, metadata={"db": object()})


@pytest.mark.parametrize("context_type", [SkillScopeContext, SkillWriteContext])
def test_detached_contexts_reject_scalar_subclasses_with_attached_resources(
    context_type: Callable[..., object],
) -> None:
    class _AttachedStr(str):
        pass

    class _AttachedInt(int):
        pass

    attached_key = _AttachedStr("team_id")
    attached_key.request = object()
    attached_value = _AttachedInt(11)
    attached_value.session = object()

    with pytest.raises(TypeError, match="detached scalar"):
        context_type(user_id=7, metadata={attached_key: 11})
    with pytest.raises(TypeError, match="detached scalar"):
        context_type(user_id=7, metadata={"team_id": attached_value})


@pytest.mark.parametrize("context_type", [SkillScopeContext, SkillWriteContext])
@pytest.mark.parametrize("user_id", [True, object()])
def test_detached_contexts_reject_non_exact_integer_user_ids(
    context_type: Callable[..., object], user_id: object
) -> None:
    class _AttachedInt(int):
        pass

    subclass_user_id = _AttachedInt(7)
    subclass_user_id.request = object()

    with pytest.raises(TypeError, match="user_id"):
        context_type(user_id=user_id)
    with pytest.raises(TypeError, match="user_id"):
        context_type(user_id=subclass_user_id)


def test_skill_scope_context_copies_and_freezes_metadata() -> None:
    metadata = {"team_id": 11}
    context = SkillScopeContext(user_id=7, metadata=metadata)

    metadata["team_id"] = 12

    assert context.metadata == {"team_id": 11}
    with pytest.raises(TypeError):
        context.metadata["team_id"] = 12  # type: ignore[index]


def test_skill_write_context_contains_only_detached_identity() -> None:
    metadata = {"source_id": 11}

    context = SkillWriteContext(user_id=7, metadata=metadata)

    assert {field.name for field in fields(context)} == {"user_id", "metadata"}
    assert context.user_id == 7
    assert context.metadata == {"source_id": 11}
    metadata["source_id"] = 12
    assert context.metadata == {"source_id": 11}
    with pytest.raises(TypeError):
        context.metadata["source_id"] = 13  # type: ignore[index]


def test_skill_provider_failure_contract_is_exported() -> None:
    from xagent.skills.library import (
        SkillWriteProviderError,
        SkillWriteProviderErrorReason,
    )

    error = SkillWriteProviderError(
        SkillWriteProviderErrorReason.FORBIDDEN,
        "You cannot write this skill.",
    )

    assert error.reason is SkillWriteProviderErrorReason.FORBIDDEN
    assert error.public_detail == "You cannot write this skill."
    assert skills.SkillWriteProviderError is SkillWriteProviderError
    assert skills.SkillWriteProviderErrorReason is SkillWriteProviderErrorReason
    assert hasattr(skills, "SkillWriteProvider")
    assert hasattr(skills, "get_skill_write_provider")
    assert hasattr(skills, "set_skill_write_provider")


class StaticProvider:
    def __init__(self, source: str, records: list[SkillRecord]):
        self.source = source
        self.records = records

    async def list_records(self, context: SkillScopeContext) -> list[SkillRecord]:
        return self.records

    async def read_file(
        self, context: SkillScopeContext, record: SkillRecord, path: str
    ) -> bytes:
        return record.files[path]


def _record(name: str, source: str, description: str) -> SkillRecord:
    return SkillRecord(
        name=name,
        source=source,
        scope=source,
        files={
            "SKILL.md": (
                f"---\ndescription: {description!r}\n"
                f"when_to_use: Use {source}.\n---\n# {name}\n"
            ).encode()
        },
    )


@pytest.mark.asyncio
async def test_composite_provider_later_records_override_earlier_by_name():
    provider = CompositeSkillLibraryProvider(
        [
            StaticProvider("builtin", [_record("writer", "builtin", "builtin")]),
            StaticProvider("team", [_record("writer", "team", "team")]),
            StaticProvider("personal", [_record("writer", "personal", "personal")]),
        ]
    )

    manager = SkillManager(provider=provider, context=SkillScopeContext(user_id=7))
    await manager.initialize()

    skill = await manager.get_skill("writer")

    assert skill is not None
    assert skill["description"] == "personal"
    assert skill["source"] == "personal"
    assert skill["scope"] == "personal"


@pytest.mark.asyncio
async def test_composite_records_survive_unavailable_personal_database(
    monkeypatch: pytest.MonkeyPatch, tmp_path
) -> None:
    from xagent.skills.personal_db import XagentPersonalDbSkillProvider
    from xagent.web.models import database

    filesystem_skill = tmp_path / "filesystem-writer"
    filesystem_skill.mkdir()
    (filesystem_skill / "SKILL.md").write_bytes(
        b"---\ndescription: filesystem\n---\n# Filesystem writer\n"
    )

    monkeypatch.setattr(database, "_SessionLocal", None)
    provider = CompositeSkillLibraryProvider(
        [
            FilesystemSkillLibraryProvider([tmp_path]),
            StaticProvider(
                "overlay", [_record("overlay-writer", "overlay", "overlay")]
            ),
            XagentPersonalDbSkillProvider(),
        ]
    )

    records = await provider.list_records(SkillScopeContext(user_id=7))

    assert [record.name for record in records] == [
        "filesystem-writer",
        "overlay-writer",
    ]


@pytest.mark.asyncio
async def test_composite_propagates_personal_database_failure_without_partial_records(
    monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
) -> None:
    from xagent.skills.personal_db import XagentPersonalDbSkillProvider
    from xagent.web.models import database

    error = RuntimeError("Session Local is not initialized. Call init_db() first.")

    def _failing_session_factory():
        raise error

    monkeypatch.setattr(
        database,
        "_SessionLocal",
        _failing_session_factory,
    )
    provider = CompositeSkillLibraryProvider(
        [
            StaticProvider("builtin", [_record("writer", "builtin", "builtin")]),
            XagentPersonalDbSkillProvider(),
        ]
    )

    with pytest.raises(RuntimeError) as caught:
        await provider.list_records(SkillScopeContext(user_id=7))

    assert caught.value is error
    assert (
        str(caught.value) == "Session Local is not initialized. Call init_db() first."
    )
    assert not any("unavailable" in record.message.lower() for record in caplog.records)


@pytest.mark.asyncio
async def test_composite_provider_can_return_visible_records_with_shadowed_state():
    provider = CompositeSkillLibraryProvider(
        [
            StaticProvider("team", [_record("writer", "team", "team")]),
            StaticProvider("personal", [_record("writer", "personal", "personal")]),
        ]
    )

    records = await provider.list_visible_records(SkillScopeContext(user_id=7))

    assert [(r.scope, r.name, r.effective, r.shadowed_by) for r in records] == [
        ("team", "writer", False, "personal"),
        ("personal", "writer", True, None),
    ]