Files
EverOS/tests/integration/test_memorize_integration.py
T
Kendrick-SongandClaude Opus 4.7 b1441da607 refactor(config): make [embedding] and [rerank] soft dependencies (#361)
* refactor(config): make [embedding] and [rerank] soft dependencies

Make [embedding] and [rerank] soft runtime dependencies so a
freshly-onboarded user can run EverOS end-to-end with only [llm]
configured. Previously the server refused to start without embedding,
locking out anyone who just wanted keyword-only search.

## Capability tiers

- Tier 1 ([llm] only)                   KEYWORD search, add/flush, md
                                        writes, cascade sync
- Tier 2 ([llm] + [embedding])          + VECTOR / HYBRID search,
                                        reflection, skill extraction,
                                        backfill
- Tier 3 ([llm] + [embedding] + rerank) + AGENTIC search, knowledge

Tier upgrades require a server restart (capability accessors cache
for the process lifetime). Tier downgrades are read-safe: a Tier-3
user who drops [rerank] can still read/rename/delete existing
knowledge documents; only write/search endpoints return 422.

## What changed

- Component accessors — component/{embedding,rerank,llm}/accessor.py
  are the single process-wide provider singletons. service/* never
  maintains parallel singletons; it consumes get_embedding_capability()
  / get_rerank_capability() / get_llm_client() directly. Build-time
  ValueError from the factory is logged as capability_build_failed
  (was silently swallowed).
- Error mapping — ProviderNotConfiguredError -> 422 with everos.toml
  section hints (never EVEROS_* env-var strings).
  LanceDBMigrationError fails loud with escalating recovery guidance
  (restart -> wipe index). LLMNotConfiguredError in search maps to
  None for KEYWORD degradation.
- Nullable-vector LanceDB migration — schema v2 makes the vector
  column nullable so Tier-1 rows can land without embeddings.
  Migration is guarded by a cross-process memory_root_lock
  (fcntl.flock + anyio.to_thread) and runs optimize() per table
  after Phase-1 backfill to reclaim manifest bloat.
- Cascade — knowledge handlers register unconditionally (Tier-3 ->
  Tier-2/1 downgrade no longer strands DELETE); embed-requiring
  strategies use body-guards that check capability.available at
  execution time. _TABLE_SPECS has an import-time drift assertion
  against BUSINESS_SCHEMAS_WITH_VECTOR.
- `everos cascade backfill` CLI — Phase-1 (embed missing vectors) /
  Phase-2 (emit synthetic events for cascaded processing) / Phase-3
  (sync new skill files). Exit codes: 0 / 1 / 2 / 3 (server running
  preflight) / 4 (COMPLETED_WITH_FAILURES — per-row failures rolled
  up) / 130 (SIGINT). OMEConfig.crash_recovery_enabled=False in
  backfill engines prevents stale-RUNNING rows re-enqueuing into a
  smaller strategy registry.
- /health — reports capabilities + disabled_features per tier so ops
  can distinguish "boots but degraded" from "boots and full".
- Presentation split — memory / service / infra never import typer /
  click. TyperPresenter Protocol + run_backfill() live in
  entrypoints/cli/commands/_backfill_cmd.py. Enforced by
  import-linter.
- Startup hint — unconditional count_rows(filter="vector IS NULL")
  sweep emits unbackfilled_memory_rows (event name + hint text
  pinned) when Tier-1 rows exist. ParserLifespanProvider warms the
  everalgo.parser import at boot so /health doesn't block on first
  call.
- Knowledge upload UTF-8 short-circuit — _looks_like_utf8_text()
  routes text/* mime and known plaintext extensions (md/txt/rst)
  straight to UTF-8 decode instead of the parser. Prevents 503
  Multimodal-not-configured when Tier 3 sans [multimodal] uploads a
  markdown doc.

## Sync history with main (2 merges collapsed into this squash)

Merged origin/main at 6dcd3eb (v1.1.4 -> v1.2.0 adds OTel tracing,
/api/v2 alias, TracingLifespanProvider, per-cascade-embedding span
fix, memory-op instrumentation) and later at 42629df (PR #366
backfills v1.1.4 CWE-22 knowledge path traversal fix + cascade
retry-budget rework + errors.py -> core.errors.ExternalServiceError).
Key merge decisions:
- service/search.py adopts single wrap site — component.llm accessor
  already applies UsageRecordingClient when observability is on;
  service layer never keeps a parallel LLM singleton (Round-1 CR
  rule: "service layer never maintains parallel singletons").
- Knowledge router prefix moved to /knowledge; create_app() mounts
  it under both /api/v1 and /api/v2.
- Cascade retry classification uses ExternalServiceError from
  core.errors (cascade/errors.py deleted). _MAX_TOTAL_RETRIES=12
  cross-cycle budget preserved.
- Fixed backport typo: MemoryRoot.default() -> MemoryRoot.resolve()
  (no .default() classmethod exists — main PR #366 shipped a broken
  call).

## Verified layering

    $ git grep -l "^import typer\|^from typer" src/everos/{memory,service,infra}
    # empty
    $ git grep -l "^import click\|^from click" src/everos/{memory,service,infra}
    # empty

Memory / service / infra layers clean of CLI presentation libraries.

## Review history

Three rounds of Fable 5 (opus) code review across the pre-squash
commit history closed 38 findings total:
- Round 1: 10 findings (fail-loud migration, backfill hardening,
  knowledge router gate scoping, SearchManager guards, profile
  throttle lift)
- Round 2: 13 findings (hermetic test env, hot-reload doc drift,
  knowledge handler registration, Phase 3 sync guarantee, Phase 2
  idempotency, profile event-first path, OMEConfig crash-recovery
  gate, cross-process migration lock, batch embed per-row fallback,
  LanceDB optimize, typer/click layer split)
- Round 3: 15 Minor cleanups (accessor unification, marker revert,
  episode query hygiene, --verbose subcommand, parser lifespan warm,
  task-number scrub, temporal-overlap test, real-SIGINT slow mark,
  4 design-note back-references)

Full per-round context lives in the PR description on GitHub.

## Test plan

- make lint (ruff + import-linter 3 contracts + assets +
  deprecated-names + github-docs + datetime + OpenAPI drift)
- Hermetic env full pytest — 2027 passed / 7 deselected (7 = slow +
  live_llm markers)
- Manual e2e across Tier 1/2/3 (21/21 assertions across v1/v2
  double-mount and Tier 3 -> Tier 2 downgrade)
- /health reports correct capabilities + disabled_features per tier

## Known follow-ups

- .superpowers/sdd/followup-http-bridge.md (gitignored) — Path A for
  spec §10's "backfill 期间 EverOS 完全可用" promise
- _TABLE_SCHEMA_VERSION docstring — v3+ migrations need a version
  dispatch table
- extract_user_profile.py throttle-counter block — replace LanceDB
  count_by_owner with a sqlite memcell count

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(review): close 3 blockers surfaced by round-4 review

N1. cluster_repo.find_cluster_id_for_member was cross-owner-unsafe.
Its reverse index (member_type, member_id) alone cannot disambiguate
two owners whose entry_id happens to collide — entry_id is
deliberately only per-owner unique (see entries.py:47:
'Cross-user uniqueness is handled at the database layer via a
composite <user_id>_<entry_id> field; it is not encoded into the
EntryId string itself'). Phase 2's _scan_all_rows crosses all
owners, so on any multi-owner root, same-day seq=1 episodes under
different owners would either false-hit each other's cluster or
be silently skipped from clustering. Add required (app_id,
project_id, owner_id) keyword args + JOIN Cluster (which already
carries scope) to filter by parent scope. Prior signature had zero
production callers except two the same PR just added, so the
API break is contained. Regression test: two owners persist a
cluster each around the same entry_id, each lookup resolves to
its own owner's cluster, a third owner's lookup returns None.

N2. Ctrl-C / EOF at the y/N prompt was landing on the generic
except Exception branch (exit 2 with rich traceback) instead of
the exit-130 interrupt path. Root cause: typer 0.15+ vendored
click under typer._click, so typer.Abort and the standalone
click.exceptions.Abort are distinct classes. The interrupt-branch
catch only listed the standalone one; every existing 'abort'
test was manually raising click.exceptions.Abort so the miss
was a false-positive guard rail. Widen the catch to
(typer.Abort, click.exceptions.Abort) and declare click as a
first-class dependency (it was only pulled in via uvicorn).
Regression test: raise real typer.Abort() at the confirm step
and assert exit 130 + INTERRUPTED banner.

N3. _looks_like_utf8_text used mime.startswith('text/'), which
caught text/html as well. HTML uploads then bypassed everalgo's
_aparse_html — losing clean_html_for_llm (strips <script>/<style>
/<nav>/<iframe> + HTML comments) and the 1 MiB output cap. A
40 MiB .html with <script> bodies and <!-- prompt injection -->
comments would flow straight into the extraction LLM. Replace
with explicit allowlist {text/plain, text/markdown, text/x-rst,
text/x-markdown}; text/html and any future text/* mime now
default to the parser path. Test matrix asserts text/html →
False (was regressed as True by the earlier commit).

Hermetic env full pytest: 2033 passed / 7 deselected (+6 tests
from these regressions).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(review): close round-4 major + minor + PR body errata

Round-4 review-driven cleanup. Blocker fixes (N1/N2/N3) landed in
561b5fe. This commit closes the remaining CONFIRMED items:

Major:
- J3 MemoryRoot.default() -> resolve() was a breaking public API
  rename this branch introduced (main still has default()). Adds
  default() as a backward-compat alias forwarding to resolve()
  with DeprecationWarning; CHANGELOG entry under Unreleased.
- J4 episode_repo.list_by_owner_after_ts(limit=N) truncates in
  fragment order (== insertion order), NOT newest-first. Docstring
  now spells out the trap so a future caller passing limit for a
  'newest N' window doesn't silently get the oldest N.
- J5.2 TyperPresenter.nothing_to_backfill picked colour via
  'could not be read' in message — a domain wording change
  would silently flip yellow -> green. Signature gains explicit
  scan_failed: bool kwarg; CLI colour-picks off the flag.
- J5.5 phase_header was Protocol-declared but never dispatched
  (run_backfill calls _print_phase_header directly). Removed the
  dead Protocol method + both no-op implementations.
- J6.3 3 inline from everos.core.errors import ... inside
  Phase 1/2/3 preflights promoted to a single top-level import.
- J7 subject-side embed failure was silently exit-0 because
  rows_processed advanced whenever any side wrote. Now: a row with
  a needed side still NULL counts as rows_failed (exit 4 =
  COMPLETED_WITH_FAILURES). Gated on spec.subject_of + row.needs_*
  + row.subject_text so non-Episode tables and subject-empty rows
  don't false-positive.
- J9 test_migration_cross_process.py did NOT actually test cross-
  process (all 5 tests mock memory_root_lock). Renamed to
  test_migration_lock_wiring.py; docstring now scopes it to
  'lock-invocation wiring' and points at test_core/…/test_locking.py
  for real flock coverage.
- J10 Phase 1 lacked the server-running preflight Phase 2/3 have.
  --phase all against a live server would burn Phase 1 embed API
  calls (real cost) before Phase 2 halted with exit 3. Phase 1 now
  probes _probe_ome_lock_available first; regression test in
  test_backfill_preflight.py; upgrade_path integration patches the
  probe so its in-process 'server + backfill' scenario stays valid.

Minor:
- M1 knowledge upload with NUL byte or filename > 255 bytes UTF-8
  used to raise ValueError/OSError at write_bytes → 500 with a
  half-written md left on disk. _safe_original_filename now
  rejects both up front with InvalidInputError (→ 400).
- M2 backfill optimize() now passes cleanup_older_than=timedelta(0)
  so older manifest versions are physically pruned (previous call
  compacted fragments but left the manifest chain on disk).
- M3 verify_business_schemas remediation text used to jump straight
  to 'rm -rf ~/.everos/.index/lancedb'; now walks restart → wipe.
- M5 multimodal/accessor.py capability_build_failed warning added
  so all four provider accessors log symmetrically (was silent).
- M7 test_knowledge_api parser-absence tests call
  parser_available.cache_clear() around the sys.modules patch so
  the lru_cache doesn't strand a stale True/False.
- M8 cascade_handler_embed_skipped (6 handlers) demoted INFO → DEBUG:
  Tier 1 imports were generating N × 6 handler-info lines per md.
- M10.1 test_drift_scenario_would_raise was a tautology (compared
  two hardcoded string sets, never touched the guard). Now
  monkey-patches BUSINESS_SCHEMAS_WITH_VECTOR to a superset and
  reloads _backfill, proving the import-time RuntimeError fires.
- M11 test_cascade_verbose_position subprocess.run calls gain
  env= — scrubs EVEROS_* from the developer environment so the
  same footgun as round-2 B1 doesn't re-appear inside subprocesses.
- M14 health() -> dict degraded the OpenAPI schema to
  additionalProperties: true. Introduce HealthResponse +
  HealthCapabilities Pydantic models so clients get real field
  shape; docs/openapi.json regenerated.
- M16 routes/knowledge.py:_require_knowledge_capabilities docstring
  claimed cascade.registry.build_handlers still gates
  knowledge_topic/knowledge_document, contradicting
  registry.py:177-194 (gate removed there, moved to HTTP layer).
  Rewritten to describe the current design accurately.

Hermetic env full pytest: 2037 passed / 7 deselected.

Explicitly deferred to followup:
- J1 lazy multimodal client (needs everalgo signature change)
- J2 tier definition (knowledge = Tier 3 whole)
- J5.1/3/4 broader presentation-split refactor
- J6.1/2 backfill dispatch and _backfill_table refactor
- J8 Phase 1 keyset pagination for bulk migration OOM
- M4 flock timeout/waiting log/re-entry (core/persistence refactor)
- M6 UTF-8 codec strategy (BOM/UTF-16/GBK)
- M9 count_by_owner monotonicity (latent, INTERVAL=1 short-circuits)
- M13 --phase all multi-phase combined-outcome test coverage
- M15 PR-marker rationale comments (16 occurrences, all inert)

M12 was refuted (both event names exist).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-07-29 11:05:23 +08:00

757 lines
25 KiB
Python

"""End-to-end memorize integration tests.
Drives ``service.memorize.memorize()`` with a ``FakeLLMClient`` so the
full chain (ingest → boundary → user / agent pipeline → md + OME emit)
runs without real LLM calls. Each test isolates state by:
- redirecting ``MemoryRoot.resolve()`` to a ``tmp_path``
- resetting service-layer lazy singletons
- starting / stopping a per-test ``OfflineEngine``
- patching ``get_llm_client`` (boundary + strategies) onto a fake
OME strategies (atomic / foresight) are silenced via ``mock_aextract`` so
this test focuses on the synchronous boundary + pipeline + md path —
strategy dispatch correctness already has its own coverage in
``test_ome_strategies_integration.py``.
"""
from __future__ import annotations
import importlib
import json
import sqlite3
from collections.abc import AsyncIterator, Callable
from pathlib import Path
from typing import Any
from unittest.mock import AsyncMock
import pytest
import pytest_asyncio
from everalgo.llm.types import ChatMessage as LLMChatMessage
from everalgo.llm.types import ChatResponse
from everalgo.testing.fake_llm import FakeLLMClient
from sqlmodel import SQLModel
from everos.core.persistence import MemoryRoot
from everos.service.memorize import MemorizeResult, memorize
# ---------------------------------------------------------------------------
# Canned LLM responses
# ---------------------------------------------------------------------------
def _boundary_response(boundaries: list[int]) -> str:
"""Build a ``detect_boundaries`` JSON response (algo schema)."""
payload = {
"reasoning": "test",
"boundaries": boundaries,
"should_wait": False,
}
return json.dumps(payload)
def _episode_response(title: str = "Test Subject", content: str = "Test body") -> str:
"""Build an ``EpisodeExtractor`` JSON response (algo schema)."""
return json.dumps({"title": title, "content": content})
def _make_fake_llm(
boundary_responses: list[list[int]] | None = None,
*,
episode_title: str = "Test Subject",
episode_content: str = "Test body",
) -> FakeLLMClient:
"""Build a ``FakeLLMClient`` that dispatches by prompt fingerprint.
Pops one ``boundaries=...`` from ``boundary_responses`` per boundary
prompt seen; every episode prompt returns the same canned
``{title, content}``.
"""
boundary_queue: list[list[int]] = list(boundary_responses or [])
def handler(messages: list[LLMChatMessage], **_: Any) -> ChatResponse:
prompt = messages[0].content
if "boundaries" in prompt.lower() or "memcell" in prompt.lower():
cuts = boundary_queue.pop(0) if boundary_queue else []
return ChatResponse(content=_boundary_response(cuts), model="fake")
# Fall through to episode (also catches atomic/foresight prompts —
# they'll return success-but-empty in their mocked extractor below).
return ChatResponse(
content=_episode_response(episode_title, episode_content),
model="fake",
)
return FakeLLMClient(handler=handler)
# ---------------------------------------------------------------------------
# Shared setup fixture
# ---------------------------------------------------------------------------
@pytest_asyncio.fixture
async def memorize_env(
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> AsyncIterator[Callable[..., AsyncMock]]:
"""Yield a builder that configures a clean memorize environment.
Usage::
async def test_x(memorize_env):
await memorize_env(mode="chat", fake_llm=_make_fake_llm([...]))
outcome = await memorize({"session_id": "s", "messages": [...]})
The builder must be called exactly once per test (it primes singletons
+ starts the OME engine). Teardown stops the engine and disposes the
sqlite engine.
"""
monkeypatch.setattr(
MemoryRoot, "resolve", classmethod(lambda cls: MemoryRoot(root=tmp_path))
)
(tmp_path / ".index" / "sqlite").mkdir(parents=True, exist_ok=True)
(tmp_path / "ome.toml").write_text("# test\n")
svc = importlib.import_module("everos.service.memorize")
af_mod = importlib.import_module("everos.memory.strategies.extract_atomic_facts")
fs_mod = importlib.import_module("everos.memory.strategies.extract_foresight")
client_mod = importlib.import_module("everos.component.llm.client")
# Reset singletons.
for attr in (
"_episode_writer",
"_prompt_loader",
"_user_pipeline",
"_agent_pipeline",
"_ome_engine",
):
monkeypatch.setattr(svc, attr, None, raising=False)
monkeypatch.setattr(client_mod, "_llm_client", None, raising=False)
monkeypatch.setattr(af_mod, "_writer", None, raising=False)
monkeypatch.setattr(fs_mod, "_writer", None, raising=False)
started: dict[str, Any] = {"engine": None, "sqlite_engine": None}
async def _setup(
*,
mode: str = "chat",
fake_llm: FakeLLMClient,
hard_token_limit: int = 65536,
hard_msg_limit: int = 500,
) -> None:
# Provide a non-None API key + base_url so get_llm_client doesn't
# raise; we replace the cached singleton with our fake right after.
monkeypatch.setenv("EVEROS_MEMORIZE__MODE", mode)
monkeypatch.setenv("EVEROS_LLM__API_KEY", "fake-key")
monkeypatch.setenv("EVEROS_LLM__BASE_URL", "https://fake.example.com")
monkeypatch.setenv(
"EVEROS_BOUNDARY_DETECTION__HARD_TOKEN_LIMIT", str(hard_token_limit)
)
monkeypatch.setenv(
"EVEROS_BOUNDARY_DETECTION__HARD_MSG_LIMIT", str(hard_msg_limit)
)
from everos.config import load_settings
load_settings.cache_clear()
# Replace the cached client singleton with our fake so get_llm_client
# returns the fake on subsequent calls.
monkeypatch.setattr(client_mod, "_llm_client", fake_llm)
# Build sqlite schema.
from everos.infra.persistence.sqlite import dispose_engine, get_engine
db_engine = get_engine()
async with db_engine.begin() as conn:
await conn.run_sync(SQLModel.metadata.create_all)
started["sqlite_engine"] = (get_engine, dispose_engine)
# Mock the OME extractors so the async strategy chain is a no-op
# (the strategy itself still runs; it just sees no facts/foresights).
mock_af = AsyncMock(return_value=[])
mock_fs = AsyncMock(return_value=[])
monkeypatch.setattr(
af_mod,
"AtomicFactExtractor",
lambda *a, **k: type("M", (), {"aextract": mock_af})(),
)
monkeypatch.setattr(
fs_mod,
"ForesightExtractor",
lambda *a, **k: type("M", (), {"aextract": mock_fs})(),
)
engine = svc._get_engine()
await engine.start()
started["engine"] = engine
yield _setup
if started["engine"] is not None:
await started["engine"].stop()
if started["sqlite_engine"] is not None:
_, dispose = started["sqlite_engine"]
await dispose()
# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------
def _msg(
role: str,
content: str,
*,
sender_id: str = "u_alice",
timestamp: int = 1_700_000_000_000,
tool_calls: list[dict] | None = None,
tool_call_id: str | None = None,
) -> dict[str, Any]:
out: dict[str, Any] = {
"sender_id": sender_id,
"role": role,
"content": content,
"timestamp": timestamp,
}
if tool_calls is not None:
out["tool_calls"] = tool_calls
if tool_call_id is not None:
out["tool_call_id"] = tool_call_id
return out
def _user(content: str, ts: int, *, sender: str = "u_alice") -> dict[str, Any]:
return _msg("user", content, sender_id=sender, timestamp=ts)
def _assistant(content: str, ts: int, *, sender: str = "assistant") -> dict[str, Any]:
return _msg("assistant", content, sender_id=sender, timestamp=ts)
def _memcell_rows(tmp_path: Path) -> list[sqlite3.Row]:
db = tmp_path / ".index" / "sqlite" / "system.db"
if not db.is_file():
return []
conn = sqlite3.connect(db)
conn.row_factory = sqlite3.Row
try:
return list(conn.execute("SELECT * FROM memcell ORDER BY timestamp"))
finally:
conn.close()
def _buffer_count(tmp_path: Path) -> int:
db = tmp_path / ".index" / "sqlite" / "system.db"
if not db.is_file():
return 0
conn = sqlite3.connect(db)
try:
return conn.execute(
"SELECT COUNT(*) FROM unprocessed_buffer WHERE track='memorize'"
).fetchone()[0]
finally:
conn.close()
def _episode_paths(tmp_path: Path) -> list[Path]:
base = tmp_path / "default_app" / "default_project" / "users"
return sorted(base.rglob("episode-*.md"))
# ---------------------------------------------------------------------------
# Happy path baseline
# ---------------------------------------------------------------------------
async def test_chat_baseline_two_msgs_one_cell(
tmp_path: Path,
memorize_env: Callable[..., Any],
) -> None:
"""2 messages → flush forces them into 1 cell + 1 Episode + 1 memcell row."""
fake = _make_fake_llm(boundary_responses=[[]]) # no internal cuts
await memorize_env(mode="chat", fake_llm=fake)
payload = {
"session_id": "test_chat_1",
"messages": [
_user("hello", 1_700_000_000_000),
_assistant("hi there", 1_700_000_001_000),
],
}
result = await memorize(payload, is_final=True)
assert isinstance(result, MemorizeResult)
assert result.status == "extracted"
assert result.message_count == 2
rows = _memcell_rows(tmp_path)
assert len(rows) == 1
assert rows[0]["track"] == "memorize"
assert rows[0]["raw_type"] == "Conversation"
# MemCell has no single owner — sender_ids carries the participants.
assert "u_alice" in json.loads(rows[0]["sender_ids_json"])
assert _buffer_count(tmp_path) == 0
md_files = _episode_paths(tmp_path)
assert len(md_files) == 1
body = md_files[0].read_text()
assert "Test Subject" in body
assert "Test body" in body
# ---------------------------------------------------------------------------
# Input-shape boundary cases (6)
# ---------------------------------------------------------------------------
async def test_empty_batch_non_final_is_skipped(
tmp_path: Path, memorize_env: Callable[..., Any]
) -> None:
"""``messages=[]`` + ``is_final=False`` → skipped, no side effects."""
await memorize_env(mode="chat", fake_llm=_make_fake_llm())
result = await memorize(
{"session_id": "test_empty_nonfinal", "messages": []}, is_final=False
)
assert result.status == "accumulated"
assert result.message_count == 0
assert _memcell_rows(tmp_path) == []
assert _episode_paths(tmp_path) == []
async def test_empty_batch_final_drains_empty_buffer(
tmp_path: Path, memorize_env: Callable[..., Any]
) -> None:
"""``messages=[]`` + ``is_final=True`` on virgin session → no cells, no md."""
await memorize_env(mode="chat", fake_llm=_make_fake_llm())
result = await memorize(
{"session_id": "test_empty_final", "messages": []}, is_final=True
)
assert result.status == "accumulated"
assert _memcell_rows(tmp_path) == []
assert _episode_paths(tmp_path) == []
async def test_assistant_only_batch_accumulates(
tmp_path: Path, memorize_env: Callable[..., Any]
) -> None:
"""No role=user message → boundary stage parks everything in buffer."""
fake = _make_fake_llm(boundary_responses=[]) # no LLM call expected
await memorize_env(mode="chat", fake_llm=fake)
result = await memorize(
{
"session_id": "test_asst_only",
"messages": [
_assistant("hi", 1_700_000_000_000),
_assistant("anyone here?", 1_700_000_001_000),
],
},
is_final=False,
)
assert result.status == "accumulated"
assert _memcell_rows(tmp_path) == []
assert _buffer_count(tmp_path) == 2 # parked in buffer
async def test_single_user_message_accumulates(
tmp_path: Path, memorize_env: Callable[..., Any]
) -> None:
"""Single user msg → boundary returns no cells (need conversation) → buffer it."""
fake = _make_fake_llm(boundary_responses=[[]]) # boundary called, no cuts
await memorize_env(mode="chat", fake_llm=fake)
result = await memorize(
{
"session_id": "test_single",
"messages": [_user("hello?", 1_700_000_000_000)],
},
is_final=False,
)
assert result.status == "accumulated"
assert _memcell_rows(tmp_path) == []
assert _buffer_count(tmp_path) == 1
async def test_chat_mode_filters_tool_messages(
tmp_path: Path, memorize_env: Callable[..., Any]
) -> None:
"""Chat mode drops ``role=tool`` + assistant-with-tool_calls pre-boundary."""
fake = _make_fake_llm(boundary_responses=[[]])
await memorize_env(mode="chat", fake_llm=fake)
result = await memorize(
{
"session_id": "test_chat_filter",
"messages": [
_user("debug this", 1_700_000_000_000),
_msg(
"assistant",
"calling tool",
timestamp=1_700_000_001_000,
tool_calls=[
{
"id": "c1",
"type": "function",
"function": {"name": "x", "arguments": "{}"},
}
],
),
_msg(
"tool",
"result",
sender_id="tool",
timestamp=1_700_000_002_000,
tool_call_id="c1",
),
_assistant("here's the answer", 1_700_000_003_000),
],
},
is_final=True,
)
# After filter: 1 user + 1 assistant text = 2 msgs → 1 cell on flush.
assert result.status == "extracted"
rows = _memcell_rows(tmp_path)
assert len(rows) == 1
ids = json.loads(rows[0]["message_ids_json"])
assert len(ids) == 2 # tool + assistant-with-tool_calls dropped
async def test_duplicate_message_id_dedup_across_adds(
tmp_path: Path, memorize_env: Callable[..., Any]
) -> None:
"""Same message replayed across two ``/add`` calls is deduped by message_id."""
fake = _make_fake_llm(boundary_responses=[[], []]) # 2 boundary calls, both empty
await memorize_env(mode="chat", fake_llm=fake)
# message_id is derived from (session_id, ts_ms, idx); same payload twice
# produces the same id, so the second add should be a no-op insert.
payload = {
"session_id": "test_dedup",
"messages": [
_user("hi", 1_700_000_000_000),
_assistant("hi back", 1_700_000_001_000),
],
}
await memorize(payload, is_final=False)
await memorize(payload, is_final=False) # replay
await memorize({"session_id": "test_dedup", "messages": []}, is_final=True)
rows = _memcell_rows(tmp_path)
assert len(rows) == 1
ids = json.loads(rows[0]["message_ids_json"])
assert len(ids) == 2 # not 4 — dedup worked
assert len(set(ids)) == 2 # unique
# ---------------------------------------------------------------------------
# Hard-limit cases (2)
# ---------------------------------------------------------------------------
async def test_hard_msg_limit_force_split(
tmp_path: Path, memorize_env: Callable[..., Any]
) -> None:
"""Exceeding ``hard_msg_limit`` triggers a force-split before the LLM call."""
fake = _make_fake_llm(boundary_responses=[[]]) # LLM call after force-split
# hard_msg_limit=3 → batch of 5 msgs forces ~1 split before LLM.
await memorize_env(
mode="chat", fake_llm=fake, hard_msg_limit=3, hard_token_limit=10_000
)
msgs = [
_user(f"u{i}", 1_700_000_000_000 + i * 1000, sender="u_alice")
if i % 2 == 0
else _assistant(f"a{i}", 1_700_000_000_000 + i * 1000)
for i in range(5)
]
result = await memorize(
{"session_id": "test_hardmsg", "messages": msgs}, is_final=True
)
assert result.status == "extracted"
rows = _memcell_rows(tmp_path)
# Force-split + LLM final → at least 2 cells (force + remaining).
assert len(rows) >= 2
async def test_hard_token_limit_force_split(
tmp_path: Path, memorize_env: Callable[..., Any]
) -> None:
"""Exceeding ``hard_token_limit`` triggers a force-split (token-based)."""
fake = _make_fake_llm(boundary_responses=[[]])
# Very small token budget → even tiny content triggers force-split.
await memorize_env(
mode="chat", fake_llm=fake, hard_msg_limit=500, hard_token_limit=20
)
msgs = [
_user("a" * 200, 1_700_000_000_000, sender="u_alice"),
_assistant("b" * 200, 1_700_000_001_000),
_user("c" * 200, 1_700_000_002_000, sender="u_alice"),
_assistant("d" * 200, 1_700_000_003_000),
]
result = await memorize(
{"session_id": "test_hardtok", "messages": msgs}, is_final=True
)
assert result.status == "extracted"
assert len(_memcell_rows(tmp_path)) >= 2
# ---------------------------------------------------------------------------
# Flush state-machine cases (4)
# ---------------------------------------------------------------------------
async def test_flush_on_virgin_session_is_noop(
tmp_path: Path, memorize_env: Callable[..., Any]
) -> None:
"""Flush a session that never received ``/add`` — should not crash."""
await memorize_env(mode="chat", fake_llm=_make_fake_llm())
result = await memorize(
{"session_id": "test_virgin_flush", "messages": []}, is_final=True
)
assert result.status == "accumulated"
assert _memcell_rows(tmp_path) == []
async def test_add_then_flush_then_add(
tmp_path: Path, memorize_env: Callable[..., Any]
) -> None:
"""After flush drains the buffer, a follow-up ``/add`` still works."""
fake = _make_fake_llm(boundary_responses=[[], []])
await memorize_env(mode="chat", fake_llm=fake)
sid = "test_add_flush_add"
await memorize(
{
"session_id": sid,
"messages": [
_user("first", 1_700_000_000_000),
_assistant("ack", 1_700_000_001_000),
],
},
is_final=False,
)
await memorize({"session_id": sid, "messages": []}, is_final=True)
rows_after_flush_1 = len(_memcell_rows(tmp_path))
assert rows_after_flush_1 == 1
# Second turn after the flush.
await memorize(
{
"session_id": sid,
"messages": [
_user("second turn", 1_700_000_010_000),
_assistant("ok", 1_700_000_011_000),
],
},
is_final=True,
)
assert len(_memcell_rows(tmp_path)) == 2 # cumulative
async def test_consecutive_flushes_second_is_noop(
tmp_path: Path, memorize_env: Callable[..., Any]
) -> None:
"""Flush twice in a row — second call finds empty buffer, no-ops."""
fake = _make_fake_llm(boundary_responses=[[]])
await memorize_env(mode="chat", fake_llm=fake)
sid = "test_double_flush"
await memorize(
{
"session_id": sid,
"messages": [
_user("hi", 1_700_000_000_000),
_assistant("ok", 1_700_000_001_000),
],
},
is_final=False,
)
res1 = await memorize({"session_id": sid, "messages": []}, is_final=True)
res2 = await memorize({"session_id": sid, "messages": []}, is_final=True)
assert res1.status == "extracted"
assert res2.status == "accumulated" # nothing left
assert len(_memcell_rows(tmp_path)) == 1
async def test_flush_drains_assistant_only_buffer(
tmp_path: Path, memorize_env: Callable[..., Any]
) -> None:
"""Buffer with only assistant messages: flush still forces them into a cell."""
fake = _make_fake_llm(boundary_responses=[[]])
await memorize_env(mode="chat", fake_llm=fake)
sid = "test_asst_then_flush"
# Two assistant-only adds → both park in buffer.
await memorize(
{
"session_id": sid,
"messages": [_assistant("a1", 1_700_000_000_000)],
},
is_final=False,
)
await memorize(
{
"session_id": sid,
"messages": [_assistant("a2", 1_700_000_001_000)],
},
is_final=False,
)
assert _buffer_count(tmp_path) == 2
# Add a user message + flush — boundary should now run.
result = await memorize(
{
"session_id": sid,
"messages": [_user("anyone there?", 1_700_000_002_000)],
},
is_final=True,
)
assert result.status == "extracted"
assert _buffer_count(tmp_path) == 0
# ---------------------------------------------------------------------------
# Multi-session cases (2)
# ---------------------------------------------------------------------------
async def test_two_sessions_are_isolated(
tmp_path: Path, memorize_env: Callable[..., Any]
) -> None:
"""Two session_ids share the engine but their buffers / cells stay separate."""
fake = _make_fake_llm(boundary_responses=[[], []]) # 1 per session
await memorize_env(mode="chat", fake_llm=fake)
await memorize(
{
"session_id": "sess_A",
"messages": [
_user("hi from A", 1_700_000_000_000, sender="u_alice"),
_assistant("ack A", 1_700_000_001_000),
],
},
is_final=True,
)
await memorize(
{
"session_id": "sess_B",
"messages": [
_user("hi from B", 1_700_000_010_000, sender="u_bob"),
_assistant("ack B", 1_700_000_011_000),
],
},
is_final=True,
)
rows = _memcell_rows(tmp_path)
assert len(rows) == 2
sessions = sorted(r["session_id"] for r in rows)
assert sessions == ["sess_A", "sess_B"]
# MemCell has no single owner — sender_ids carries who participated.
senders = {r["session_id"]: json.loads(r["sender_ids_json"]) for r in rows}
assert "u_alice" in senders["sess_A"]
assert "u_bob" in senders["sess_B"]
async def test_same_session_multi_add_concatenates(
tmp_path: Path, memorize_env: Callable[..., Any]
) -> None:
"""Multiple adds on the same session accumulate in one buffer until flushed."""
fake = _make_fake_llm(boundary_responses=[[], [], []])
await memorize_env(mode="chat", fake_llm=fake)
sid = "test_multi_add"
for i in range(3):
await memorize(
{
"session_id": sid,
"messages": [
_user(f"u{i}", 1_700_000_000_000 + i * 2000),
_assistant(f"a{i}", 1_700_000_001_000 + i * 2000),
],
},
is_final=False,
)
# Buffer should have 6 messages now (no boundary cuts).
assert _buffer_count(tmp_path) == 6
result = await memorize({"session_id": sid, "messages": []}, is_final=True)
assert result.status == "extracted"
rows = _memcell_rows(tmp_path)
assert len(rows) == 1 # one cell from the flush
ids = json.loads(rows[0]["message_ids_json"])
assert len(ids) == 6 # all 6 messages folded in
# ---------------------------------------------------------------------------
# Tracing: the add/flush span nests extract + persist in one trace
# ---------------------------------------------------------------------------
async def test_flush_produces_nested_trace(
tmp_path: Path,
memorize_env: Callable[..., Any],
) -> None:
"""A real flush that extracts one Episode emits everos.memory.flush with
everos.extract + everos.persist.markdown as children of one trace."""
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
from opentelemetry.sdk.trace.export.in_memory_span_exporter import (
InMemorySpanExporter,
)
from everos.config.settings import ObservabilitySettings
from everos.core.observability.tracing import (
force_flush,
init_tracing,
shutdown_tracing,
)
fake = _make_fake_llm(boundary_responses=[[]])
await memorize_env(mode="chat", fake_llm=fake)
exporter = InMemorySpanExporter()
shutdown_tracing()
init_tracing(
ObservabilitySettings(enabled=True, endpoint="http://collector.invalid"),
span_processor=SimpleSpanProcessor(exporter),
)
try:
payload = {
"session_id": "trace_sess",
"messages": [
_user("hello", 1_700_000_000_000),
_assistant("hi there", 1_700_000_001_000),
],
}
result = await memorize(payload, is_final=True)
assert result.status == "extracted"
force_flush()
finally:
shutdown_tracing()
spans = {s.name: s for s in exporter.get_finished_spans()}
assert "everos.memory.flush" in spans
assert "everos.extract" in spans
assert "everos.persist.markdown" in spans
root = spans["everos.memory.flush"]
extract = spans["everos.extract"]
persist = spans["everos.persist.markdown"]
# One trace: all three share the flush span's trace id.
trace_id = root.context.trace_id
assert extract.context.trace_id == trace_id
assert persist.context.trace_id == trace_id
# flush is the root; extract / persist hang beneath it (not siblings).
assert root.parent is None
assert extract.parent is not None
assert persist.parent is not None