358 lines
12 KiB
Python
358 lines
12 KiB
Python
"""Regression tests for Honcho startup fail-open behavior."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import threading
|
|
import time
|
|
from types import SimpleNamespace
|
|
|
|
from plugins.memory.honcho import HonchoMemoryProvider
|
|
|
|
|
|
class _FakeHonchoConfig(SimpleNamespace):
|
|
def resolve_session_name(self, **kwargs):
|
|
return "test-session"
|
|
|
|
|
|
def _configured_hybrid_config() -> _FakeHonchoConfig:
|
|
return _FakeHonchoConfig(
|
|
enabled=True,
|
|
api_key=None,
|
|
base_url="http://127.0.0.1:8000",
|
|
recall_mode="hybrid",
|
|
init_on_session_start=False,
|
|
dialectic_depth=1,
|
|
dialectic_depth_levels=None,
|
|
reasoning_heuristic=True,
|
|
reasoning_level_cap="high",
|
|
context_tokens=None,
|
|
message_max_chars=25000,
|
|
session_strategy="per-directory",
|
|
)
|
|
|
|
|
|
def _configured_tools_config(*, init_on_session_start: bool = False) -> _FakeHonchoConfig:
|
|
cfg = _configured_hybrid_config()
|
|
cfg.recall_mode = "tools"
|
|
cfg.init_on_session_start = init_on_session_start
|
|
return cfg
|
|
|
|
|
|
def test_honcho_hybrid_initialize_returns_without_waiting_for_session_init(monkeypatch):
|
|
"""Slow Honcho session creation must not block agent startup."""
|
|
provider = HonchoMemoryProvider()
|
|
cfg = _configured_hybrid_config()
|
|
started = threading.Event()
|
|
release = threading.Event()
|
|
|
|
monkeypatch.setattr(
|
|
"plugins.memory.honcho.client.HonchoClientConfig.from_global_config",
|
|
lambda: cfg,
|
|
)
|
|
|
|
def slow_session_init(self, cfg, session_id, **kwargs):
|
|
started.set()
|
|
release.wait(timeout=5)
|
|
self._session_initialized = True
|
|
|
|
monkeypatch.setattr(HonchoMemoryProvider, "_do_session_init", slow_session_init)
|
|
|
|
start = time.perf_counter()
|
|
provider.initialize("session-1", platform="cli")
|
|
elapsed = time.perf_counter() - start
|
|
|
|
try:
|
|
assert elapsed < 0.5
|
|
assert started.wait(timeout=1)
|
|
assert provider._session_key == "test-session"
|
|
finally:
|
|
release.set()
|
|
init_thread = getattr(provider, "_init_thread", None)
|
|
if init_thread:
|
|
init_thread.join(timeout=1)
|
|
|
|
|
|
def test_honcho_background_init_rechecks_state_after_lock_race():
|
|
"""Startup should not spawn/crash if init completes while waiting for lock."""
|
|
provider = HonchoMemoryProvider()
|
|
provider._config = _configured_hybrid_config()
|
|
provider._lazy_init_kwargs = {"platform": "cli"}
|
|
provider._lazy_init_session_id = "session-1"
|
|
|
|
class RacingLock:
|
|
def __enter__(self):
|
|
provider._session_initialized = True
|
|
provider._lazy_init_kwargs = None
|
|
return self
|
|
|
|
def __exit__(self, exc_type, exc, tb):
|
|
return False
|
|
|
|
provider._init_lock = RacingLock()
|
|
|
|
provider._start_session_init_background()
|
|
|
|
assert provider._init_thread is None
|
|
assert provider._session_initialized is True
|
|
|
|
|
|
def test_honcho_prefetch_returns_without_waiting_for_first_context_fetch():
|
|
"""First-turn context injection must fail open when Honcho is slow."""
|
|
provider = HonchoMemoryProvider()
|
|
cfg = _configured_hybrid_config()
|
|
cfg.timeout = 0.1
|
|
fetch_started = threading.Event()
|
|
|
|
class SlowManager:
|
|
def get_prefetch_context(self, session_key, user_message=None):
|
|
fetch_started.set()
|
|
time.sleep(5)
|
|
return {"representation": "late"}
|
|
|
|
def prefetch_context(self, session_key, user_message=None):
|
|
fetch_started.set()
|
|
|
|
def pop_context_result(self, session_key):
|
|
return {}
|
|
|
|
provider._config = cfg
|
|
provider._manager = SlowManager()
|
|
provider._session_key = "test-session"
|
|
provider._session_initialized = True
|
|
provider._turn_count = 1
|
|
|
|
start = time.perf_counter()
|
|
result = provider.prefetch("what do you know about me?")
|
|
elapsed = time.perf_counter() - start
|
|
|
|
assert result == ""
|
|
assert elapsed < 0.5
|
|
assert fetch_started.is_set()
|
|
|
|
|
|
|
|
def test_honcho_sync_turn_does_not_start_network_write_before_session_init():
|
|
"""Session-end sync must not create a blocking writer before init finishes."""
|
|
provider = HonchoMemoryProvider()
|
|
cfg = _configured_hybrid_config()
|
|
get_started = threading.Event()
|
|
background_started = threading.Event()
|
|
release_init = threading.Event()
|
|
|
|
class SlowManager:
|
|
def get_or_create(self, session_key):
|
|
get_started.set()
|
|
time.sleep(5)
|
|
return SimpleNamespace()
|
|
|
|
def _flush_session(self, session):
|
|
pass
|
|
|
|
provider._config = cfg
|
|
provider._manager = SlowManager()
|
|
provider._session_key = "test-session"
|
|
provider._session_initialized = False
|
|
provider._start_session_init_background = background_started.set
|
|
provider._init_thread = threading.Thread(
|
|
target=lambda: release_init.wait(timeout=5), daemon=True
|
|
)
|
|
provider._init_thread.start()
|
|
|
|
try:
|
|
provider.sync_turn("hello", "world")
|
|
|
|
assert provider._sync_thread is None
|
|
assert background_started.is_set()
|
|
assert not get_started.wait(timeout=0.1)
|
|
finally:
|
|
release_init.set()
|
|
provider._init_thread.join(timeout=1)
|
|
|
|
|
|
def test_honcho_sync_turn_waits_for_full_background_startup(monkeypatch):
|
|
"""Manager assignment alone is not readiness while background init continues."""
|
|
provider = HonchoMemoryProvider()
|
|
cfg = _configured_hybrid_config()
|
|
session_created = threading.Event()
|
|
migration_started = threading.Event()
|
|
release_migration = threading.Event()
|
|
get_calls = []
|
|
|
|
class StartupManager:
|
|
def __init__(self, *args, **kwargs):
|
|
pass
|
|
|
|
def get_or_create(self, session_key):
|
|
get_calls.append(session_key)
|
|
session_created.set()
|
|
return SimpleNamespace(messages=[])
|
|
|
|
def migrate_memory_files(self, session_key, mem_dir):
|
|
migration_started.set()
|
|
release_migration.wait(timeout=5)
|
|
|
|
def prefetch_context(self, session_key, user_message=None):
|
|
pass
|
|
|
|
def _flush_session(self, session):
|
|
pass
|
|
|
|
monkeypatch.setattr(
|
|
"plugins.memory.honcho.client.HonchoClientConfig.from_global_config",
|
|
lambda: cfg,
|
|
)
|
|
monkeypatch.setattr("plugins.memory.honcho.client.get_honcho_client", lambda cfg: object())
|
|
monkeypatch.setattr("plugins.memory.honcho.session.HonchoSessionManager", StartupManager)
|
|
|
|
provider.initialize("session-1", platform="cli")
|
|
try:
|
|
assert session_created.wait(timeout=1)
|
|
assert migration_started.wait(timeout=1)
|
|
assert provider._manager is not None
|
|
assert provider._session_initialized is False
|
|
|
|
provider.sync_turn("hello", "world")
|
|
|
|
assert provider._sync_thread is None
|
|
assert get_calls == ["test-session"]
|
|
finally:
|
|
release_migration.set()
|
|
init_thread = getattr(provider, "_init_thread", None)
|
|
if init_thread:
|
|
init_thread.join(timeout=1)
|
|
if provider._prefetch_thread:
|
|
provider._prefetch_thread.join(timeout=1)
|
|
|
|
assert provider._session_initialized is True
|
|
|
|
|
|
def test_honcho_system_prompt_advertises_active_while_background_init_runs(monkeypatch):
|
|
"""Prompt metadata should not require a completed network session."""
|
|
provider = HonchoMemoryProvider()
|
|
cfg = _configured_hybrid_config()
|
|
release = threading.Event()
|
|
|
|
monkeypatch.setattr(
|
|
"plugins.memory.honcho.client.HonchoClientConfig.from_global_config",
|
|
lambda: cfg,
|
|
)
|
|
|
|
def slow_session_init(self, cfg, session_id, **kwargs):
|
|
release.wait(timeout=5)
|
|
self._session_initialized = True
|
|
|
|
monkeypatch.setattr(HonchoMemoryProvider, "_do_session_init", slow_session_init)
|
|
|
|
provider.initialize("session-1", platform="cli")
|
|
try:
|
|
prompt = provider.system_prompt_block()
|
|
assert "Honcho Memory" in prompt
|
|
assert "hybrid mode" in prompt
|
|
finally:
|
|
release.set()
|
|
init_thread = getattr(provider, "_init_thread", None)
|
|
if init_thread:
|
|
init_thread.join(timeout=1)
|
|
|
|
|
|
def test_honcho_tools_eager_init_still_ready_on_return(monkeypatch):
|
|
"""tools + initOnSessionStart=true keeps its ready-on-return contract."""
|
|
provider = HonchoMemoryProvider()
|
|
cfg = _configured_tools_config(init_on_session_start=True)
|
|
|
|
monkeypatch.setattr(
|
|
"plugins.memory.honcho.client.HonchoClientConfig.from_global_config",
|
|
lambda: cfg,
|
|
)
|
|
|
|
def fake_session_init(self, cfg, session_id, **kwargs):
|
|
self._manager = SimpleNamespace()
|
|
self._session_key = "test-session"
|
|
self._session_initialized = True
|
|
|
|
monkeypatch.setattr(HonchoMemoryProvider, "_do_session_init", fake_session_init)
|
|
|
|
provider.initialize("session-1", platform="cli")
|
|
|
|
assert provider._session_initialized is True
|
|
assert provider._manager is not None
|
|
assert provider._init_thread is None
|
|
|
|
|
|
def test_honcho_tools_eager_init_failure_does_not_leave_ready_manager(monkeypatch):
|
|
"""Failed eager tools startup must not leave hooks seeing a ready session."""
|
|
provider = HonchoMemoryProvider()
|
|
cfg = _configured_tools_config(init_on_session_start=True)
|
|
|
|
monkeypatch.setattr(
|
|
"plugins.memory.honcho.client.HonchoClientConfig.from_global_config",
|
|
lambda: cfg,
|
|
)
|
|
|
|
def failing_session_init(self, cfg, session_id, **kwargs):
|
|
self._manager = SimpleNamespace()
|
|
self._session_key = "test-session"
|
|
raise RuntimeError("boom")
|
|
|
|
monkeypatch.setattr(HonchoMemoryProvider, "_do_session_init", failing_session_init)
|
|
|
|
provider.initialize("session-1", platform="cli")
|
|
assert provider._session_initialized is False
|
|
assert provider._manager is None
|
|
|
|
background_started = threading.Event()
|
|
provider._start_session_init_background = background_started.set
|
|
provider.sync_turn("hello", "world")
|
|
provider.on_memory_write("add", "user", "prefers safe Honcho startup")
|
|
|
|
assert provider._sync_thread is None
|
|
assert not background_started.is_set()
|
|
|
|
result = json.loads(provider.handle_tool_call("honcho_profile", {"peer": "user"}))
|
|
assert "could not be initialized" in result["error"]
|
|
assert provider._manager is None
|
|
|
|
|
|
def test_honcho_tools_lazy_hooks_do_not_prestart_background_init(monkeypatch):
|
|
"""tools lazy mode lets the first tool call own session initialization."""
|
|
provider = HonchoMemoryProvider()
|
|
cfg = _configured_tools_config(init_on_session_start=False)
|
|
|
|
monkeypatch.setattr(
|
|
"plugins.memory.honcho.client.HonchoClientConfig.from_global_config",
|
|
lambda: cfg,
|
|
)
|
|
|
|
provider.initialize("session-1", platform="cli")
|
|
background_started = threading.Event()
|
|
provider._start_session_init_background = background_started.set
|
|
|
|
provider.prefetch("what do you know?")
|
|
provider.queue_prefetch("what do you know?")
|
|
provider.sync_turn("hello", "world")
|
|
provider.on_memory_write("add", "user", "prefers fail-open memory")
|
|
|
|
assert not background_started.is_set()
|
|
assert provider._session_initialized is False
|
|
|
|
class ToolManager:
|
|
def get_peer_card(self, session_key, peer="user"):
|
|
return ["ready"]
|
|
|
|
init_calls = []
|
|
|
|
def fake_session_init(self, cfg, session_id, **kwargs):
|
|
init_calls.append(session_id)
|
|
self._manager = ToolManager()
|
|
self._session_key = "test-session"
|
|
self._session_initialized = True
|
|
|
|
monkeypatch.setattr(HonchoMemoryProvider, "_do_session_init", fake_session_init)
|
|
|
|
result = json.loads(provider.handle_tool_call("honcho_profile", {"peer": "user"}))
|
|
|
|
assert result == {"result": ["ready"]}
|
|
assert init_calls == ["session-1"]
|
|
assert not background_started.is_set()
|