mirror of
https://github.com/headroomlabs-ai/headroom.git
synced 2026-11-22 13:29:19 +08:00
## 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>
178 lines
6.1 KiB
Python
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
|