Files
headroom/tests/test_memory/test_mcp_server.py
ee2252a315 feat(mcp)!: port MCP servers to SDK 2.x (#4603)
## Description

Supersedes #2658 (`tejas/mcp-2x-port`, a draft with conflicts against
`main` since 2026-10-20). This is that PR's net diff rebased onto `main`
as one commit (originally `fc1ba891`, now `7e0094d6`; see below),
crediting Tejas Chopra and Jerrett Davis as co-authors, with three
changes needed on current `main`. Both MCP servers
(`headroom/ccr/mcp_server.py`, `headroom/memory/mcp_server.py`) move
from SDK 1's decorator API to SDK 2's constructor callbacks, as #2658
did. The `<2.0.0` cap from #2642 is then lifted.

Why now: current Claude Code tries the modern `server/discover`
handshake first. On SDK 1, `headroom mcp serve` rejects it and logs
`Failed to validate request: 31 validation errors for ClientRequest` on
stderr in every session. Claude Code then falls back to legacy
`initialize`, so the tools still work. On SDK 2 the modern handshake
succeeds and nothing is logged.

Changes relative to #2658:

1. **The floor is `mcp>=2.2.0,<3.0.0`, not `>=2.0.0`.** The GitHub
advisories mark `mcp` `>=2.0.0, <2.2.0` as affected by CVE-2026-59951
(the reason for #4239's `>=1.30.0` floor), CVE-2026-116684,
CVE-2026-116685 and CVE-2026-116686. #2658's lock resolved 2.1.1. The
contract test keeps `main`'s CVE guard for the 2.x line and rejects 3.x
(see #2977).
2. **`tests/test_ccr_mcp_http.py` is ported.** #1773 added it after
#2658 branched, and it fails on SDK 2: `streamable_http_client` now
takes an `httpx2.AsyncClient`, yields `(read, write)` without the
session-id getter, and its types are snake_case (`protocol_version`).
`headroom/ccr/mcp_http.py` itself needs no change.
3. **The lock is regenerated** with uv 0.9.30 (`uv lock
--upgrade-package mcp`, still `revision = 3`).

**Rebased onto main (`7e0094d6`), 2026-11-03.** The branch is now two
linear commits, with no merge commits:

- `ce4d6442` feat(mcp)!: port MCP servers to SDK 2.x (was `39c574c2`)
- `274f0672` fix(mcp): attribute SDK 2 clients by client_info, not
clientInfo (was `c7900848`)

The previous head was the merge `4c1b774f` (main `5c785e69` into the
branch), which carried the resolution against #4525
(GHSA-8g49-pg6g-xgrf, confining `headroom_read` to the workspace). The
rebase replays the port directly on top of #4525 instead. What it
changed:

- `headroom/ccr/mcp_server.py` conflicted with #4525 in two places: the
imports (#4525's `errno` next to the port's `contextvars`) and the tool
list, where #4525's workspace-scoped `headroom_read` schema met the
port's move from the `@list_tools` decorator to `_on_list_tools`. The
resolved file keeps both: SDK 2 callbacks and #4525's confinement and
`HEADROOM_MCP_READ_ROOTS` description. It is byte-identical to the file
in the previous merge head `4c1b774f`.
- `uv.lock` conflicted in one hunk with #4614's `mem0ai` bump: kept this
PR's `mcp>=2.2.0,<3.0.0` for the `mcp` and `proxy` extras and #4614's
`mem0ai>=2.0.18,<3.0`. `uv lock --check` resolves 253 packages.
- Every other file this PR touches is unchanged from `4c1b774f`. The
only difference in `pyproject.toml` and `uv.lock` against the previous
head is #4614's own diff, line for line.

The Strands blocker from the July review no longer applies:
`strands-agents` 1.63.0 declares `mcp<2.4,>=1.23.0`, and the lock
resolves `mcp` 2.3.0 with it.

Dependency justification (CONTRIBUTING, new dep or version bump):

| Package | Change | Source |
|---|---|---|
| `mcp` | 1.30.0 → 2.3.0 | modelcontextprotocol/python-sdk |
| `mcp-types` | new, 2.3.0 | same SDK; `mcp` 2.3.0 pins it `==2.3.0` |
| `httpx2`, `httpcore2` | new, 2.16.0 | pydantic/httpx2 (Tom Christie);
SDK 2's HTTP client |
| `httpx2-jsfetch` | new, 1.0 | only on `sys_platform == 'emscripten'`;
not installed elsewhere |
| `strands-agents` | 1.62.0 → 1.63.0 | first release that accepts `mcp`
2.2+ |
| `httpx-sse` | removed | SDK 1 only |
| `idna` | 3.15 → 3.20 | required by `httpx2` |

## Type of Change

- [ ] Bug fix (non-breaking change that fixes an issue)
- [ ] New feature (non-breaking change that adds functionality)
- [x] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update
- [ ] Performance improvement
- [ ] Code refactoring (no functional changes)

## Changes Made

- `headroom/ccr/mcp_server.py`, `headroom/memory/mcp_server.py`:
register handlers as `on_list_tools` / `on_call_tool` constructor
callbacks, return `ListToolsResult` / `CallToolResult`, and read the
request context from the callback argument. These are #2658's changes,
including Jerrett's memory-backend cleanup hook.
- `pyproject.toml`: `mcp>=2.2.0,<3.0.0` in the `proxy` and `mcp` extras.
- `uv.lock`: relocked as described above.
- `tests/test_mcp_dependency_contract.py`: both extras must admit 2.2.0
and reject 1.30.0, 2.1.1 and 3.0.0.
- `tests/test_mcp_sdk2_contract.py`, `tests/_mcp_stub.py`,
`tests/test_mcp_stub.py`, `tests/test_memory/test_mcp_server.py`: from
#2658.
- `tests/test_ccr_mcp_http.py`: ported to the SDK 2 client. It reads the
session id from the `mcp-session-id` response header.
- `headroom/ccr/mcp_server.py` `_current_client`: read `client_info`
(SDK 2) instead of `clientInfo` (SDK 1), so `headroom_compress` savings
events name the client again. `tests/test_mcp_sdk2_contract.py` now
builds the SDK's own `InitializeRequestParams`; its old stand-in used
`clientInfo` and stayed green while every client was recorded as
`unknown`. Before and after, with an SDK 2.3 client named
`attribution-probe` over stdio: the ledger recorded `unknown` on both
`server/discover` and `initialize`, and now records `attribution-probe`
on both (found by Devin's review).

## Testing

- [x] Unit tests pass (`pytest`)
- [x] Linting passes (`ruff check .`)
- [ ] Type checking passes (`mypy headroom`)
- [x] New tests added for new functionality
- [x] Manual testing performed

### Test Output

After the rebase, on `274f0672`:

```text
# Python 3.11.17, mcp 2.3.0, strands-agents 1.63.0
$ pytest -q tests/test_mcp_dependency_contract.py tests/test_mcp_sdk2_contract.py tests/test_mcp_stub.py \
    tests/test_ccr_mcp_http.py tests/test_memory/test_mcp_server.py \
    <every test module that references mcp_server, GHSA or HEADROOM_MCP_READ_ROOTS, incl. tests/test_ccr_mcp_server.py>
840 passed, 2 skipped
$ uv lock --check
Resolved 253 packages
$ ruff check && ruff format --check on every changed .py file (ruff 0.17.2); git diff --check origin/main
clean
```

The wider 40-file mcp/strands run below was not repeated after the
rebase.

Before the rebase:

```text
# Python 3.11.17, uv sync --frozen --extra mcp --extra strands --extra proxy --extra otel (mcp 2.3.0, strands-agents 1.63.0)
$ pytest -q <every test module that references mcp, strands or the MCP servers: 40 files>
1163 passed, 31 skipped
$ pytest -q tests/test_ccr_mcp_http.py tests/test_mcp_dependency_contract.py tests/test_mcp_sdk2_contract.py
9 passed
$ pytest -q tests/integrations/test_strands tests/test_strands_tokenizer.py
80 passed, 25 skipped
$ uv run --with uv==0.9.30 python -m uv lock --check
Resolved 253 packages
$ ruff check && ruff format --check on every changed .py file (ruff 0.16.8); git diff --check origin/main
clean
# [all] export against the union of the extras it includes: no package missing
```

## Real Behavior Proof

- Environment: macOS 27 (arm64), Python 3.11.17; `main` `fc1ba891` (SDK
1.30.0) and this branch (SDK 2.3.0); temporary `HOME`; plus this branch
merged into my local runtime branch and installed as the `headroom` uv
tool.
- Exact command / steps: an SDK 2.3 stdio client starts `headroom mcp
serve`, calls `ClientSession.discover()` (`server/discover`, as Claude
Code does first), falls back to `initialize()` if that is rejected, then
lists tools and calls `headroom_stats`. The server's stderr is captured.
- Observed result: on `main`, `server/discover` is rejected with -32602
and the legacy `initialize` is used; stderr has 94 lines, starting
`WARNING: Failed to validate request: 31 validation errors for
ClientRequest`; 3 tools are listed and the call succeeds. On this branch
the modern `server/discover` is accepted and stderr has 0 lines; 3 tools
are listed and the call succeeds. The installed build behaves the same.
- Not tested: Windows; the memory MCP server against a live client (unit
and contract tests only); Strands agents against a live MCP server
(`tests/integrations/test_strands` and
`tests/test_strands_tokenizer.py`: 80 passed, 25 skipped); a real
network client against the Streamable HTTP transport (the ASGI contract
test only).

## Runtime Rollout Safety

- Rollout-managed feature(s): none
- Minimum rollout channel: n/a, dependency and server API change
- Stable/default behavior changed: yes; the MCP servers require SDK 2.2+
and speak the modern handshake; the tools and their JSON results are
unchanged
- Kill switch / disable path: none; pin `headroom-ai` to the previous
release to stay on SDK 1
- Unsafe override required: no
- Qualification impact: environments that pin `mcp<2` alongside
`headroom-ai[mcp]` or `[proxy]` no longer resolve
- Rollback path: revert this commit, which restores the `<2.0.0` cap

## Review Readiness

- [x] I have performed a self-review
- [x] This PR is ready for human review

## Checklist

- [x] My code follows the project's style guidelines
- [x] I have performed a self-review of my code
- [x] I have commented my code, particularly in hard-to-understand areas
- [ ] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [x] I have added tests that prove my fix is effective or that my
feature works
- [x] New and existing unit tests pass locally with my changes
- [x] I did **not** edit `CHANGELOG.md` — it is generated by
release-please from my Conventional Commit PR title (a CI guard enforces
this)

## Screenshots (if applicable)

N/A

## Additional Notes

Proposed on #2658
(https://github.com/headroomlabs-ai/headroom/pull/2658#issuecomment-6562744017).
If maintainers would rather keep #2658, `ce4d6442` and `274f0672`
(previously `39c574c2` and `c7900848`) can be cherry-picked onto
`tejas/mcp-2x-port` instead, and I'll close this.

`mypy headroom/ccr/mcp_server.py headroom/memory/mcp_server.py
headroom/ccr/mcp_http.py` with SDK 2.3 installed reports one error, in
`headroom/providers/model_metadata.py:79`, which `main` reports too;
none in the changed files. Full `mypy headroom` was not run. No docs
change: the MCP tool names, arguments and results are unchanged.

---------

Co-authored-by: Kenneth Wong <17061293+KennethWKZ@users.noreply.github.com>
Co-authored-by: Tejas Chopra <chopratejas@gmail.com>
Co-authored-by: JerrettDavis <mxjerrett@gmail.com>
2026-11-04 08:46:49 -06:00

488 lines
17 KiB
Python

import asyncio
from types import SimpleNamespace
from unittest.mock import AsyncMock
import numpy as np
from headroom.memory.models import Memory
from tests._mcp_stub import import_module_with_mcp_stub
mcp_server_mod = import_module_with_mcp_stub("headroom.memory.mcp_server")
class _CapturingServer:
"""MCP 2.x takes handlers as constructor callbacks rather than decorators."""
def __init__(self, name: str, on_list_tools=None, on_call_tool=None, **_: object) -> None:
self.name = name
self.list_tools_handler = on_list_tools
self.call_tool_handler = on_call_tool
class _CallParams:
"""Stand-in for ``mcp.types.CallToolRequestParams``."""
def __init__(self, name: str, arguments: dict | None = None) -> None:
self.name = name
self.arguments = arguments
def test_warm_up_backend_batches_embedding_and_indexing() -> None:
"""Warm-up should batch missing embeddings and vector indexing."""
warmup_embedding = np.ones(384, dtype=np.float32)
batch_embeddings = [
np.full(384, 2.0, dtype=np.float32),
np.full(384, 3.0, dtype=np.float32),
]
embedder = SimpleNamespace(
embed=AsyncMock(return_value=warmup_embedding),
embed_batch=AsyncMock(return_value=batch_embeddings),
)
store = SimpleNamespace(save_batch=AsyncMock())
vector_index = SimpleNamespace(index_batch=AsyncMock(return_value=3))
memory_without_embedding_a = Memory(content="First", user_id="alice")
memory_with_embedding = Memory(
content="Second",
user_id="alice",
embedding=np.full(384, 5.0, dtype=np.float32),
)
memory_without_embedding_b = Memory(content="Third", user_id="alice")
memories = [
memory_without_embedding_a,
memory_with_embedding,
memory_without_embedding_b,
]
backend = SimpleNamespace(
_ensure_initialized=AsyncMock(),
_hierarchical_memory=SimpleNamespace(
_embedder=embedder,
_store=store,
_vector_index=vector_index,
),
get_user_memories=AsyncMock(return_value=memories),
)
asyncio.run(mcp_server_mod._warm_up_backend(backend, "alice"))
backend._ensure_initialized.assert_awaited_once()
backend.get_user_memories.assert_awaited_once_with("alice", limit=500)
embedder.embed.assert_awaited_once_with("warmup")
embedder.embed_batch.assert_awaited_once_with(["First", "Third"])
store.save_batch.assert_awaited_once_with(
[memory_without_embedding_a, memory_without_embedding_b]
)
vector_index.index_batch.assert_awaited_once_with(memories)
assert np.array_equal(memory_without_embedding_a.embedding, batch_embeddings[0])
assert np.array_equal(memory_without_embedding_b.embedding, batch_embeddings[1])
def test_tool_call_waits_for_handshake_warm_up(monkeypatch) -> None:
async def scenario() -> None:
warm_up_started = asyncio.Event()
release_warm_up = asyncio.Event()
backend = SimpleNamespace()
async def warm_up(candidate, user_id: str) -> None:
assert candidate is backend
assert user_id == "alice"
warm_up_started.set()
await release_warm_up.wait()
handle_search = AsyncMock(return_value=["search result"])
monkeypatch.setattr(mcp_server_mod, "Server", _CapturingServer)
monkeypatch.setattr(mcp_server_mod, "LocalBackend", lambda config: backend)
monkeypatch.setattr(mcp_server_mod, "_warm_up_backend", warm_up)
monkeypatch.setattr(mcp_server_mod, "_handle_search", handle_search)
server = mcp_server_mod.create_memory_server("memory.db", user_id="alice")
await server.list_tools_handler(None, None)
await warm_up_started.wait()
tool_call = asyncio.create_task(
server.call_tool_handler(None, _CallParams("memory_search", {"query": "preferences"}))
)
await asyncio.sleep(0)
handle_search.assert_not_awaited()
assert not tool_call.done()
release_warm_up.set()
assert (await tool_call).content == ["search result"]
handle_search.assert_awaited_once_with(
backend,
{"query": "preferences"},
"alice",
)
asyncio.run(scenario())
def test_failed_handshake_init_is_discarded_and_retried(monkeypatch) -> None:
async def scenario() -> None:
first_warm_up_started = asyncio.Event()
fail_first_warm_up = asyncio.Event()
failed_backend_closed = asyncio.Event()
async def close_failed_backend() -> None:
failed_backend_closed.set()
failed_backend = SimpleNamespace(close=AsyncMock(side_effect=close_failed_backend))
ready_backend = SimpleNamespace(close=AsyncMock())
backends = iter([failed_backend, ready_backend])
async def warm_up(candidate, user_id: str) -> None:
assert user_id == "alice"
if candidate is failed_backend:
first_warm_up_started.set()
await fail_first_warm_up.wait()
raise RuntimeError("warm-up failed")
handle_search = AsyncMock(return_value=["search result"])
monkeypatch.setattr(mcp_server_mod, "Server", _CapturingServer)
monkeypatch.setattr(mcp_server_mod, "LocalBackend", lambda config: next(backends))
monkeypatch.setattr(mcp_server_mod, "_warm_up_backend", warm_up)
monkeypatch.setattr(mcp_server_mod, "_handle_search", handle_search)
server = mcp_server_mod.create_memory_server("memory.db", user_id="alice")
await server.list_tools_handler(None, None)
await first_warm_up_started.wait()
fail_first_warm_up.set()
await failed_backend_closed.wait()
await asyncio.sleep(0)
failed_backend.close.assert_awaited_once()
handle_search.assert_not_awaited()
result = await server.call_tool_handler(
None, _CallParams("memory_search", {"query": "preferences"})
)
assert result.content == ["search result"]
handle_search.assert_awaited_once_with(
ready_backend,
{"query": "preferences"},
"alice",
)
ready_backend.close.assert_not_awaited()
asyncio.run(scenario())
def test_concurrent_tool_calls_share_backend_initialization(monkeypatch) -> None:
async def scenario() -> None:
warm_up_started = asyncio.Event()
release_warm_up = asyncio.Event()
backend = SimpleNamespace()
created_backends = 0
def create_backend(config):
nonlocal created_backends
created_backends += 1
return backend
async def warm_up(candidate, user_id: str) -> None:
assert candidate is backend
assert user_id == "alice"
warm_up_started.set()
await release_warm_up.wait()
handle_search = AsyncMock(return_value=["search result"])
monkeypatch.setattr(mcp_server_mod, "Server", _CapturingServer)
monkeypatch.setattr(mcp_server_mod, "LocalBackend", create_backend)
monkeypatch.setattr(mcp_server_mod, "_warm_up_backend", warm_up)
monkeypatch.setattr(mcp_server_mod, "_handle_search", handle_search)
server = mcp_server_mod.create_memory_server("memory.db", user_id="alice")
calls = [
asyncio.create_task(
server.call_tool_handler(
None, _CallParams("memory_search", {"query": f"query-{index}"})
)
)
for index in range(2)
]
await warm_up_started.wait()
await asyncio.sleep(0)
assert created_backends == 1
handle_search.assert_not_awaited()
release_warm_up.set()
assert [r.content for r in await asyncio.gather(*calls)] == [
["search result"],
["search result"],
]
assert handle_search.await_count == 2
assert all(call.args[0] is backend for call in handle_search.await_args_list)
asyncio.run(scenario())
def test_server_cleanup_closes_initialized_backend_once(monkeypatch) -> None:
async def scenario() -> None:
backend = SimpleNamespace(close=AsyncMock())
monkeypatch.setattr(mcp_server_mod, "Server", _CapturingServer)
monkeypatch.setattr(mcp_server_mod, "LocalBackend", lambda config: backend)
monkeypatch.setattr(mcp_server_mod, "_warm_up_backend", AsyncMock())
server = mcp_server_mod.create_memory_server("memory.db", user_id="alice")
await server.list_tools_handler(None, None)
await asyncio.sleep(0)
close_backend = server._headroom_close
await close_backend()
await close_backend()
backend.close.assert_awaited_once()
asyncio.run(scenario())
def test_server_cleanup_cancels_pending_backend_initialization(monkeypatch) -> None:
async def scenario() -> None:
init_started = asyncio.Event()
backend = SimpleNamespace(close=AsyncMock())
async def warm_up(_backend, _user_id: str) -> None:
init_started.set()
await asyncio.Event().wait()
monkeypatch.setattr(mcp_server_mod, "Server", _CapturingServer)
monkeypatch.setattr(mcp_server_mod, "LocalBackend", lambda config: backend)
monkeypatch.setattr(mcp_server_mod, "_warm_up_backend", warm_up)
server = mcp_server_mod.create_memory_server("memory.db", user_id="alice")
await server.list_tools_handler(None, None)
await init_started.wait()
await server._headroom_close()
backend.close.assert_awaited_once()
asyncio.run(scenario())
def test_run_closes_backend_when_stdio_exits(monkeypatch) -> None:
async def scenario() -> None:
close_backend = AsyncMock()
server = SimpleNamespace(
create_initialization_options=lambda: {},
run=AsyncMock(),
_headroom_close=close_backend,
)
class _StdioContext:
async def __aenter__(self):
return object(), object()
async def __aexit__(self, exc_type, exc_value, traceback):
return False
monkeypatch.setattr(mcp_server_mod, "create_memory_server", lambda *args: server)
monkeypatch.setattr(mcp_server_mod, "stdio_server", lambda: _StdioContext())
await mcp_server_mod._run("memory.db", "alice")
server.run.assert_awaited_once()
close_backend.assert_awaited_once()
asyncio.run(scenario())
def test_memory_mcp_startup_context_reports_dynamic_project_db(tmp_path) -> None:
project_dir = tmp_path / "project-a"
project_dir.mkdir()
configured_db = str(project_dir / ".headroom" / "memory.db")
context = mcp_server_mod._memory_mcp_startup_context(
configured_db,
project_dir,
db_flag_present=False,
)
assert context == {
"configured_db": configured_db,
"resolved_db": configured_db,
"config_source": "cwd-default",
"cwd": str(project_dir),
"project_root": str(project_dir),
"storage_scope": "active-project",
"path_exists": False,
"path_readable": False,
"resolution": "dynamic-cwd",
}
def test_memory_mcp_startup_context_reports_static_external_db(tmp_path) -> None:
project_dir = tmp_path / "project-a"
project_dir.mkdir()
external_db = tmp_path / "shared-memory" / "memory.db"
external_db.parent.mkdir()
external_db.write_text("sqlite placeholder")
context = mcp_server_mod._memory_mcp_startup_context(
str(external_db),
project_dir,
db_flag_present=True,
)
assert context == {
"configured_db": str(external_db),
"resolved_db": str(external_db.resolve(strict=False)),
"config_source": "cli-flag",
"cwd": str(project_dir),
"project_root": str(project_dir),
"storage_scope": "external-memory-db",
"path_exists": True,
"path_readable": True,
"resolution": "static-cli",
}
def test_memory_mcp_startup_context_reports_custom_db_path(tmp_path) -> None:
project_dir = tmp_path / "project-a"
project_dir.mkdir()
custom_db = tmp_path / "queries.db"
context = mcp_server_mod._memory_mcp_startup_context(
str(custom_db),
project_dir,
db_flag_present=True,
)
assert context["storage_scope"] == "custom-db-path"
assert context["config_source"] == "cli-flag"
assert context["path_exists"] is False
assert context["path_readable"] is False
def test_main_logs_memory_mcp_startup_context(monkeypatch, tmp_path, caplog) -> None:
project_dir = tmp_path / "project-a"
project_dir.mkdir()
monkeypatch.chdir(project_dir)
monkeypatch.setenv("USER", "codex-user")
monkeypatch.setattr(mcp_server_mod.logging, "basicConfig", lambda **kwargs: None)
monkeypatch.setattr(mcp_server_mod.sys, "argv", ["memory-mcp"])
captured_run_payloads: list[object] = []
monkeypatch.setattr(
mcp_server_mod,
"_run",
lambda db_path, user_id: ("run", db_path, user_id),
)
monkeypatch.setattr(
mcp_server_mod.asyncio,
"run",
lambda payload: captured_run_payloads.append(payload),
)
caplog.set_level("INFO", logger="headroom.memory.mcp")
mcp_server_mod.main()
assert captured_run_payloads == [
("run", str(project_dir / ".headroom" / "memory.db"), "codex-user")
]
assert any(
"Memory MCP startup: configured_db=" in record.message
and "config_source=cwd-default" in record.message
and "storage_scope=active-project" in record.message
and "resolution=dynamic-cwd" in record.message
for record in caplog.records
)
def test_search_records_access_only_for_returned_memories() -> None:
active = Memory(content="Active preference", user_id="alice")
extra = Memory(content="Lower-ranked preference", user_id="alice")
backend = SimpleNamespace(
search_memories=AsyncMock(
return_value=[
SimpleNamespace(memory=active, score=0.9, related_entities=[]),
SimpleNamespace(memory=extra, score=0.8, related_entities=[]),
]
),
get_memory=AsyncMock(
side_effect=lambda memory_id: {
active.id: active,
extra.id: extra,
}[memory_id]
),
record_access=AsyncMock(return_value=1),
)
result = asyncio.run(
mcp_server_mod._handle_search(
backend,
{"query": "preference", "top_k": 1},
"alice",
)
)
backend.record_access.assert_awaited_once_with([active.id])
assert "Active preference" in result[0].kwargs["text"]
assert "Lower-ranked preference" not in result[0].kwargs["text"]
def test_search_does_not_record_superseded_memories() -> None:
superseded = Memory(content="Old preference", user_id="alice")
replacement = Memory(content="Current preference", user_id="alice")
superseded.superseded_by = replacement.id
backend = SimpleNamespace(
search_memories=AsyncMock(
return_value=[SimpleNamespace(memory=superseded, score=0.9, related_entities=[])]
),
get_memory=AsyncMock(return_value=superseded),
record_access=AsyncMock(),
)
result = asyncio.run(mcp_server_mod._handle_search(backend, {"query": "preference"}, "alice"))
backend.record_access.assert_not_awaited()
assert result[0].kwargs["text"] == "No memories found."
def test_search_fails_open_when_access_tracking_fails() -> None:
memory = Memory(content="Useful preference", user_id="alice")
backend = SimpleNamespace(
search_memories=AsyncMock(
return_value=[SimpleNamespace(memory=memory, score=0.9, related_entities=[])]
),
get_memory=AsyncMock(return_value=memory),
record_access=AsyncMock(side_effect=RuntimeError("write failed")),
)
result = asyncio.run(mcp_server_mod._handle_search(backend, {"query": "preference"}, "alice"))
assert "Useful preference" in result[0].kwargs["text"]
def test_save_does_not_supersede_a_semantically_similar_memory() -> None:
existing = Memory(content="Use compact output by default", user_id="alice")
saved = Memory(content="Keep semantic compression disabled", user_id="alice")
backend = SimpleNamespace(
search_memories=AsyncMock(return_value=[SimpleNamespace(memory=existing, score=0.91)]),
update_memory=AsyncMock(),
save_memory=AsyncMock(return_value=saved),
)
result = asyncio.run(
mcp_server_mod._handle_save(
backend,
{"facts": ["Keep semantic compression disabled"], "importance": 0.9},
"alice",
)
)
backend.search_memories.assert_not_awaited()
backend.update_memory.assert_not_awaited()
backend.save_memory.assert_awaited_once_with(
content="Keep semantic compression disabled",
user_id="alice",
importance=0.9,
)
assert result[0].kwargs["text"].startswith("Saved 1 new, updated 0 existing")