Enterprise agent platform for building, deploying, and operating AI teammates.
from __future__ import annotations
import asyncio
import threading
from collections.abc import Iterator
import pytest
from xagent.core.memory import MemoryAccessScope
from xagent.core.memory.core import MemoryNote
from xagent.core.memory.in_memory import InMemoryMemoryStore
from xagent.web.services.memory_binding import (
MemoryBindingResolutionError,
MemoryManagementBindingRequest,
MemoryStoreBinding,
MemoryTaskBindingRequest,
MemoryToolAssemblyRequest,
resolve_trusted_memory_binding,
resolve_trusted_memory_binding_async,
set_trusted_memory_binding_resolver,
)
from xagent.web.user_isolated_memory import UserIsolatedMemoryStore
@pytest.fixture(autouse=True)
def clear_memory_binding_resolver() -> Iterator[None]:
set_trusted_memory_binding_resolver(None)
yield
set_trusted_memory_binding_resolver(None)
def _task_request() -> MemoryTaskBindingRequest:
return MemoryTaskBindingRequest(
task_id=17,
user_id=23,
agent_id=None,
source="trusted-ingress",
is_preview=False,
)
def _binding(
store: InMemoryMemoryStore | UserIsolatedMemoryStore | None = None,
*,
identity: str = "backend-a",
generation: str = "route-1",
) -> MemoryStoreBinding:
return MemoryStoreBinding(
store=store or InMemoryMemoryStore(),
backend_identity=identity,
route_generation=generation,
)
@pytest.mark.parametrize(
("request_type", "kwargs"),
[
(MemoryManagementBindingRequest, {"authenticated_user_id": True}),
(MemoryManagementBindingRequest, {"authenticated_user_id": 0}),
(
MemoryTaskBindingRequest,
{
"task_id": "17",
"user_id": 23,
"agent_id": None,
"source": None,
"is_preview": False,
},
),
(
MemoryTaskBindingRequest,
{
"task_id": 17,
"user_id": 23,
"agent_id": None,
"source": None,
"is_preview": 0,
},
),
],
)
def test_binding_requests_fail_closed_on_invalid_trusted_identity(
request_type: type[object], kwargs: dict[str, object]
) -> None:
with pytest.raises((TypeError, ValueError)):
request_type(**kwargs) # type: ignore[call-arg]
def test_unregistered_resolver_preserves_legacy_selection() -> None:
assert resolve_trusted_memory_binding(_task_request()) is None
@pytest.mark.asyncio
async def test_async_resolution_runs_sync_callback_off_event_loop() -> None:
event_loop_thread = threading.get_ident()
resolver_thread: int | None = None
def resolver(request: object) -> MemoryStoreBinding:
nonlocal resolver_thread
assert isinstance(request, MemoryManagementBindingRequest)
resolver_thread = threading.get_ident()
return _binding()
set_trusted_memory_binding_resolver(resolver)
result = await resolve_trusted_memory_binding_async(
MemoryManagementBindingRequest(authenticated_user_id=23)
)
assert isinstance(result, MemoryStoreBinding)
assert resolver_thread is not None
assert resolver_thread != event_loop_thread
def test_each_request_resolves_an_immutable_binding_snapshot() -> None:
calls = 0
def resolver(request: object) -> MemoryStoreBinding:
nonlocal calls
assert isinstance(request, MemoryTaskBindingRequest)
calls += 1
return _binding(generation=f"route-{calls}")
set_trusted_memory_binding_resolver(resolver)
first = resolve_trusted_memory_binding(_task_request())
second = resolve_trusted_memory_binding(_task_request())
assert first is not None and second is not None
assert first is not second
assert first.route_generation == "route-1"
assert second.route_generation == "route-2"
with pytest.raises(AttributeError):
first.route_generation = "forged" # type: ignore[misc]
@pytest.mark.parametrize(
"resolver",
[
lambda _request: None,
lambda _request: object(),
lambda _request: (_ for _ in ()).throw(RuntimeError("boom")),
],
)
def test_registered_resolver_failure_cannot_fall_back_to_global_store(
resolver: object,
) -> None:
set_trusted_memory_binding_resolver(resolver) # type: ignore[arg-type]
with pytest.raises(MemoryBindingResolutionError, match="resolution failed"):
resolve_trusted_memory_binding(_task_request())
def test_resolver_failure_log_omits_exception_message_and_body(
caplog: pytest.LogCaptureFixture,
) -> None:
credential_marker = "SYNTHETIC_CREDENTIAL_MARKER"
body_marker = "SYNTHETIC_PRIVATE_NOTE_BODY"
def resolver(_request: object) -> MemoryStoreBinding:
raise RuntimeError(f"{credential_marker}:{body_marker}")
set_trusted_memory_binding_resolver(resolver)
with caplog.at_level("WARNING"), pytest.raises(MemoryBindingResolutionError):
resolve_trusted_memory_binding(_task_request())
assert "RuntimeError" in caplog.text
assert "test_memory_binding.py:resolver:" in caplog.text
assert credential_marker not in caplog.text
assert body_marker not in caplog.text
@pytest.mark.asyncio
async def test_async_resolution_drains_worker_before_propagating_cancellation() -> None:
started = threading.Event()
release = threading.Event()
finished = threading.Event()
def resolver(_request: object) -> MemoryStoreBinding:
started.set()
assert release.wait(timeout=5)
finished.set()
return _binding()
set_trusted_memory_binding_resolver(resolver)
resolution = asyncio.create_task(
resolve_trusted_memory_binding_async(
MemoryManagementBindingRequest(authenticated_user_id=23)
)
)
assert await asyncio.to_thread(started.wait, 5)
resolution.cancel()
await asyncio.sleep(0)
assert not resolution.done()
release.set()
with pytest.raises(asyncio.CancelledError):
await resolution
assert finished.is_set()
@pytest.mark.parametrize(
("identity", "generation"),
[("", "route-1"), ("backend-a", ""), (1, "route-1")],
)
def test_binding_requires_opaque_nonempty_cache_fences(
identity: object, generation: object
) -> None:
with pytest.raises(TypeError):
MemoryStoreBinding(
store=InMemoryMemoryStore(),
backend_identity=identity, # type: ignore[arg-type]
route_generation=generation, # type: ignore[arg-type]
)
def test_binding_copies_public_diagnostics_and_rejects_non_public_values() -> None:
diagnostics = {"backend": "host-managed", "available": True}
binding = MemoryStoreBinding(
store=InMemoryMemoryStore(),
backend_identity="backend-a",
route_generation="route-1",
public_diagnostics=diagnostics,
)
diagnostics["backend"] = "mutated"
assert dict(binding.public_diagnostics) == {
"backend": "host-managed",
"available": True,
}
with pytest.raises(TypeError):
binding.public_diagnostics["backend"] = "forged" # type: ignore[index]
with pytest.raises(TypeError, match="scalar JSON"):
MemoryStoreBinding(
store=InMemoryMemoryStore(),
backend_identity="backend-a",
route_generation="route-1",
public_diagnostics={"nested": {"secret": "not-public-contract"}},
)
def test_binding_applies_scope_before_snapshot_escapes() -> None:
base = InMemoryMemoryStore()
unbound = UserIsolatedMemoryStore(base)
binding = MemoryStoreBinding(
store=unbound,
backend_identity="backend-a",
route_generation="route-1",
access_scope=MemoryAccessScope(
owner_user_id=700,
memory_dimensions={},
strict_owner_only=True,
),
)
note = MemoryNote(content="owner-only note")
assert binding.store is not unbound
assert binding.store.add(note).success
stored = base.get(note.id).content
assert isinstance(stored, MemoryNote)
assert stored.metadata == {"user_id": 700}
def test_binding_scope_failure_is_a_resolver_failure() -> None:
def resolver(_request: object) -> MemoryStoreBinding:
return MemoryStoreBinding(
store=InMemoryMemoryStore(),
backend_identity="backend-a",
route_generation="route-1",
access_scope=MemoryAccessScope(
owner_user_id=700,
memory_dimensions={"principal": "person-1"},
),
)
set_trusted_memory_binding_resolver(resolver)
with pytest.raises(MemoryBindingResolutionError):
resolve_trusted_memory_binding(_task_request())
def test_host_tool_factory_is_snapshot_local_and_opt_in() -> None:
marker = object()
def factory(request: MemoryToolAssemblyRequest) -> list[object]:
assert request.task == "remember safely"
return [marker]
binding = MemoryStoreBinding(
store=InMemoryMemoryStore(),
backend_identity="backend-a",
route_generation="route-1",
memory_tools_factory=factory,
)
request = MemoryToolAssemblyRequest(
memory_store=binding.store,
task="remember safely",
)
assert binding.memory_tools_factory is not None
assert list(binding.memory_tools_factory(request)) == [marker]
assert _binding().memory_tools_factory is None
def test_sync_resolver_does_not_accept_awaitable_result() -> None:
async def async_resolver(_request: object) -> MemoryStoreBinding:
await asyncio.sleep(0)
return _binding()
set_trusted_memory_binding_resolver(async_resolver) # type: ignore[arg-type]
with pytest.raises(MemoryBindingResolutionError):
resolve_trusted_memory_binding(_task_request())