Skip to content

armgit / avibe

Public Imported from GitHub
0

Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.

fix(steer): keep Send Now usable when optional Memory runtime is unavailable (#2090)

rkrkrkkfac123a6482e
diff --git a/core/session_turns.py b/core/session_turns.py
index 0a6b8e729..0cf25d3c8 100644
--- a/core/session_turns.py
+++ b/core/session_turns.py
@@ -2690,21 +2690,34 @@ class SessionTurnManager:
def _compatible_steer_memory_authority(self, turn_id: str, deliveries: list[dict[str, Any]]) -> bool:
if not bool(getattr(getattr(self.controller.config, "memory", None), "enabled", False)):
return True
- from avibe_memory.admission import InboundTurnFacts
+
+ memory_available = (
+ getattr(self.controller, "memory_runtime", None) is not None
+ and getattr(self.controller, "_memory_implementation_error", None) is None
+ )
+ if memory_available:
+ from avibe_memory.admission import InboundTurnFacts
+ admission = self.controller._memory_admission()
+
+ def admits(owner: dict[str, Any]) -> bool:
+ return admission.admits(InboundTurnFacts(**owner))
+ else:
+
+ def admits(_owner: dict[str, Any]) -> bool:
+ return False
with self._sqlite_engine().connect() as conn:
initial = delivery_store.delivery_for_turn(conn, turn_id)
active = delivery_store.execution_delivery_payload(conn, initial) if initial else {}
incoming = [delivery_store.execution_delivery_payload(conn, row) for row in deliveries]
payloads = [active, *incoming]
- admission = self.controller._memory_admission()
delegated = [delivery_store.memory_owner_from_payload(payload)
for payload in payloads if payload.get("source") == "harness"]
# Revoking a binding must not let foreign input enter a native Turn whose
# existing scope could become readable again when access is restored.
has_scope = active.get("session_id") in getattr(self.controller, "_memory_scopes_by_session", {})
- if not any(owner and (has_scope or admission.admits(InboundTurnFacts(**owner))) for owner in delegated):
- return True # Human-only and Memory-ineligible group steering keep their policy.
+ if not any(owner and (has_scope or admits(owner)) for owner in delegated):
+ return True # Human-only and Memory-ineligible steering keep their policy.
authority = delivery_store.memory_authority_for_payload(active)
return all(delivery_store.memory_authority_for_payload(payload) == authority for payload in incoming)
diff --git a/tests/test_session_delivery_fsm.py b/tests/test_session_delivery_fsm.py
index 9d18d4336..d66d763be 100644
--- a/tests/test_session_delivery_fsm.py
+++ b/tests/test_session_delivery_fsm.py
@@ -4,6 +4,7 @@ import asyncio
import gc
import json
import sqlite3
+import sys
import threading
from concurrent.futures import ThreadPoolExecutor
from contextlib import asynccontextmanager, closing
@@ -67,6 +68,10 @@ from storage.models import (
session_turns,
show_session_events,
)
+from vibe.memory_contract import (
+ MemoryImplementationIncompatibleError,
+ MemoryImplementationUnavailableError,
+)
@pytest.fixture
@@ -79,6 +84,8 @@ class _Controller:
self.command_handler = SimpleNamespace(handle_stop=AsyncMock(return_value=True))
self.agent_service = SimpleNamespace(agents={}, _turn_gates={})
self.config = SimpleNamespace(language="en")
+ self.memory_runtime = SimpleNamespace()
+ self._memory_implementation_error = None
self.statuses: list[tuple[str, str]] = []
@staticmethod
@@ -485,6 +492,44 @@ def _row(engine, delivery_id: str) -> dict:
return row
+def _steer_memory_payload(
+ *,
+ source: str,
+ owner: dict[str, object] | None = None,
+ resource_user_context: dict[str, object] | None = None,
+) -> dict[str, object]:
+ metadata: dict[str, object] = {}
+ if owner is not None:
+ message_metadata: dict[str, object] = {"delegated_memory_owner": owner}
+ if resource_user_context is not None:
+ message_metadata["resource_user_context"] = resource_user_context
+ metadata["scheduled_provenance"] = {
+ "platform_specific": {
+ "task_trigger_kind": "watch",
+ "message_metadata": message_metadata,
+ }
+ }
+ return {"session_id": "ses_fsm", "source": source, "metadata": metadata}
+
+
+def _stub_steer_memory_payloads(
+ monkeypatch: pytest.MonkeyPatch,
+ active: dict[str, object],
+ incoming: dict[str, object],
+) -> list[dict[str, object]]:
+ monkeypatch.setattr(
+ delivery_store,
+ "delivery_for_turn",
+ lambda _conn, _turn_id: {"id": "active"},
+ )
+ monkeypatch.setattr(
+ delivery_store,
+ "execution_delivery_payload",
+ lambda _conn, row: active if row["id"] == "active" else row,
+ )
+ return [incoming]
+
+
def _configure_activation_owner(
manager: SessionTurnManager,
registry: RuntimeActivationRegistry,
@@ -1309,6 +1354,174 @@ async def test_steering_memory_check_failure_restores_a_retryable_queue_row(mana
assert queued[0]["current_attempt_id"] is None
+ "implementation_error",
+ [MemoryImplementationUnavailableError("missing"), MemoryImplementationIncompatibleError("incompatible")],
+)
+def test_steer_memory_unavailable_keeps_human_input_independent_of_optional_import(
+ managers,
+ monkeypatch,
+ implementation_error,
+):
+ manager, _other, _engine, _engine_b, _starts = managers
+ manager.controller.config.memory = SimpleNamespace(enabled=True)
+ manager.controller.memory_runtime = None
+ manager.controller._memory_implementation_error = implementation_error
+ manager.controller._memory_admission = Mock(side_effect=AssertionError("Memory admission must not be called"))
+ active = _steer_memory_payload(source="user")
+ incoming = _steer_memory_payload(source="user")
+ incoming["id"] = "incoming"
+ deliveries = _stub_steer_memory_payloads(monkeypatch, active, incoming)
+
+ with patch.dict(sys.modules, {"avibe_memory.admission": None}):
+ assert manager._compatible_steer_memory_authority("turn", deliveries)
+ manager.controller._memory_admission.assert_not_called()
+
+
+ ("incoming_owner", "incoming_resource", "expected"),
+ [
+ ({"platform": "avibe", "user_id": "local", "is_dm": False}, None, True),
+ ({"platform": "avibe", "user_id": "remote:bob", "is_dm": False}, None, True),
+ ({"platform": "avibe", "user_id": "local", "is_dm": False}, {"sub": "other"}, True),
+ ],
+)
+def test_steer_memory_unavailable_keeps_delegated_policy_without_readable_scope(
+ managers,
+ monkeypatch,
+ incoming_owner,
+ incoming_resource,
+ expected,
+):
+ manager, _other, _engine, _engine_b, _starts = managers
+ manager.controller.config.memory = SimpleNamespace(enabled=True)
+ manager.controller.memory_runtime = None
+ manager.controller._memory_implementation_error = MemoryImplementationUnavailableError("missing")
+ manager.controller._memory_scopes_by_session = {}
+ owner = {"platform": "avibe", "user_id": "local", "is_dm": False}
+ resource = {"sub": "local"}
+ active = _steer_memory_payload(
+ source="harness",
+ owner=owner,
+ resource_user_context=resource,
+ )
+ incoming = _steer_memory_payload(
+ source="harness",
+ owner=incoming_owner,
+ resource_user_context=incoming_resource if incoming_resource is not None else resource,
+ )
+ incoming["id"] = "incoming"
+ deliveries = _stub_steer_memory_payloads(monkeypatch, active, incoming)
+
+ assert manager._compatible_steer_memory_authority("turn", deliveries) is expected
+
+
+ ("incoming_owner", "incoming_resource"),
+ [
+ ({"platform": "avibe", "user_id": "remote:bob", "is_dm": False}, None),
+ ({"platform": "avibe", "user_id": "local", "is_dm": False}, {"sub": "other"}),
+ ],
+)
+def test_steer_memory_unavailable_preserves_recorded_scope_boundaries(
+ managers,
+ monkeypatch,
+ incoming_owner,
+ incoming_resource,
+):
+ manager, _other, _engine, _engine_b, _starts = managers
+ manager.controller.config.memory = SimpleNamespace(enabled=True)
+ manager.controller.memory_runtime = None
+ manager.controller._memory_implementation_error = MemoryImplementationUnavailableError("missing")
+ manager.controller._memory_scopes_by_session = {"ses_fsm": object()}
+ owner = {"platform": "avibe", "user_id": "local", "is_dm": False}
+ active = _steer_memory_payload(
+ source="harness",
+ owner=owner,
+ resource_user_context={"sub": "local"},
+ )
+ incoming = _steer_memory_payload(
+ source="harness",
+ owner=incoming_owner,
+ resource_user_context=incoming_resource or {"sub": "local"},
+ )
+ incoming["id"] = "incoming"
+ deliveries = _stub_steer_memory_payloads(monkeypatch, active, incoming)
+
+ assert manager._compatible_steer_memory_authority("turn", deliveries) is False
+
+
+async def test_steering_memory_admission_failure_restores_retryable_queue_row(managers):
+ manager, _other, engine, _engine_b, _starts = managers
+ await _activate(manager, text="active")
+ manager.controller.config.memory = SimpleNamespace(enabled=True)
+ manager.controller.memory_runtime = SimpleNamespace()
+ manager.controller._memory_implementation_error = None
+ manager.controller._memory_admission = Mock(side_effect=RuntimeError("admission unavailable"))
+ manager._steer = AsyncMock(return_value=steer_result(SteerOutcome.ACCEPTED))
+
+ owner = {"platform": "avibe", "user_id": "local", "is_dm": False}
+ result = await manager.deliver(
+ DeliveryRequest(
+ session_id="ses_fsm",
+ priority="p1",
+ content="retry after admission failure",
+ source="harness",
+ author="harness",
+ message_type="harness",
+ metadata={
+ "scheduled_provenance": {
+ "platform_specific": {
+ "task_trigger_kind": "watch",
+ "message_metadata": {"delegated_memory_owner": owner},
+ }
+ }
+ },
+ ),
+ context=_context(),
+ )
+
+ assert result.state == "queued"
+ manager._steer.assert_not_awaited()
+ queued = [row for row in _rows(engine) if row["state"] == "queued"]
+ assert len(queued) == 1
+ events = json.loads(queued[0]["delivery_history_json"])["events"]
+ assert events[-1]["receipt"]["reason"] == "memory_runtime_unavailable"
+
+
+ ("admitted", "incoming_owner", "expected"),
+ [
+ (True, {"platform": "avibe", "user_id": "remote:bob", "is_dm": False}, False),
+ (True, {"platform": "avibe", "user_id": "local", "is_dm": False}, True),
+ (False, {"platform": "avibe", "user_id": "remote:bob", "is_dm": False}, True),
+ ],
+)
+def test_steer_memory_available_retains_admission_authority_semantics(
+ managers,
+ monkeypatch,
+ admitted,
+ incoming_owner,
+ expected,
+):
+ manager, _other, _engine, _engine_b, _starts = managers
+ manager.controller.config.memory = SimpleNamespace(enabled=True)
+ manager.controller.memory_runtime = SimpleNamespace()
+ manager.controller._memory_implementation_error = None
+ admission = Mock()
+ admission.admits.return_value = admitted
+ manager.controller._memory_admission = Mock(return_value=admission)
+ owner = {"platform": "avibe", "user_id": "local", "is_dm": False}
+ active = _steer_memory_payload(source="harness", owner=owner)
+ incoming = _steer_memory_payload(source="harness", owner=incoming_owner)
+ incoming["id"] = "incoming"
+ deliveries = _stub_steer_memory_payloads(monkeypatch, active, incoming)
+
+ assert manager._compatible_steer_memory_authority("turn", deliveries) is expected
+ assert admission.admits.call_count >= 1
+
+
def test_persisted_start_attempt_reaches_dispatch_context(managers) -> None:
manager, _other, engine, _engine_b, _starts = managers
captured: dict[str, object] = {}