Fix v0.1.6: get_tool_schemas() must be unconditional

Hermes's MemoryManager captures the schema list at register-time, before
the provider's initialize() runs. Our get_tool_schemas() was gated on
self._initialized, returning [] until init completed. By that point
Hermes had already built _tool_to_provider with zero entries for us,
and every bm_* invocation for the rest of the session returned
'Unknown tool: bm_search' from MemoryManager dispatch.

The asymmetry was the giveaway: prefetch (called per-turn, after init)
worked, but tool calls (registered once at start) didn't. Felix
reported recall injection working alongside 'Unknown tool: bm_search'
on the same conversation.

Schemas are static — return them unconditionally. handle_tool_call()
already gates on _initialized + actor presence and returns a clean
tool_error if the actor isn't ready, so user-visible failure modes
stay clean.

Regression test: test_get_tool_schemas_unconditional asserts a fresh
uninitialized provider exposes all 7 schemas. Locks the bug shut.

Author: groksrc

CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.6] — 2026-05-10
+
+### Fixed
+- **`bm_*` tools were never registered with Hermes's `MemoryManager._tool_to_provider`.** `get_tool_schemas()` was gated on `self._initialized`, but Hermes captures the schema list at *register* time — before `initialize()` runs. The gate caused every session to start with zero tools registered for our provider, so every LLM-issued `bm_search` (and friends) returned `"Unknown tool: bm_search"` from MemoryManager's dispatch. Symptoms were asymmetric: prefetch (recall injection) worked because it's invoked per-turn after init, but tool calls didn't. Schemas are static — they now return unconditionally, with `handle_tool_call()` doing the runtime "is the actor ready?" gate.
+- Regression test pins this so we don't reintroduce it: `test_get_tool_schemas_unconditional` asserts `get_tool_schemas()` returns all 7 schemas on a fresh, uninitialized provider.
+
 ## [0.1.5] — 2026-05-10
 
 ### Added
@@ -63,6 +69,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 - Single-file plugin at `__init__.py`, AGPL-3.0-or-later.
 - 84-test pytest suite.
 
+[0.1.6]: https://github.com/basicmachines-co/hermes-basic-memory/releases/tag/v0.1.6
 [0.1.5]: https://github.com/basicmachines-co/hermes-basic-memory/releases/tag/v0.1.5
 [0.1.4]: https://github.com/basicmachines-co/hermes-basic-memory/releases/tag/v0.1.4
 [0.1.3]: https://github.com/basicmachines-co/hermes-basic-memory/releases/tag/v0.1.3

__init__.py

@@ -38,7 +38,7 @@
 from agent.memory_provider import MemoryProvider
 from tools.registry import tool_error
 
-__version__ = "0.1.5"
+__version__ = "0.1.6"
 
 logger = logging.getLogger("hermes.memory.basic-memory")
 
@@ -791,8 +791,12 @@ def system_prompt_block(self) -> str:
         )
 
     def get_tool_schemas(self) -> List[Dict[str, Any]]:
-        if not self._initialized:
-            return []
+        # Static. Hermes captures the schema list at register time (before
+        # initialize() has run), so gating on `_initialized` would mean the
+        # tools never make it into MemoryManager._tool_to_provider, and every
+        # `bm_*` invocation returns "Unknown tool: bm_*" for the rest of the
+        # session. handle_tool_call() does the runtime gate on `_initialized`
+        # and returns a clean tool error if the actor isn't ready yet.
         return [dict(s) for s in TOOL_SCHEMAS]
 
     def handle_tool_call(self, tool_name: str, args: Dict[str, Any], **kwargs: Any) -> str:

plugin.yaml

@@ -1,5 +1,5 @@
 name: basic-memory
-version: 0.1.5
+version: 0.1.6
 description: "Basic Memory — persistent knowledge graph backed by the basic-memory MCP server"
 pip_dependencies:
   - mcp

tests/test_provider.py

@@ -44,17 +44,32 @@ def test_name(bm):
     assert bm.BasicMemoryProvider().name == bm.PROVIDER_NAME
 
 
-def test_get_tool_schemas_uninitialized(bm):
+def test_get_tool_schemas_unconditional(bm):
+    """
+    Regression: Hermes captures the schema list at *register* time, before
+    `initialize()` runs. If get_tool_schemas() returns [] when uninitialized,
+    Hermes builds _tool_to_provider with no entries for us and every
+    subsequent bm_* invocation returns "Unknown tool: bm_*" forever.
+    Schemas are static — return them unconditionally.
+    """
+    # Fresh provider, never initialized, should still expose all 7 schemas
     p = bm.BasicMemoryProvider()
-    assert p.get_tool_schemas() == []
+    assert p._initialized is False
+    schemas = p.get_tool_schemas()
+    assert len(schemas) == 7
+    names = {s["name"] for s in schemas}
+    assert names == {"bm_search", "bm_read", "bm_write", "bm_edit",
+                     "bm_context", "bm_delete", "bm_move"}
+
+    # Initialized provider also returns 7 (idempotent)
+    p._initialized = True
+    assert len(p.get_tool_schemas()) == 7
 
 
-def test_get_tool_schemas_initialized(bm):
+def test_get_tool_schemas_returns_independent_copies(bm):
+    """Mutating the returned list shouldn't affect the next call."""
     p = bm.BasicMemoryProvider()
-    p._initialized = True
     schemas = p.get_tool_schemas()
-    assert len(schemas) == 7
-    # Returned list is a copy (mutating shouldn't affect class state)
     schemas.clear()
     assert len(p.get_tool_schemas()) == 7