Files
headroom/tests/test_memory_tool_user_scope.py
48df6df497 fix(memory): scope memory_update and memory_delete to the calling user (#4869)
## Description

The `memory_delete` tool called `backend.delete_memory(memory_id)`
without the user id. `LocalBackend.update_memory` and `delete_memory`
ignored `user_id`, and `DirectMem0Adapter` did the same. When users
share one store (`global` storage mode, or the qdrant-neo4j backend), a
memory id that belonged to another user could be deleted or overwritten.

The handler now passes the effective user id to `delete_memory`. Both
backends now treat an id owned by someone else as not found: delete
returns `False`, and update raises the same not-found `ValueError` it
raises for an unknown id. A caller that passes no `user_id` (the CLI,
`MemorySystem`) keeps the old unscoped behaviour.

## Type of Change

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

## Changes Made

- `headroom/proxy/memory_handler.py`: `_execute_delete`, and the
delete+save fallback in `_execute_update`, pass
`user_id=effective_user_id`. The fallback now returns `not_found` when
nothing was deleted, instead of saving a replacement.
- `headroom/memory/backends/local.py`: `update_memory` and
`delete_memory` check the stored owner when `user_id` is given.
- `headroom/memory/backends/direct_mem0.py`: `update_memory` and
`delete_memory` check the owner through `get_memory` when `user_id` is
given. If the lookup fails, the id is treated as not found.
- `headroom/memory/backends/mem0_system_adapter.py`: `delete_memory`
with a `user_id` used to delete anyway when the owner lookup raised (it
caught every exception) or when the record had no owner. It now deletes
only when the stored owner matches. A `ValueError`/`OSError` from the
lookup is logged and the delete is refused; anything else propagates.
`Mem0Backend` (`backends/mem0.py`) is the raw client that this adapter
wraps; the proxy never calls it directly.
- Tests: a new `tests/test_memory_tool_user_scope.py` runs through
`create_app` with a real `LocalBackend` in `global` mode and a
`MockTransport` upstream. There is also one `DirectMem0Adapter` test.
Fake backends in `test_memory_handler_native_ops.py` now accept
`user_id`.

## Testing

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

### Test Output

In the test, alice saves a memory. bob's request then gets an upstream
turn that calls `memory_delete`, or `memory_update`, with alice's id.
The test passes when alice's memory is unchanged. The controls check
that bob can still delete and update his own memory.

On `origin/main` (0368a872):
```text
PASSED tests/test_memory_tool_user_scope.py::test_user_can_still_change_own_memory[memory_delete-args0]
PASSED tests/test_memory_tool_user_scope.py::test_user_can_still_change_own_memory[memory_update-args1]
FAILED tests/test_memory_tool_user_scope.py::test_memory_owned_by_another_user_is_left_alone[memory_delete-args0]
FAILED tests/test_memory_tool_user_scope.py::test_memory_owned_by_another_user_is_left_alone[memory_update-args1]
2 failed, 2 passed
FAILED tests/test_memory/test_direct_mem0.py::test_update_and_delete_leave_another_users_memory_alone
1 failed, 23 deselected
```
On this branch:
```text
PASSED tests/test_memory_tool_user_scope.py::test_memory_owned_by_another_user_is_left_alone[memory_delete-args0]
PASSED tests/test_memory_tool_user_scope.py::test_memory_owned_by_another_user_is_left_alone[memory_update-args1]
PASSED tests/test_memory_tool_user_scope.py::test_user_can_still_change_own_memory[memory_delete-args0]
PASSED tests/test_memory_tool_user_scope.py::test_user_can_still_change_own_memory[memory_update-args1]
4 passed
PASSED tests/test_memory/test_direct_mem0.py::test_update_and_delete_leave_another_users_memory_alone
1 passed, 23 deselected
```
`Mem0SystemAdapter` (second commit),
`test_delete_is_refused_unless_the_owner_is_confirmed`: 4 failed, 1
passed on the first commit (only `other-owner` passed); 5 passed with
the fix. Memory tests after it: 875 passed, 2 skipped.

The existing memory test files (74 files) pass on this branch:
```text
1447 passed, 27 skipped in 64.67s
(after review follow-ups: test_memory_tool_user_scope, test_memory_handler_native_ops, test_direct_mem0: 69 passed, 1 skipped)
```
`uvx ruff@0.17.3 check` and `format --check` pass on the changed files.
`mypy` on the three changed modules reports no issues.

## Real Behavior Proof

- Environment: macOS, Python 3.12. The proxy is created in-process with
`create_app(ProxyConfig(memory_enabled=True,
memory_storage_mode="global", memory_inject_tools=True))` and backed by
a real `LocalBackend` (SQLite plus sqlite-vec, fixed test embedder). The
upstream is `httpx.MockTransport`, and
`LITELLM_LOCAL_MODEL_COST_MAP=True`.
- Exact command / steps: `pytest tests/test_memory_tool_user_scope.py`.
alice saves a memory. A `/v1/messages` request with `x-headroom-user-id:
bob` gets an upstream `memory_delete` or `memory_update` with alice's
id. The proxy runs the tool and continues the turn.
- Observed result: on main, alice's memory is deleted, or superseded
with bob's content. On this branch it is unchanged. The model gets
`not_found` for delete, and the usual not-found error for update.
- Not tested: a live qdrant/neo4j deployment. `DirectMem0Adapter` is
covered with a stubbed mem0 client.

## Runtime Rollout Safety

- Rollout-managed feature(s): none.
- Minimum rollout channel: n/a.
- Stable/default behavior changed: only for update/delete calls on an id
the caller does not own. They now return not found.
- Kill switch / disable path: none needed.
- Unsafe override required: no.
- Qualification impact: none.
- Rollback path: revert this PR.

## 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)

## Additional Notes

This PR is independent of the PR that limits which memory tool calls the
proxy runs. Either can merge first.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Reported by @JoaoMarcos44. Thank you for your contribution! 🩵

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: JerrettDavis <mxjerrett@gmail.com>
2026-11-14 10:47:00 +05:30

178 lines
6.1 KiB
Python

"""memory_update / memory_delete only touch the calling user's memories.
With one shared store (``global`` storage), a memory id that belongs to
another user is treated as not found: it is neither changed nor removed.
"""
from __future__ import annotations
import json
from typing import Any
import httpx
import numpy as np
import pytest
from headroom.memory.adapters.cache import LRUMemoryCache
from headroom.memory.adapters.fts5 import FTS5TextIndex
from headroom.memory.adapters.sqlite import SQLiteMemoryStore
from headroom.memory.adapters.sqlite_vector import SQLiteVectorIndex, is_sqlite_vec_available
from headroom.memory.backends.local import LocalBackend, LocalBackendConfig
from headroom.memory.config import MemoryConfig
from headroom.memory.core import HierarchicalMemory
from headroom.proxy.server import ProxyConfig, create_app
pytestmark = pytest.mark.skipif(not is_sqlite_vec_available(), reason="sqlite-vec unavailable")
class _FixedEmbedder:
async def embed(self, text: str) -> np.ndarray:
return np.array([1.0, 0.0, 0.0], dtype=np.float32)
async def embed_batch(self, texts: list[str]) -> list[np.ndarray]:
return [await self.embed(t) for t in texts]
@pytest.fixture
def backend(tmp_path, monkeypatch) -> LocalBackend:
async def create(cls: type, config: MemoryConfig | None = None) -> HierarchicalMemory:
return HierarchicalMemory(
SQLiteMemoryStore(tmp_path / "memory.db"),
SQLiteVectorIndex(dimension=3, db_path=tmp_path / "vectors.db"),
FTS5TextIndex(tmp_path / "memory.db"),
_FixedEmbedder(),
LRUMemoryCache(),
MemoryConfig(auto_bubble=False, vector_dimension=3),
)
monkeypatch.setattr(HierarchicalMemory, "create", classmethod(create))
return LocalBackend(
LocalBackendConfig(db_path=str(tmp_path / "memory.db"), graph_persist=False)
)
def _anthropic_turn(content: list[dict[str, Any]], stop_reason: str) -> dict[str, Any]:
return {
"id": "msg_1",
"type": "message",
"role": "assistant",
"model": "claude-sonnet-4-5",
"content": content,
"stop_reason": stop_reason,
"stop_sequence": None,
"usage": {"input_tokens": 1, "output_tokens": 1},
}
async def _call_tool_as(
tmp_path, backend: LocalBackend, user_id: str, tool: str, args: dict[str, Any]
) -> None:
app = create_app(
ProxyConfig(
anthropic_api_url="https://anthropic.invalid",
optimize=False,
image_optimize=False,
cache_enabled=False,
rate_limit_enabled=False,
cost_tracking_enabled=False,
ccr_inject_tool=False,
ccr_handle_responses=False,
ccr_context_tracking=False,
discover_pipeline_extensions=False,
compression_max_workers=1,
memory_enabled=True,
memory_storage_mode="global",
memory_inject_tools=True,
memory_inject_context=False,
memory_db_path=str(tmp_path / "memory.db"),
)
)
handler = app.state.proxy.memory_handler
handler._backend = backend
handler._initialized = True
# Every scope resolves to the one shared fixture store, as in global mode.
router = handler._router
if router is not None:
router.backend_for = lambda ctx: (backend, router.scope_for(ctx))
turns = [
_anthropic_turn(
[{"type": "tool_use", "id": "toolu_1", "name": tool, "input": args}], "tool_use"
),
_anthropic_turn([{"type": "text", "text": "done"}], "end_turn"),
]
sent: list[dict[str, Any]] = []
def upstream(request: httpx.Request) -> httpx.Response:
sent.append(json.loads(request.content))
return httpx.Response(200, json=turns[len(sent) - 1])
mock = httpx.AsyncClient(transport=httpx.MockTransport(upstream))
app.state.proxy.http_client = mock
app.state.proxy.http_client_h1 = mock
transport = httpx.ASGITransport(app=app, client=("127.0.0.1", 12345))
async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
response = await client.post(
"/v1/messages",
json={
"model": "claude-sonnet-4-5",
"max_tokens": 64,
"messages": [{"role": "user", "content": "hi"}],
"tools": [{"name": "Bash", "input_schema": {"type": "object"}}],
},
headers={
"x-api-key": "FAKE-KEY",
"anthropic-version": "2023-06-01",
"x-headroom-user-id": user_id,
},
timeout=30,
)
await mock.aclose()
assert response.status_code == 200
# The proxy ran the tool and continued the turn.
assert len(sent) == 2
@pytest.mark.parametrize(
("tool", "args"),
[
("memory_delete", {}),
("memory_update", {"new_content": "overwritten"}),
],
)
async def test_memory_owned_by_another_user_is_left_alone(
tmp_path, monkeypatch, backend: LocalBackend, tool: str, args: dict[str, Any]
) -> None:
monkeypatch.setenv("LITELLM_LOCAL_MODEL_COST_MAP", "True")
alice = await backend.save_memory(content="alice prefers tabs", user_id="alice")
await _call_tool_as(tmp_path, backend, "bob", tool, {"memory_id": alice.id, **args})
kept = await backend.get_memory(alice.id)
assert kept is not None
assert kept.content == "alice prefers tabs"
assert kept.superseded_by is None
@pytest.mark.parametrize(
("tool", "args"),
[
("memory_delete", {}),
("memory_update", {"new_content": "bob prefers tabs"}),
],
)
async def test_user_can_still_change_own_memory(
tmp_path, monkeypatch, backend: LocalBackend, tool: str, args: dict[str, Any]
) -> None:
monkeypatch.setenv("LITELLM_LOCAL_MODEL_COST_MAP", "True")
bob = await backend.save_memory(content="bob prefers spaces", user_id="bob")
await _call_tool_as(tmp_path, backend, "bob", tool, {"memory_id": bob.id, **args})
old = await backend.get_memory(bob.id)
if tool == "memory_delete":
assert old is None
else:
assert old is not None
assert old.superseded_by is not None