Skip to content

The agent that grows with you

refactor(memory): move tool-schema plumbing into agent/memory_manager_tools.py

kshitijk4poor310bcf444abf
diff --git a/acp_adapter/commands.py b/acp_adapter/commands.py
index f452e381edc..66e915f6038 100644
--- a/acp_adapter/commands.py
+++ b/acp_adapter/commands.py
@@ -151,7 +151,7 @@ class SlashCommandsMixin:
try:
from model_tools import get_tool_definitions
from types import SimpleNamespace
- from agent.memory_manager import inject_memory_provider_tools
+ from agent.memory_manager_tools import inject_memory_provider_tools
toolsets = _expand_acp_enabled_toolsets(getattr(state.agent, "enabled_toolsets", None))
tools = get_tool_definitions(
diff --git a/acp_adapter/server.py b/acp_adapter/server.py
index 3d3ae4e4c05..8baa96fc0e6 100644
--- a/acp_adapter/server.py
+++ b/acp_adapter/server.py
@@ -445,7 +445,7 @@ class HermesACPAgent(SlashCommandsMixin, acp.Agent):
return
try:
from model_tools import get_tool_definitions
- from agent.memory_manager import inject_memory_provider_tools
+ from agent.memory_manager_tools import inject_memory_provider_tools
agent = state.agent
agent.enabled_toolsets = _expand_acp_enabled_toolsets(
diff --git a/agent/agent_init.py b/agent/agent_init.py
index 65f5e3d7c25..59006475ded 100644
--- a/agent/agent_init.py
+++ b/agent/agent_init.py
@@ -1379,7 +1379,7 @@ def _init_memory(agent, _agent_cfg, skip_memory, platform, memory_manager=None):
_ra().logger.warning("Memory provider plugin init failed: %s", _mpe)
agent._memory_manager = None
- from agent.memory_manager import inject_memory_provider_tools
+ from agent.memory_manager_tools import inject_memory_provider_tools
inject_memory_provider_tools(agent)
@@ -2132,7 +2132,7 @@ def _inject_context_engine_tools(agent):
_existing_tool_names = {
t.get("function", {}).get("name") for t in agent.tools if isinstance(t, dict)
}
- from agent.memory_manager import normalize_tool_schema
+ from agent.memory_manager_tools import normalize_tool_schema
for _raw_schema in agent.context_compressor.get_tool_schemas():
_schema = normalize_tool_schema(_raw_schema)
if _schema is None:
diff --git a/agent/memory_manager.py b/agent/memory_manager.py
index 1015a95b2cc..6a1c0b4e5a6 100644
--- a/agent/memory_manager.py
+++ b/agent/memory_manager.py
@@ -20,9 +20,11 @@ from typing import Any, Callable, Dict, List, Optional
from agent.redact import redact_for_egress
from agent.memory_caller_scope import bound_scope, caller_scope, claim_instance, in_owner_home, refused_tool_message
-# Moved to agent.memory_context; still importable here because agent.memory_manager is a public
+# Moved to agent.memory_context / agent.memory_manager_tools; still importable here because agent.memory_manager is a public
# module for plugins (hermes_cli/plugin_validate_private_imports.py).
from agent.memory_context import StreamingContextScrubber, build_memory_context_block, sanitize_context
+from agent.memory_manager_tools import (inject_memory_provider_tools, memory_provider_tools_enabled,
+ memory_provider_tools_exposed, normalize_tool_schema)
from agent.memory_provider import MemoryProvider, PRE_COMPRESS_CHECKPOINT_API_VERSION, ctx_bound, spawn_context_thread
from agent.skill_commands import extract_user_instruction_from_skill_message
from hermes_constants import hermes_home_key
@@ -71,105 +73,6 @@ def _accepts_require_checkpoint(fn: Callable[..., Any]) -> bool:
return _has_var_kwargs(params) or kind in (inspect.Parameter.KEYWORD_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD)
-# -- Tool-schema plumbing -----------------------------------------------------
-
-def normalize_tool_schema(schema: Any) -> Optional[dict[str, Any]]:
- """Return a bare function-tool dict with a resolvable top-level ``name``, else None.
-
- Providers should return ``{"name", "description", "parameters"}`` but some return the
- wrapped OpenAI form; wrapping that twice yields a nameless ``function`` and strict
- providers (DeepSeek) reject the ENTIRE request, so both shapes are normalized here.
- """
- if not isinstance(schema, dict):
- return None
- if schema.get("type") == "function" and isinstance(schema.get("function"), dict):
- schema = schema["function"]
- name = schema.get("name", "")
- return schema if name and isinstance(name, str) else None
-
-
-def memory_provider_tools_enabled(enabled_toolsets: Optional[list[str]], disabled_toolsets: Optional[list[str]] = None,
- *, memory_tool_present: bool = False) -> bool:
- """Return whether external memory-provider tools should be exposed."""
- if disabled_toolsets and "memory" in disabled_toolsets:
- return False
- if memory_tool_present or enabled_toolsets is None:
- return True
- if not enabled_toolsets:
- return False
- if "memory" in enabled_toolsets:
- return True
- try:
- from toolsets import resolve_toolset
-
- return any("memory" in resolve_toolset(name) for name in enabled_toolsets)
- except Exception:
- logger.debug("Failed to resolve enabled toolsets for memory-provider tools", exc_info=True)
- return False
-
-
-def _tool_name(tool: Any) -> Any:
- return tool.get("function", {}).get("name") if isinstance(tool, dict) else None
-
-
-def memory_provider_tools_exposed(agent: Any) -> bool:
- """Whether external memory-provider tools are exposed on ``agent``.
-
- Same gate as ``inject_memory_provider_tools`` so a provider's ``system_prompt_block()``
- never advertises tools absent from the tool surface.
- """
- tools = getattr(agent, "tools", None)
- present = isinstance(tools, (list, tuple)) and any(_tool_name(t) == "memory" for t in tools)
- enabled, disabled = getattr(agent, "enabled_toolsets", None), getattr(agent, "disabled_toolsets", None)
- return memory_provider_tools_enabled(enabled, disabled, memory_tool_present=present)
-
-
-def inject_memory_provider_tools(agent: Any) -> int:
- """Append external memory-provider tool schemas to an agent tool surface; return count added."""
- memory_manager = getattr(agent, "_memory_manager", None)
- tools = getattr(agent, "tools", None)
- if not memory_manager or tools is None:
- return 0
-
- if not memory_provider_tools_exposed(agent):
- # Say so once: a silent 0 leaves the provider looking "half on" with no clue which
- # config key (platform_toolsets / disabled_toolsets) gated it.
- # See #81014.
- _providers = [p for p in getattr(memory_manager, "providers", None) or []
- if getattr(p, "name", "") != "builtin"]
- if _providers:
- logger.info(
- "Memory provider(s) %s configured but the 'memory' toolset is "
- "gated off for this session (platform_toolsets / "
- "agent.disabled_toolsets) — provider tools and system-prompt "
- "block are both withheld.",
- [getattr(p, "name", type(p).__name__) for p in _providers],
- )
- return 0
-
- get_schemas = getattr(memory_manager, "get_all_tool_schemas", None)
- if not callable(get_schemas):
- return 0
-
- if getattr(agent, "valid_tool_names", None) is None:
- agent.valid_tool_names = set()
- existing_tool_names = {_tool_name(tool) for tool in tools if isinstance(tool, dict)}
- added = 0
- for raw_schema in get_schemas():
- schema = normalize_tool_schema(raw_schema)
- if schema is None:
- logger.warning(
- "Memory provider returned a tool schema with no resolvable "
- "name; skipping to avoid poisoning the request (%r)", raw_schema,
- )
- elif schema["name"] not in existing_tool_names:
- tools.append({"type": "function", "function": schema})
- agent.valid_tool_names.add(schema["name"])
- existing_tool_names.add(schema["name"])
- added += 1
- return added
-
-
# -- Provider egress scrubbing -----------------------------------------------
def _scrub(text: str) -> str:
diff --git a/agent/memory_manager_tools.py b/agent/memory_manager_tools.py
new file mode 100644
index 00000000000..9ea93c833cb
--- /dev/null
+++ b/agent/memory_manager_tools.py
@@ -0,0 +1,106 @@
+"""Memory-provider tool-schema plumbing: the gate that decides whether external memory-provider
+tools are exposed on an agent's tool surface, and the injection of their schemas."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def normalize_tool_schema(schema: Any) -> Optional[dict[str, Any]]:
+ """Return a bare function-tool dict with a resolvable top-level ``name``, else None.
+
+ Providers should return ``{"name", "description", "parameters"}`` but some return the
+ wrapped OpenAI form; wrapping that twice yields a nameless ``function`` and strict
+ providers (DeepSeek) reject the ENTIRE request, so both shapes are normalized here.
+ """
+ if not isinstance(schema, dict):
+ return None
+ if schema.get("type") == "function" and isinstance(schema.get("function"), dict):
+ schema = schema["function"]
+ name = schema.get("name", "")
+ return schema if name and isinstance(name, str) else None
+
+
+def memory_provider_tools_enabled(enabled_toolsets: Optional[list[str]], disabled_toolsets: Optional[list[str]] = None,
+ *, memory_tool_present: bool = False) -> bool:
+ """Return whether external memory-provider tools should be exposed."""
+ if disabled_toolsets and "memory" in disabled_toolsets:
+ return False
+ if memory_tool_present or enabled_toolsets is None:
+ return True
+ if not enabled_toolsets:
+ return False
+ if "memory" in enabled_toolsets:
+ return True
+ try:
+ from toolsets import resolve_toolset
+
+ return any("memory" in resolve_toolset(name) for name in enabled_toolsets)
+ except Exception:
+ logger.debug("Failed to resolve enabled toolsets for memory-provider tools", exc_info=True)
+ return False
+
+
+def _tool_name(tool: Any) -> Any:
+ return tool.get("function", {}).get("name") if isinstance(tool, dict) else None
+
+
+def memory_provider_tools_exposed(agent: Any) -> bool:
+ """Whether external memory-provider tools are exposed on ``agent``.
+
+ Same gate as ``inject_memory_provider_tools`` so a provider's ``system_prompt_block()``
+ never advertises tools absent from the tool surface.
+ """
+ tools = getattr(agent, "tools", None)
+ present = isinstance(tools, (list, tuple)) and any(_tool_name(t) == "memory" for t in tools)
+ enabled, disabled = getattr(agent, "enabled_toolsets", None), getattr(agent, "disabled_toolsets", None)
+ return memory_provider_tools_enabled(enabled, disabled, memory_tool_present=present)
+
+
+def inject_memory_provider_tools(agent: Any) -> int:
+ """Append external memory-provider tool schemas to an agent tool surface; return count added."""
+ memory_manager = getattr(agent, "_memory_manager", None)
+ tools = getattr(agent, "tools", None)
+ if not memory_manager or tools is None:
+ return 0
+
+ if not memory_provider_tools_exposed(agent):
+ # Say so once: a silent 0 leaves the provider looking "half on" with no clue which
+ # config key (platform_toolsets / disabled_toolsets) gated it.
+ # See #81014.
+ _providers = [p for p in getattr(memory_manager, "providers", None) or []
+ if getattr(p, "name", "") != "builtin"]
+ if _providers:
+ logger.info(
+ "Memory provider(s) %s configured but the 'memory' toolset is "
+ "gated off for this session (platform_toolsets / "
+ "agent.disabled_toolsets) — provider tools and system-prompt "
+ "block are both withheld.",
+ [getattr(p, "name", type(p).__name__) for p in _providers],
+ )
+ return 0
+
+ get_schemas = getattr(memory_manager, "get_all_tool_schemas", None)
+ if not callable(get_schemas):
+ return 0
+
+ if getattr(agent, "valid_tool_names", None) is None:
+ agent.valid_tool_names = set()
+ existing_tool_names = {_tool_name(tool) for tool in tools if isinstance(tool, dict)}
+ added = 0
+ for raw_schema in get_schemas():
+ schema = normalize_tool_schema(raw_schema)
+ if schema is None:
+ logger.warning(
+ "Memory provider returned a tool schema with no resolvable "
+ "name; skipping to avoid poisoning the request (%r)", raw_schema,
+ )
+ elif schema["name"] not in existing_tool_names:
+ tools.append({"type": "function", "function": schema})
+ agent.valid_tool_names.add(schema["name"])
+ existing_tool_names.add(schema["name"])
+ added += 1
+ return added
diff --git a/agent/system_prompt.py b/agent/system_prompt.py
index dc09facac3e..03ede0060d2 100644
--- a/agent/system_prompt.py
+++ b/agent/system_prompt.py
@@ -534,7 +534,7 @@ def _memory_parts(agent: Any) -> list[str]:
# configuration has already gated off (#81014).
if agent._memory_manager:
try:
- from agent.memory_manager import memory_provider_tools_exposed as _mem_exposed
+ from agent.memory_manager_tools import memory_provider_tools_exposed as _mem_exposed
except Exception:
_mem_exposed = None
if _mem_exposed is None or _mem_exposed(agent):
diff --git a/tests/agent/test_builtin_memory_disabled_surface.py b/tests/agent/test_builtin_memory_disabled_surface.py
index 8c3d5fe91e6..f87adb53ac1 100644
--- a/tests/agent/test_builtin_memory_disabled_surface.py
+++ b/tests/agent/test_builtin_memory_disabled_surface.py
@@ -245,20 +245,20 @@ class TestExternalProviderSurvivesBuiltinDisable:
"""
def test_provider_tools_enabled_when_memory_toolset_requested(self):
- from agent.memory_manager import memory_provider_tools_enabled
+ from agent.memory_manager_tools import memory_provider_tools_enabled
assert memory_provider_tools_enabled(
["memory", "file"], None, memory_tool_present=False
)
def test_provider_tools_enabled_for_unrestricted_toolsets(self):
- from agent.memory_manager import memory_provider_tools_enabled
+ from agent.memory_manager_tools import memory_provider_tools_enabled
assert memory_provider_tools_enabled(None, None, memory_tool_present=False)
def test_disabled_toolsets_still_takes_everything_down(self):
"""The heavy switch keeps its documented meaning."""
- from agent.memory_manager import memory_provider_tools_enabled
+ from agent.memory_manager_tools import memory_provider_tools_enabled
assert not memory_provider_tools_enabled(
None, ["memory"], memory_tool_present=False
@@ -271,7 +271,8 @@ class TestInjectionEndToEnd:
def test_provider_tools_injected_without_builtin_memory_tool(self):
from types import SimpleNamespace
- from agent.memory_manager import MemoryManager, inject_memory_provider_tools
+ from agent.memory_manager import MemoryManager
+ from agent.memory_manager_tools import inject_memory_provider_tools
from agent.memory_provider import MemoryProvider
class _Provider(MemoryProvider):
diff --git a/tests/agent/test_memory_provider.py b/tests/agent/test_memory_provider.py
index e19d8e737bb..b43c8462ab8 100644
--- a/tests/agent/test_memory_provider.py
+++ b/tests/agent/test_memory_provider.py
@@ -8,7 +8,8 @@ from types import SimpleNamespace
from unittest.mock import MagicMock
from agent.memory_provider import MemoryProvider
-from agent.memory_manager import MemoryManager, inject_memory_provider_tools
+from agent.memory_manager import MemoryManager
+from agent.memory_manager_tools import inject_memory_provider_tools
# ---------------------------------------------------------------------------
# Concrete test provider
@@ -1212,7 +1213,7 @@ class TestNormalizeToolSchema:
def test_non_dict_rejected(self):
- from agent.memory_manager import normalize_tool_schema
+ from agent.memory_manager_tools import normalize_tool_schema
assert normalize_tool_schema("nope") is None
assert normalize_tool_schema(None) is None
@@ -1323,24 +1324,24 @@ class TestSystemPromptGateParity:
return agent, mgr, provider
def test_tools_exposed_when_memory_in_enabled_toolsets(self):
- from agent.memory_manager import memory_provider_tools_exposed
+ from agent.memory_manager_tools import memory_provider_tools_exposed
agent, _mgr, _p = self._agent_with_provider(enabled_toolsets=["memory"])
assert memory_provider_tools_exposed(agent) is True
def test_tools_hidden_when_memory_in_disabled_toolsets(self):
- from agent.memory_manager import memory_provider_tools_exposed
+ from agent.memory_manager_tools import memory_provider_tools_exposed
agent, _mgr, _p = self._agent_with_provider(disabled_toolsets=["memory"])
assert memory_provider_tools_exposed(agent) is False
def test_tools_hidden_when_memory_not_in_enabled_toolsets(self):
- from agent.memory_manager import memory_provider_tools_exposed
+ from agent.memory_manager_tools import memory_provider_tools_exposed
agent, _mgr, _p = self._agent_with_provider(enabled_toolsets=["web_search"])
assert memory_provider_tools_exposed(agent) is False
def test_tools_exposed_when_memory_tool_already_present(self):
"""The built-in "memory" tool is a sufficient opt-in even when the
toolset gate says nothing about memory."""
- from agent.memory_manager import memory_provider_tools_exposed
+ from agent.memory_manager_tools import memory_provider_tools_exposed
tools = [
{"type": "function", "function": {"name": "memory", "description": "x", "parameters": {}}},
]
@@ -1351,7 +1352,7 @@ class TestSystemPromptGateParity:
"""``inject_memory_provider_tools`` and ``memory_provider_tools_exposed``
must agree — both determine whether provider tools are presented to
the model (#81014)."""
- from agent.memory_manager import inject_memory_provider_tools, memory_provider_tools_exposed
+ from agent.memory_manager_tools import inject_memory_provider_tools, memory_provider_tools_exposed
# Disabled toolsets — neither path should add or advertise provider tools.
agent, _mgr, _p = self._agent_with_provider(disabled_toolsets=["memory"])
diff --git a/tools/mcp_tool_agent.py b/tools/mcp_tool_agent.py
index eca214e725f..e74f1510b57 100644
--- a/tools/mcp_tool_agent.py
+++ b/tools/mcp_tool_agent.py
@@ -329,7 +329,7 @@ def _reinject_post_build_tools(agent, tools_list: list, name_set: set) -> set:
try:
get_mem_schemas = _schema_getter("_memory_manager", "get_all_tool_schemas")
if get_mem_schemas is not None:
- from agent.memory_manager import memory_provider_tools_enabled # same gate inject_memory_provider_tools uses
+ from agent.memory_manager_tools import memory_provider_tools_enabled # same gate inject_memory_provider_tools uses
if memory_provider_tools_enabled(
enabled, getattr(agent, "disabled_toolsets", None), memory_tool_present="memory" in name_set):
for schema in get_mem_schemas():