amrita_plugin_memory 0.2.2__tar.gz → 0.2.2.post1__tar.gz

{amrita_plugin_memory-0.2.2 → amrita_plugin_memory-0.2.2.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amrita_plugin_memory
-Version: 0.2.2
+Version: 0.2.2.post1
 Summary: Amrita长期记忆插件
 Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown

amrita_plugin_memory-0.2.2.post1/amrita_plugin_memory/rethinking/__init__.py

@@ -0,0 +1,20 @@
+"""潜意识推理循环（rethinking 子包）。
+
+导入此包时触发工具注册和 hook 注册。
+注意：避免模块级导入 tools/runner 等会触发循环导入的子模块。
+这些模块的副作用（@on_tools 注册、hook 注册）通过 hooks 和 tools 内部的延迟导入自动生效。
+"""
+
+from . import _state, backend, hooks, nodes, schemas, workflow
+
+__all__ = [
+    "_state",
+    "backend",
+    "consts",
+    "hooks",
+    "nodes",
+    "runner",
+    "schemas",
+    "tools",
+    "workflow",
+]

amrita_plugin_memory-0.2.2.post1/amrita_plugin_memory/rethinking/_state.py

@@ -0,0 +1,41 @@
+"""模块级共享状态管理。"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from amrita_core.tools.manager import MultiToolsManager
+
+if TYPE_CHECKING:
+    from .runner import SubconsciousRunner
+
+_runner: SubconsciousRunner | None = None
+_pending_messages: list[dict[str, Any]] = []
+# 隔离的工具管理器 — 所有 @on_tools 装饰器通过 bound_to 注册到这里，不污染全局 ToolsManager
+_SUBCONSCIOUS_TOOLS = MultiToolsManager()
+
+
+def get_runner() -> SubconsciousRunner | None:
+    return _runner
+
+
+def set_runner(r: SubconsciousRunner | None) -> None:
+    global _runner
+    _runner = r
+
+
+def get_target_user_id() -> str:
+    return _runner._config.target_user_id if _runner is not None else ""
+
+
+def get_pending() -> list[dict[str, Any]]:
+    return _pending_messages
+
+
+def set_pending(msgs: list[dict[str, Any]]) -> None:
+    global _pending_messages
+    _pending_messages = msgs
+
+
+def get_tools_manager() -> MultiToolsManager:
+    return _SUBCONSCIOUS_TOOLS

amrita_plugin_memory-0.2.2.post1/amrita_plugin_memory/rethinking/backend.py

@@ -0,0 +1,73 @@
+"""自定义 Backend — 为潜意识循环提供隔离的工具和内存池。"""
+
+from __future__ import annotations
+
+from typing import Any, ClassVar
+
+from amrita_core.base.backend import AbilityBackend, MemoryBackend
+from amrita_core.contexts import AbilityContext
+from amrita_core.preset import MultiPresetManager
+from amrita_core.tools.manager import MultiToolsManager, ToolsManager
+from amrita_core.tools.mcp import ClientManager, MultiClientManager
+from amrita_core.types import MemoryModel
+from nonebot import logger
+
+from ..config import SubconsciousConfig
+from . import _state
+
+
+def _get_global_tools() -> ToolsManager:
+    return ToolsManager()
+
+
+class SubconsciousBackend(AbilityBackend, MemoryBackend):
+    """为潜意识循环提供隔离的工具和内存池。"""
+
+    _instance: ClassVar[SubconsciousBackend | None] = None
+    _tools_manager: MultiToolsManager
+    _presets: MultiPresetManager
+    _memory: MemoryModel
+
+    def __new__(cls, *args: Any, **kwargs: Any):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self, config: SubconsciousConfig):
+        if not hasattr(self, "_tools_manager"):
+            self._config = config
+            self._presets = MultiPresetManager()
+            self._memory = MemoryModel()
+            self._register_tools()
+
+    def _register_tools(self) -> None:
+        # 所有工具已通过 @on_tools(bound_to=_state.get_tools_manager()) 注册到隔离的 MultiToolsManager
+        # 这里只需拉取它们的 ToolData 用于 debug 校验
+        self._tools_manager = _state.get_tools_manager()
+        # allowed_tools 从全局 ToolsManager 拉取额外工具
+        gm = _get_global_tools()
+        for tool_name in self._config.allowed_tools:
+            if (td := gm.get_tool(tool_name)) is not None:
+                self._tools_manager.register_tool(td)
+            else:
+                logger.warning(f"[EXP Subconscious] Tool '{tool_name}' not found")
+
+    async def load_ability_all(self, session_id: str) -> AbilityContext:
+        return AbilityContext(
+            tools=self._tools_manager, presets=self._presets, mcp=ClientManager()
+        )
+
+    async def load_mcp_clients(self, session_id: str) -> MultiClientManager:
+        return ClientManager()
+
+    async def load_tools(self, session_id: str) -> MultiToolsManager:
+        return self._tools_manager
+
+    async def load_presets(self, session_id: str) -> MultiPresetManager:
+        return self._presets
+
+    async def load_memory(self, session_id: str) -> MemoryModel:
+        return MemoryModel(messages=[], abstract="")
+
+    async def commit_memory(self, session_id: str, memory: MemoryModel) -> None:
+        self._memory = memory

amrita_plugin_memory-0.2.2.post1/amrita_plugin_memory/rethinking/consts.py

@@ -0,0 +1,88 @@
+"""常量、默认提示词模板和工具函数。"""
+
+from pathlib import Path
+
+from nonebot import logger
+
+DEFAULT_SUBCONSCIOUS_PROMPT = """\
+你是用户的记忆管家（Memory Curator），在后台静默运行。你的职责是整理、优化用户的长期记忆库。
+{% if character_prompt -%}
+{{ character_prompt }}
+{% endif %}
+
+<ROLE>
+你是一个细心、可靠、不喧宾夺主的记忆管家。你不会和用户直接对话——所有操作通过工具调用完成。
+</ROLE>
+
+<INFO>
+当前时间：{{ current_time }}
+用户ID：{{ target_user_id }}
+这是第 {{ total_runs }} 次推理循环。
+{% if last_run %}
+<PREVIOUS_RUN_SUMMARY>
+{{ last_run }}
+</PREVIOUS_RUN_SUMMARY>
+{% endif %}
+</INFO>
+
+<RULES>
+1. 必须使用工具检查操作用户记忆库，不凭空想象。
+2. 每轮先了解状态（subconscious_list_memory / subconscious_read_memory），再执行整理。
+3. 识别重复/矛盾/过时/缺标签的记忆，用 subconscious_write_memory / update / delete 处理。
+4. 整理完毕或有新发现需要处理时，必须调用 subconscious_iter_stop。
+5. 别单轮做太多，保持高效。
+</RULES>
+
+<MEMORY_QUALITY>
+- 去重：内容高度相似 → 合并为一条精炼的
+- 矛盾检测：保留较新或更具体的
+- 标签管理：有意义且一致
+- 重要性校准：评估 low/medium/high
+- 过时信息：考虑更新或降低重要性
+</MEMORY_QUALITY>"""
+
+DEFAULT_SEND_PROMPT = """\
+{% if character_prompt -%}
+<ORIGINAL_CHARACTER_PROMPT>
+{{ character_prompt }}
+</ORIGINAL_CHARACTER_PROMPT>
+
+
+{% endif %}
+你是AI助手本身，以你的日常角色身份对用户说话。不要暴露你是"后台进程"。
+
+<INTENT>{{ intent }}</INTENT>
+{% if memory_context %}<MEMORY>{{ memory_context }}</MEMORY>{% endif %}
+
+<RULES>
+- 只输出一句话，≤60字
+- 语气自然随意，像朋友发消息
+- 有记忆上下文就自然提及（别背诵原文）
+- 不用任何技术标签或格式
+</RULES>"""
+
+
+def ensure_prompt_file(path: Path, default_content: str) -> None:
+    """确保 prompt 文件存在，缺失时创建默认文件。"""
+    if not path.exists():
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(default_content, encoding="utf-8")
+        logger.info(f"[EXP Subconscious] Created default prompt: {path}")
+
+
+async def load_character_prompt() -> str:
+    """加载 Bot 的角色设定 prompt（从 config/chat/private_prompts/ 中读取）。"""
+    try:
+        from amrita.plugins.chat.config import config_manager
+
+        prompts_dir = config_manager.prompt_store.private_dir
+        character = config_manager.config.private_prompt_character
+        char_file = prompts_dir / f"{character}.txt"
+        if char_file.exists():
+            return char_file.read_text(encoding="utf-8").strip()
+        default_file = prompts_dir / "default.txt"
+        if default_file.exists():
+            return default_file.read_text(encoding="utf-8").strip()
+    except Exception as e:
+        logger.debug(f"[EXP Subconscious] Load character prompt failed: {e}")
+    return ""

amrita_plugin_memory-0.2.2.post1/amrita_plugin_memory/rethinking/hooks.py

@@ -0,0 +1,75 @@
+"""Hook 注册与生命周期管理。"""
+
+from amrita_core.types import Message
+from nonebot import get_driver, logger
+
+from ..config import DataManager
+from . import _state
+
+
+async def _setup_subconscious_hook() -> None:
+    from amrita.plugins.chat.runtime import try_get_amrita_ctx
+    from amrita_core.hook.event import PreCompletionEvent
+    from amrita_core.hook.on import on_precompletion
+
+    pre_chat_hook = on_precompletion(priority=10, block=False)
+
+    @pre_chat_hook.handle()
+    async def _subconscious_pre_hook(event: PreCompletionEvent) -> None:
+        runner = _state.get_runner()
+        if runner is None:
+            return
+        amrita_ctx = try_get_amrita_ctx(event.chat_object)
+        if amrita_ctx is None:
+            return
+        if str(amrita_ctx["event"].user_id) != runner._config.target_user_id:
+            return
+
+        if runner._config.pause_on_user_chat:
+            await runner.pause_due_to_user_activity()
+
+        pending = _state.get_pending()
+        if pending and runner._config.allow_send_to_user:
+            msgs = list(pending)
+            _state.set_pending([])
+            await runner._save_pending_to_repo()
+            for entry in msgs:
+                content = entry.get("content", "")
+                ts = entry.get("timestamp", "")
+                if not content:
+                    continue
+                inject = Message(
+                    role="system",
+                    content=f"[系统提示] 在 {ts} 时，你（潜意识）曾想对用户说：{content}\n现在用户发来了新消息，请自然地将这个背景融入你的回复中。",
+                )
+                event.chat_object.data.messages.insert(0, inject)
+                logger.info(
+                    f"[EXP Subconscious] Injected pending msg: {content[:50]}..."
+                )
+
+    logger.debug("[EXP Subconscious] on_precompletion hook registered")
+
+
+@get_driver().on_startup
+async def _subconscious_startup() -> None:
+    from .runner import SubconsciousRunner  # lazy to avoid circular import
+
+    cfg = (await DataManager().safe_get_config()).subconscious
+    if not cfg.enabled or not cfg.target_user_id:
+        logger.debug("[EXP Subconscious] Not enabled or no target user, skip")
+        return
+    runner = SubconsciousRunner(cfg)
+    _state.set_runner(runner)
+    await runner.start()
+    try:
+        await _setup_subconscious_hook()
+    except Exception as e:
+        logger.warning(f"[EXP Subconscious] Hook setup failed: {e}")
+
+
+@get_driver().on_shutdown
+async def _subconscious_shutdown() -> None:
+    runner = _state.get_runner()
+    if runner is not None:
+        runner.stop()
+    _state.set_runner(None)

amrita_plugin_memory-0.2.2.post1/amrita_plugin_memory/rethinking/nodes.py

@@ -0,0 +1,48 @@
+"""工作流 Node — 复用 Core Agent 框架。"""
+
+from amrita_core.agent.context import StrategyContext
+from amrita_core.chatmanager import ChatObject
+from amrita_core.chatmanager.memory_limiter import MemoryLimiter
+from amrita_core.contexts import AgentLoopState, WorkingState
+from amrita_core.types import Message, SendMessageWrap
+from amrita_core.utils import gather_usage
+from amrita_sense import Node
+
+
+@Node(tag="subconscious_limiting_memory")
+async def LIMITING_MEMORY(chat_obj: ChatObject) -> None:
+    """运行 Core MemoryLimiter — 截断超限消息并生成摘要。
+
+    等价于 chat_object.py 的 _limiting_memory，去掉了 SuspendEnum 暂停机制
+    （因为我们不使用 ChatObject 的流式暂停）。
+    """
+    mem_ctx = chat_obj._di_memory
+    input_ctx = chat_obj._di_input
+    ab = chat_obj._di_ability
+    resp = chat_obj._di_resp
+    if not ab.config.llm.enable_memory_abstract:
+        return
+    assert mem_ctx.memory is not None, "Memory must be loaded before limiting"
+    async with MemoryLimiter(mem_ctx.memory, input_ctx.train, config=ab.config) as lim:
+        await lim.run_enforce()
+        if abs_usage := lim.usage:
+            resp.extra_usage = gather_usage(resp.extra_usage, abs_usage)
+        mem_ctx.memory = lim.memory
+
+
+@Node(tag="subconscious_strategy_init")
+async def STRATEGY_INIT(
+    chat_obj: ChatObject, loop: AgentLoopState, wok: WorkingState
+) -> None:
+    """初始化策略上下文。
+
+    等价于 chat_object.py 的 _run_strategy('agent' 分支)。
+    AGENT_ENTRY 紧随其后执行，agent.strategy(loop.stg_ctx) 实例化 ReActAgentStrategy。
+    """
+    assert wok.context_wrap is not None, "Context wrap must be built before strategy"
+    input_ctx = chat_obj._di_input
+
+    context = SendMessageWrap.validate_messages(
+        [input_ctx.train, Message(role="user", content=input_ctx.user_input)]
+    )
+    loop.stg_ctx = StrategyContext(input_ctx.user_input, context, chat_obj)