memory_manager_tools.py 4.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106
  1. """Memory-provider tool-schema plumbing: the gate that decides whether external memory-provider
  2. tools are exposed on an agent's tool surface, and the injection of their schemas."""
  3. from __future__ import annotations
  4. import logging
  5. from typing import Any, Optional
  6. logger = logging.getLogger(__name__)
  7. def normalize_tool_schema(schema: Any) -> Optional[dict[str, Any]]:
  8. """Return a bare function-tool dict with a resolvable top-level ``name``, else None.
  9. Providers should return ``{"name", "description", "parameters"}`` but some return the
  10. wrapped OpenAI form; wrapping that twice yields a nameless ``function`` and strict
  11. providers (DeepSeek) reject the ENTIRE request, so both shapes are normalized here.
  12. """
  13. if not isinstance(schema, dict):
  14. return None
  15. if schema.get("type") == "function" and isinstance(schema.get("function"), dict):
  16. schema = schema["function"]
  17. name = schema.get("name", "")
  18. return schema if name and isinstance(name, str) else None
  19. def memory_provider_tools_enabled(enabled_toolsets: Optional[list[str]], disabled_toolsets: Optional[list[str]] = None,
  20. *, memory_tool_present: bool = False) -> bool:
  21. """Return whether external memory-provider tools should be exposed."""
  22. if disabled_toolsets and "memory" in disabled_toolsets:
  23. return False
  24. if memory_tool_present or enabled_toolsets is None:
  25. return True
  26. if not enabled_toolsets:
  27. return False
  28. if "memory" in enabled_toolsets:
  29. return True
  30. try:
  31. from toolsets import resolve_toolset
  32. return any("memory" in resolve_toolset(name) for name in enabled_toolsets)
  33. except Exception:
  34. logger.debug("Failed to resolve enabled toolsets for memory-provider tools", exc_info=True)
  35. return False
  36. def _tool_name(tool: Any) -> Any:
  37. return tool.get("function", {}).get("name") if isinstance(tool, dict) else None
  38. def memory_provider_tools_exposed(agent: Any) -> bool:
  39. """Whether external memory-provider tools are exposed on ``agent``.
  40. Same gate as ``inject_memory_provider_tools`` so a provider's ``system_prompt_block()``
  41. never advertises tools absent from the tool surface.
  42. """
  43. tools = getattr(agent, "tools", None)
  44. present = isinstance(tools, (list, tuple)) and any(_tool_name(t) == "memory" for t in tools)
  45. enabled, disabled = getattr(agent, "enabled_toolsets", None), getattr(agent, "disabled_toolsets", None)
  46. return memory_provider_tools_enabled(enabled, disabled, memory_tool_present=present)
  47. def inject_memory_provider_tools(agent: Any) -> int:
  48. """Append external memory-provider tool schemas to an agent tool surface; return count added."""
  49. memory_manager = getattr(agent, "_memory_manager", None)
  50. tools = getattr(agent, "tools", None)
  51. if not memory_manager or tools is None:
  52. return 0
  53. if not memory_provider_tools_exposed(agent):
  54. # Say so once: a silent 0 leaves the provider looking "half on" with no clue which
  55. # config key (platform_toolsets / disabled_toolsets) gated it.
  56. # See #81014.
  57. _providers = [p for p in getattr(memory_manager, "providers", None) or []
  58. if getattr(p, "name", "") != "builtin"]
  59. if _providers:
  60. logger.info(
  61. "Memory provider(s) %s configured but the 'memory' toolset is "
  62. "gated off for this session (platform_toolsets / "
  63. "agent.disabled_toolsets) — provider tools and system-prompt "
  64. "block are both withheld.",
  65. [getattr(p, "name", type(p).__name__) for p in _providers],
  66. )
  67. return 0
  68. get_schemas = getattr(memory_manager, "get_all_tool_schemas", None)
  69. if not callable(get_schemas):
  70. return 0
  71. if getattr(agent, "valid_tool_names", None) is None:
  72. agent.valid_tool_names = set()
  73. existing_tool_names = {_tool_name(tool) for tool in tools if isinstance(tool, dict)}
  74. added = 0
  75. for raw_schema in get_schemas():
  76. schema = normalize_tool_schema(raw_schema)
  77. if schema is None:
  78. logger.warning(
  79. "Memory provider returned a tool schema with no resolvable "
  80. "name; skipping to avoid poisoning the request (%r)", raw_schema,
  81. )
  82. elif schema["name"] not in existing_tool_names:
  83. tools.append({"type": "function", "function": schema})
  84. agent.valid_tool_names.add(schema["name"])
  85. existing_tool_names.add(schema["name"])
  86. added += 1
  87. return added