amrita 0.7.3.2__tar.gz → 1.0.0.dev2__tar.gz

{amrita-0.7.3.2/amrita.egg-info → amrita-1.0.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amrita
-Version: 0.7.3.2
+Version: 1.0.0.dev2
 Summary: A powerful AI bot framework powered by NoneBot2
 License-Expression: GPL-3.0-or-later
 Project-URL: Homepage, https://github.com/LiteSuggarDEV/Amrita
@@ -29,6 +29,8 @@ Requires-Dist: nonebot-plugin-orm>=0.8.3
 Requires-Dist: nb-cli==1.6.0
 Requires-Dist: watchfiles>=1.1.1
 Provides-Extra: full
+Requires-Dist: amrita-core==0.4.3.2; extra == "full"
+Requires-Dist: nonebot-plugin-uniconf>=0.1.3; extra == "full"
 Requires-Dist: aiomysql>=0.3.2; extra == "full"
 Requires-Dist: aiopg>=1.4.0; extra == "full"
 Requires-Dist: aiosqlite>=0.21.0; extra == "full"
@@ -46,7 +48,7 @@ Requires-Dist: pytz>=2025.1; extra == "full"
 Requires-Dist: stubs>=1.0.0; extra == "full"
 Requires-Dist: dotenv>=0.9.9; extra == "full"
 Requires-Dist: importlib>=1.0.4; extra == "full"
-Requires-Dist: openai<=1.99.0,>=1.66.3; extra == "full"
+Requires-Dist: openai>=2.16.0; extra == "full"
 Requires-Dist: pydantic>=2.4.2; extra == "full"
 Requires-Dist: jieba>=0.42.1; extra == "full"
 Requires-Dist: nonebot-plugin-orm>=0.8.2; extra == "full"
@@ -54,7 +56,7 @@ Requires-Dist: nonebot-adapter-onebot>=2.4.6; extra == "full"
 Requires-Dist: nonebot2[fastapi]>=2.4.3; extra == "full"
 Dynamic: license-file
 
-# PROJ.Amrita 🌸 - 基于 NoneBot 的 LLM 聊天机器人框架
+# PROJ.Amrita 🌸 - 基于 NoneBot 与 AmritaCore 的 Agent Bot
 
 <p align= "center">
   <img src="./logo/Amrita-nobg.png" width=400 height=400>
@@ -65,7 +67,7 @@ Dynamic: license-file
   <img src="https://img.shields.io/badge/NoneBot-2.0+-red?logo=nonebot" alt="NoneBot">
 </p>
 
-Amrita 是一个基于[NoneBot2](https://nonebot.dev/)的强大聊天机器人框架，专为快速构建和部署智能聊天机器人而设计。它是一个完整的 LLM 聊天机器人解决方案，具有强大的功能和灵活性。
+Amrita 是一个基于[NoneBot2](https://nonebot.dev/)与[AmritaCore](https://amrita-core.suggar.top)的强大聊天机器人框架，专为快速构建和部署智能聊天机器人而设计。它是一个完整的 LLM 聊天机器人解决方案，具有强大的功能和灵活性。
 
 ## 🌟 特性亮点
 
@@ -76,7 +78,7 @@ Amrita 是一个基于[NoneBot2](https://nonebot.dev/)的强大聊天机器人
 - **插件化架构**: 模块化设计，易于扩展和定制
 - **开箱即用**: 预设丰富的回复模板和功能配置
 - **强大 CLI 工具**: 一体化命令行管理工具，简化开发和部署流程
-- **Agent 模式**: 支持智能对话管理，自动生成回复
+- **Agent**: 支持智能对话管理，自动生成回复
 - **智能上下文管理**: 支持智能上下文管理
 - **Web UI**: 集成 Web UI，提供可视化管理界面
 - **MCP**: 支持Model Context Protocol
@@ -84,6 +86,7 @@ Amrita 是一个基于[NoneBot2](https://nonebot.dev/)的强大聊天机器人
 ## 📚 文档和资源
 
 - [官方文档](https://amrita.suggar.top)
+- [Core开发文档](https://amrita-core.suggar.top)
 - [问题反馈](https://github.com/LiteSuggarDEV/Amrita/issues)
 
 ## 🤝 贡献

{amrita-0.7.3.2 → amrita-1.0.0.dev2}/README.md

@@ -1,4 +1,4 @@
-# PROJ.Amrita 🌸 - 基于 NoneBot 的 LLM 聊天机器人框架
+# PROJ.Amrita 🌸 - 基于 NoneBot 与 AmritaCore 的 Agent Bot
 
 <p align= "center">
   <img src="./logo/Amrita-nobg.png" width=400 height=400>
@@ -9,7 +9,7 @@
   <img src="https://img.shields.io/badge/NoneBot-2.0+-red?logo=nonebot" alt="NoneBot">
 </p>
 
-Amrita 是一个基于[NoneBot2](https://nonebot.dev/)的强大聊天机器人框架，专为快速构建和部署智能聊天机器人而设计。它是一个完整的 LLM 聊天机器人解决方案，具有强大的功能和灵活性。
+Amrita 是一个基于[NoneBot2](https://nonebot.dev/)与[AmritaCore](https://amrita-core.suggar.top)的强大聊天机器人框架，专为快速构建和部署智能聊天机器人而设计。它是一个完整的 LLM 聊天机器人解决方案，具有强大的功能和灵活性。
 
 ## 🌟 特性亮点
 
@@ -20,7 +20,7 @@ Amrita 是一个基于[NoneBot2](https://nonebot.dev/)的强大聊天机器人
 - **插件化架构**: 模块化设计，易于扩展和定制
 - **开箱即用**: 预设丰富的回复模板和功能配置
 - **强大 CLI 工具**: 一体化命令行管理工具，简化开发和部署流程
-- **Agent 模式**: 支持智能对话管理，自动生成回复
+- **Agent**: 支持智能对话管理，自动生成回复
 - **智能上下文管理**: 支持智能上下文管理
 - **Web UI**: 集成 Web UI，提供可视化管理界面
 - **MCP**: 支持Model Context Protocol
@@ -28,6 +28,7 @@ Amrita 是一个基于[NoneBot2](https://nonebot.dev/)的强大聊天机器人
 ## 📚 文档和资源
 
 - [官方文档](https://amrita.suggar.top)
+- [Core开发文档](https://amrita-core.suggar.top)
 - [问题反馈](https://github.com/LiteSuggarDEV/Amrita/issues)
 
 ## 🤝 贡献

{amrita-0.7.3.2 → amrita-1.0.0.dev2}/amrita/cache.py

@@ -2,7 +2,7 @@
 
 该模块实现了基于OrderedDict的LRU（Least Recently Used）缓存，
 支持字典-like的操作接口，并在缓存满时自动淘汰最久未使用的条目。
-同时实现了TTL（Time To Live）和TFU（Time Frequently Used）缓存策略。
+同时实现了TTL（Time To Live）和LFU（Least Frequently Used）缓存策略。
 
 目前这个模块看起来并没有使用，但是在Amrita的未来的重构计划中将作为重要的一环。
 """
@@ -445,14 +445,14 @@ class TTLCache(Generic[K, V]):
         return f"{self.__class__.__name__}(capacity={self._capacity}, ttl={self._ttl}, items={{{', '.join(items)}}})"
 
 
-class TFUCache(Generic[K, V]):
-    """TFU缓存实现（Time Frequently Used）
+class LFUCache(Generic[K, V]):
+    """LFU缓存实现（Least Frequently Used）
 
     该缓存根据访问频率淘汰条目，保留访问频率最高的条目。
     """
 
     def __init__(self, capacity: int):
-        """初始化TFU缓存
+        """初始化LFU缓存
 
         Args:
             capacity: 缓存的最大容量

amrita-1.0.0.dev2/amrita/config_manager.py

@@ -0,0 +1,25 @@
+"""为了兼容，这里保留了import"""
+
+import warnings
+
+warnings.warn(
+    "This module is deprecated and will be removed in a future version(1.2.0).Please import from `nonebot_plugin_uniconf` instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+from nonebot_plugin_uniconf import (
+    CALLBACK_TYPE,
+    FILTER_TYPE,
+    BaseDataManager,
+    EnvfulConfigManager,
+    UniConfigManager,
+)
+
+__all__ = [
+    "CALLBACK_TYPE",
+    "FILTER_TYPE",
+    "BaseDataManager",
+    "EnvfulConfigManager",
+    "UniConfigManager",
+]

amrita-1.0.0.dev2/amrita/dirty.py

@@ -0,0 +1,265 @@
+"""脏标记Pydantic模型，用于数据库ORM等场景，自动跟踪属性的修改状态。"""
+
+from __future__ import annotations
+
+from typing import Any, SupportsIndex, TypeVar
+
+from pydantic import BaseModel, Field
+
+T = TypeVar("T")
+
+
+class DirtyList(list):
+    def __init__(self, *args, parent: DirtyAwareModel, attr: str, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._parent = parent
+        self._attr = attr
+
+    def _mark_dirty(self):
+        self._parent._mark_dirty(self._attr)
+
+    def _wrap_value(self, value: Any) -> Any:
+        if isinstance(value, (list, dict, set)) and not hasattr(value, "_parent"):
+            return _wrap_container(value, self._parent, self._attr)
+        return value
+
+    def append(self, item):
+        item = self._wrap_value(item)
+        super().append(item)
+        self._mark_dirty()
+
+    def extend(self, iterable):
+        iterable = [self._wrap_value(i) for i in iterable]
+        super().extend(iterable)
+        self._mark_dirty()
+
+    def insert(self, index, item):
+        item = self._wrap_value(item)
+        super().insert(index, item)
+        self._mark_dirty()
+
+    def remove(self, item):
+        super().remove(item)
+        self._mark_dirty()
+
+    def pop(self, index: SupportsIndex = -1):
+        result = super().pop(index)
+        self._mark_dirty()
+        return result
+
+    def clear(self):
+        super().clear()
+        self._mark_dirty()
+
+    def __setitem__(self, index, item):
+        if isinstance(index, slice):
+            item = [self._wrap_value(i) for i in item]
+        else:
+            item = self._wrap_value(item)
+        super().__setitem__(index, item)
+        self._mark_dirty()
+
+    def __delitem__(self, index):
+        super().__delitem__(index)
+        self._mark_dirty()
+
+    def __iadd__(self, other):
+        other = [self._wrap_value(i) for i in other]
+        super().__iadd__(other)
+        self._mark_dirty()
+        return self
+
+    def __imul__(self, other):
+        super().__imul__(other)
+        self._mark_dirty()
+        return self
+
+    def __getitem__(self, index):
+        value = super().__getitem__(index)
+        if isinstance(index, slice):
+            return value
+        return self._wrap_value(value)
+
+
+class DirtyDict(dict):
+    def __init__(self, *args, parent: DirtyAwareModel, attr: str, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._parent = parent
+        self._attr = attr
+
+    def _mark_dirty(self):
+        self._parent._mark_dirty(self._attr)
+
+    def _wrap_value(self, value: Any) -> Any:
+        if isinstance(value, (list, dict, set)) and not hasattr(value, "_parent"):
+            return _wrap_container(value, self._parent, self._attr)
+        return value
+
+    def __setitem__(self, key, value):
+        value = self._wrap_value(value)
+        super().__setitem__(key, value)
+        self._mark_dirty()
+
+    def __delitem__(self, key):
+        super().__delitem__(key)
+        self._mark_dirty()
+
+    def pop(self, key, default=None):
+        result = super().pop(key, default)
+        self._mark_dirty()
+        return result
+
+    def popitem(self):
+        result = super().popitem()
+        self._mark_dirty()
+        return result
+
+    def clear(self):
+        super().clear()
+        self._mark_dirty()
+
+    def update(self, *args, **kwargs):
+        other = dict(*args, **kwargs)
+        for k, v in other.items():
+            other[k] = self._wrap_value(v)
+        super().update(other)
+        self._mark_dirty()
+
+    def setdefault(self, key, default=None):
+        default = self._wrap_value(default)
+        result = super().setdefault(key, default)
+        if key not in self:
+            self._mark_dirty()
+        return self._wrap_value(result)
+
+    def __getitem__(self, key):
+        value = super().__getitem__(key)
+        return self._wrap_value(value)
+
+
+class DirtySet(set):
+    def __init__(self, *args, parent: DirtyAwareModel, attr: str, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._parent = parent
+        self._attr = attr
+
+    def _mark_dirty(self):
+        self._parent._mark_dirty(self._attr)
+
+    def add(self, element):
+        super().add(element)
+        self._mark_dirty()
+
+    def remove(self, element):
+        super().remove(element)
+        self._mark_dirty()
+
+    def discard(self, element):
+        super().discard(element)
+        self._mark_dirty()
+
+    def pop(self):
+        result = super().pop()
+        self._mark_dirty()
+        return result
+
+    def clear(self):
+        super().clear()
+        self._mark_dirty()
+
+    def __ior__(self, other):
+        super().__ior__(other)
+        self._mark_dirty()
+        return self
+
+    def __iand__(self, other):
+        super().__iand__(other)
+        self._mark_dirty()
+        return self
+
+    def __isub__(self, other):
+        super().__isub__(other)
+        self._mark_dirty()
+        return self
+
+    def __ixor__(self, other):
+        super().__ixor__(other)
+        self._mark_dirty()
+        return self
+
+
+def _wrap_container(obj: list | dict | set, parent: DirtyAwareModel, attr: str):
+    if isinstance(obj, list):
+        return DirtyList(obj, parent=parent, attr=attr)
+    if isinstance(obj, dict):
+        return DirtyDict(obj, parent=parent, attr=attr)
+    if isinstance(obj, set):
+        return DirtySet(obj, parent=parent, attr=attr)
+    return obj
+
+
+class DirtyAwareModel(BaseModel):
+    dirtyvars__: set[str] = Field(default_factory=set, init=False, exclude=True)
+
+    def model_post_init(self, __context, /):
+        del __context
+        for name, value in self.__dict__.items():
+            if name.startswith("__") or name == "dirtyvars__":
+                continue
+            wrapped = self._wrap_if_needed(name, value)
+            if wrapped is not value:
+                object.__setattr__(self, name, wrapped)
+
+    def __setattr__(self, name, value):
+        if name in ("dirtyvars__",):
+            object.__setattr__(self, name, value)
+            return
+
+        wrapped = self._wrap_if_needed(name, value)
+        super().__setattr__(name, wrapped)
+        self._mark_dirty(name)
+
+    def __getattribute__(self, name: str) -> Any:
+        value = super().__getattribute__(name)
+        if name.startswith("__") or name == "dirtyvars__" or name.endswith("__"):
+            return value
+
+        if hasattr(value, "_parent"):
+            return value
+
+        if isinstance(value, (list, dict, set)):
+            wrapped = _wrap_container(value, self, name)
+            object.__setattr__(self, name, wrapped)
+            return wrapped
+        elif isinstance(
+            value, BaseModel
+        ):  # 也不会有人在ORM模型里嵌套好几层吧，就简单地处理一下吧
+            self._mark_dirty(name)
+
+        return value
+
+    def _wrap_if_needed(self, name: str, value: Any) -> Any:
+        if isinstance(value, (list, dict, set)) and not hasattr(value, "_parent"):
+            return _wrap_container(value, self, name)
+        return value
+
+    def _mark_dirty(self, name: str):
+        exclue: tuple[str, ...] | None
+        if exclue := getattr(self, "dirty_excluede__", None):
+            if name in exclue:
+                return
+        dirty_vars: set[str] | None = getattr(self, "dirtyvars__", None)
+        if dirty_vars is None:
+            return
+        dirty_vars.add(name)
+
+    def is_dirty(self, name: str | None = None) -> bool:
+        if name:
+            return name in self.dirtyvars__
+        return len(self.dirtyvars__) > 0
+
+    def get_dirty_vars(self) -> set[str]:
+        return set(self.dirtyvars__)
+
+    def clean(self):
+        self.dirtyvars__.clear()

{amrita-0.7.3.2 → amrita-1.0.0.dev2}/amrita/plugins/chat/__init__.py

@@ -8,7 +8,6 @@ require("nonebot_plugin_localstore")
 
 
 from . import (
-    API,
     builtin_hook,
     config,
     matcher_manager,
@@ -17,7 +16,6 @@ from . import (
 )
 
 __all__ = [
-    "API",
     "builtin_hook",
     "config",
     "matcher_manager",

amrita-1.0.0.dev2/amrita/plugins/chat/builtin_hook.py

@@ -0,0 +1,122 @@
+import json
+import random
+import typing
+from typing import Any
+
+from amrita_core import (
+    ChatObject,
+    PreCompletionEvent,
+    ToolContext,
+    on_precompletion,
+    on_tools,
+)
+from amrita_core.builtins import agent
+from amrita_core.protocol import StringMessageContent
+from nonebot import get_bot
+from nonebot.adapters.onebot.v11 import Bot, MessageEvent
+from nonebot.log import logger
+from nonebot.matcher import Matcher
+
+from amrita.plugins.chat.utils.app import CachedUserDataRepository
+from amrita.plugins.chat.utils.sql import (
+    SEND_MESSAGES,
+    ToolCall,
+    UniResponse,
+    get_any_id,
+)
+from amrita.utils.admin import send_to_admin
+
+from .config import Config, config_manager
+from .utils.libchat import (
+    tools_caller,
+)
+from .utils.llm_tools.builtin_tools import (
+    PROCESS_MESSAGE_TOOL,
+    REPORT_TOOL_HIGH,
+    REPORT_TOOL_LOW,
+    REPORT_TOOL_MEDIUM,
+    report,
+)
+
+checkhook = on_precompletion(1, False)
+
+agent.BUILTIN_TOOLS_NAME.add(REPORT_TOOL_MEDIUM.function.name)
+
+
+@on_tools(
+    data=PROCESS_MESSAGE_TOOL,
+    custom_run=True,
+    enable_if=lambda: config_manager.config.llm.tools.agent_middle_message,
+)
+async def _(ctx: ToolContext) -> str | None:
+    msg: str = ctx.data["content"]
+    logger.debug(f"[LLM-ProcessMessage] {msg}")
+    chatobj: ChatObject = ctx.event.chat_object
+    await chatobj.yield_response(StringMessageContent(msg))
+    return f"Sent a message to user:\n\n```text\n{msg}\n```\n"
+
+
+@checkhook.handle()
+async def text_check(
+    event: PreCompletionEvent, nonebot_event: MessageEvent, nonebot_matcher: Matcher
+) -> None:
+    config: Config = config_manager.config
+    if not config.llm.tools.enable_report:
+        checkhook.pass_event()
+    logger.info("Content checking in progress......")
+    bot = get_bot()
+    match config.llm.tools.report_invoke_level:
+        case "low":
+            tool_list = [REPORT_TOOL_LOW]
+        case "medium":
+            tool_list = [REPORT_TOOL_MEDIUM]
+        case "high":
+            tool_list = [REPORT_TOOL_HIGH]
+        case _:
+            raise ValueError("Invalid report_invoke_level")
+    msg: SEND_MESSAGES = event.get_context_messages().unwrap()
+    dm = CachedUserDataRepository()
+    if (
+        config.llm.tools.report_exclude_context
+        and config.llm.tools.report_exclude_system_prompt
+    ):
+        msg = [event.get_context_messages().get_user_query()]
+    elif config.llm.tools.report_exclude_system_prompt:
+        msg = event.get_context_messages().get_memory()
+    elif config.llm.tools.report_exclude_context:
+        msg = [
+            event.get_context_messages().get_train(),
+            event.get_context_messages().get_user_query(),
+        ]
+    if not msg:
+        logger.warning("Message list is empty, skipping content check")
+        return
+    response: UniResponse[None, list[ToolCall] | None] = await tools_caller(
+        msg, tool_list
+    )
+    if tool_calls := response.tool_calls:
+        for tool_call in tool_calls:
+            function_name = tool_call.function.name
+            function_args: dict[str, Any] = json.loads(tool_call.function.arguments)
+            if function_name == REPORT_TOOL_MEDIUM.function.name:
+                if not function_args.get("invoke"):
+                    return
+                await report(
+                    event,
+                    nonebot_event,
+                    function_args,
+                    typing.cast(Bot, bot),
+                )
+                if config_manager.config.llm.tools.report_then_block:
+                    data = await dm.get_memory(*get_any_id(nonebot_event))
+                    data.memory_json.messages = []
+                    await dm.update_memory_data(data)
+                    await bot.send(
+                        nonebot_event,
+                        random.choice(config_manager.config.llm.block_msg),
+                    )
+                    await nonebot_matcher.finish()
+            else:
+                await send_to_admin(
+                    f"[LLM-Report] Detected non-passed tool call: {function_name}, please feedback this issue to the model provider."
+                )

{amrita-0.7.3.2 → amrita-1.0.0.dev2}/amrita/plugins/chat/check_rule.py

@@ -3,6 +3,7 @@ import random
 import time
 
 import nonebot
+from amrita_core.types import Message
 from nonebot import get_driver, logger
 from nonebot.adapters.onebot.v11 import Bot
 from nonebot.adapters.onebot.v11.event import (
@@ -10,12 +11,12 @@ from nonebot.adapters.onebot.v11.event import (
     GroupMessageEvent,
     MessageEvent,
 )
-from nonebot_plugin_orm import get_session
 from typing_extensions import override
 
+from amrita.plugins.chat.utils.app import CachedUserDataRepository, MemorySchema
 from amrita.plugins.chat.utils.libchat import usage_enough
 from amrita.plugins.chat.utils.lock import get_group_lock, get_private_lock
-from amrita.plugins.chat.utils.models import TextContent
+from amrita.plugins.chat.utils.sql import TextContent
 from amrita.plugins.perm.API.admin import is_lp_admin
 
 from .config import config_manager
@@ -23,14 +24,12 @@ from .utils.functions import (
     get_current_datetime_timestamp,
     synthesize_message,
 )
-from .utils.memory import get_memory_data
-from .utils.models import Message, get_or_create_data
 
 nb_config = get_driver().config
 
 
 class FakeEvent(Event):
-    """伪造事件类，用于模拟用户事件"""
+    """伪事件类，用于模拟用户事件"""
 
     user_id: int
 
@@ -54,12 +53,11 @@ async def is_bot_enabled(event: Event) -> bool:
         bots = set(nonebot.get_bots().keys())
         if event.get_user_id() in bots:  # 多实例下防止冲突
             return False
-    if getattr(event, "group_id", None) is not None:
-        async with get_session() as session:
-            data, _ = await get_or_create_data(
-                session=session, ins_id=getattr(event, "group_id"), is_group=True
-            )
-            return data.enable
+    if (group_id := getattr(event, "group_id", None)) is not None:
+        data = await CachedUserDataRepository().get_group_config(
+            group_id,
+        )
+        return data.enable
     return True
 
 
@@ -100,6 +98,7 @@ async def should_respond_to_message(event: MessageEvent, bot: Bot) -> bool:
         if isinstance(event, GroupMessageEvent)
         else get_private_lock(event.user_id)
     )
+    dm = CachedUserDataRepository()
     async with lock:
         message = event.get_message()
         message_text = message.extract_plain_text().strip()
@@ -130,12 +129,14 @@ async def should_respond_to_message(event: MessageEvent, bot: Bot) -> bool:
             rate = config_manager.config.autoreply.probability
 
             # 获取记忆数据
-            memory_data = await get_memory_data(event)
+            is_group = bool(getattr(event, "group_id", None))
+            ins_id: int = getattr(event, "group_id", event.user_id)
+            memory_data: MemorySchema = await dm.get_memory(ins_id, is_group)
             if rand <= rate and (
                 config_manager.config.autoreply.global_enable or memory_data.fake_people
             ):
-                memory_data.timestamp = time.time()
-                await memory_data.save(event)
+                memory_data.memory_json.time = time.time()
+                await dm.update_memory_data(memory_data)
                 return True
             # 合成消息内容
             content = await synthesize_message(message, bot)
@@ -175,35 +176,34 @@ async def should_respond_to_message(event: MessageEvent, bot: Bot) -> bool:
             # 生成消息内容并记录到记忆
             content_message = f"[{role}][{Date}][{user_name}（{user_id}）]说:{content}"
             if (
-                not len(memory_data.memory.messages) > 1
-                or memory_data.memory.messages[-1].role != "user"
-                or (not memory_data.memory.messages[-1].content)
+                not len(memory_data.memory_json.messages) > 1
+                or memory_data.memory_json.messages[-1].role != "user"
+                or (not memory_data.memory_json.messages[-1].content)
             ):
-                memory_data.memory.messages.append(
+                memory_data.memory_json.messages.append(
                     Message(
                         role="user",
                         content=[TextContent(type="text", text=content_message)],
                     )
                 )
-            elif isinstance(memory_data.memory.messages[-1].content, str):
-                memory_data.memory.messages[-1].content = [
+            elif isinstance(memory_data.memory_json.messages[-1].content, str):
+                memory_data.memory_json.messages[-1].content = [
                     TextContent(
-                        type="text", text=str(memory_data.memory.messages[-1].content)
+                        type="text",
+                        text=str(memory_data.memory_json.messages[-1].content),
                     ),
                     TextContent(type="text", text=content_message),
                 ]
             else:
-                assert isinstance(memory_data.memory.messages[-1].content, list)
-                if len(memory_data.memory.messages[-1].content) >= 100:
-                    memory_data.memory.messages[
+                assert isinstance(memory_data.memory_json.messages[-1].content, list)
+                if len(memory_data.memory_json.messages[-1].content) >= 100:
+                    memory_data.memory_json.messages[
                         -1
-                    ].content = memory_data.memory.messages[-1].content[-100:]
-                memory_data.memory.messages[-1].content.append(
+                    ].content = memory_data.memory_json.messages[-1].content[-100:]
+                memory_data.memory_json.messages[-1].content.append(
                     TextContent(type="text", text=content_message)
                 )
-            # 写入记忆数据
-            await memory_data.save(event)
-
+            await dm.update_memory_data(memory_data)
         # 默认返回 False
         return False
 
@@ -219,7 +219,10 @@ async def should_respond_with_usage_check(event: MessageEvent, bot: Bot) -> bool
         ):
             if event.is_tome():
                 with contextlib.suppress(Exception):
-                    await bot.send(event, "今天的聊天额度已经用完了～")
+                    await bot.send(
+                        event,
+                        random.choice(config_manager.config.usage_limit.limit_msg),
+                    )
                     return False
             return False
         return True