nonebot-plugin-group-chat-memory 0.1.3__tar.gz → 0.1.4__tar.gz

{nonebot_plugin_group_chat_memory-0.1.3 → nonebot_plugin_group_chat_memory-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nonebot-plugin-group-chat-memory
-Version: 0.1.3
+Version: 0.1.4
 Summary: 为 NoneBot2 群聊提供共享长期记忆、点名对话和按群概率回复
 License-Expression: MIT
 License-File: LICENSE
@@ -105,6 +105,7 @@ COMMAND_START=["/"]
 | `GROUP_CHAT_MEMORY_LONG_TERM_MEMORIES` | `5` | 每次回复最多检索的长期片段数；设为 0 可停用长期检索。 |
 | `GROUP_CHAT_MEMORY_CONTEXT_MAX_CHARS` | `6000` | 发送给聊天模型的上下文总字符预算，至少为 1；优先保留当前消息和最近消息。 |
 | `GROUP_CHAT_MEMORY_DEFAULT_PROBABILITY` | `0` | 新群随机回复概率，范围 0～100；已有群使用数据库中的概率。 |
+| `GROUP_CHAT_MEMORY_HOURLY_REQUEST_LIMIT` | `10` | 新群默认每小时模型请求上限，范围 1～10000；已有群可用 `/每小时次数` 修改。 |
 | `GROUP_CHAT_MEMORY_IGNORED_QQ` | `[]` | 完全忽略的 QQ 号 JSON 数组，例如 `[12345, 67890]`；这些账号的消息不记忆也不触发回复。 |
 | `GROUP_CHAT_MEMORY_SYSTEM_PROMPT` | 内置“馒头 + 五更琉璃（黑猫）式性格”人格 | 自定义系统提示词并完全覆盖默认人格；设为空时仅使用内置的发言者区分和当前消息约束。 |
 
@@ -114,7 +115,9 @@ COMMAND_START=["/"]
 
 在群里 @Bot 或回复 Bot 的消息即可对话；这两种定向消息必定进入回复队列，不受随机概率影响。普通纯文本按当前群概率触发，默认 0% 表示关闭随机回复，100% 表示每条符合条件的普通文本都回复。
 
-默认人格为“馒头”：Bot 始终以馒头自称，借用五更琉璃（黑猫）的中二、毒舌、傲娇和外冷内热性格，但不会冒充黑猫本人。插件命令优先级为 `-1`，群聊消息优先级为 `0`；@Bot 或回复 Bot 处理完成后会停止事件继续传播，避免其他 NoneBot 插件同时响应。普通群聊仍不会阻塞其他插件。
+默认人格为“馒头”：Bot 始终以馒头自称，借用五更琉璃（黑猫）的中二、毒舌、傲娇和外冷内热性格，但不会冒充黑猫本人。插件命令优先级为 `-1001`，群聊消息优先级为 `-1000`；@Bot 或回复 Bot 处理完成后会停止事件继续传播，避免其他 NoneBot 插件同时响应。普通群聊仍不会阻塞其他插件。
+
+每个群默认每小时最多触发 10 次模型请求，采用滚动 60 分钟窗口。点名超额会收到简短提示，随机回复超额静默跳过；消息仍写入记忆，命令和 Embedding 不消耗次数。
 
 | 命令 | 权限 | 行为 |
 |---|---|---|
@@ -125,7 +128,9 @@ COMMAND_START=["/"]
 | `/模型配置` | SUPERUSER，私聊或群聊 | 查询全局配置状态，密钥只显示掩码。 |
 | `/回复概率` | 仅 SUPERUSER | 查询当前群概率，显示一位小数。 |
 | `/回复概率 <0～100>` | 仅 SUPERUSER | 设置当前群概率，最多一位小数，例如 `/回复概率 5.5`。 |
-| `/清空群记忆` | 仅 SUPERUSER | 删除当前群原始消息、分块和向量；保留当前群概率，不影响其他群。 |
+| `/每小时次数` | 仅 SUPERUSER | 查询当前群每小时模型请求上限。 |
+| `/每小时次数 <1～10000>` | 仅 SUPERUSER | 设置当前群每小时请求上限，例如 `/每小时次数 20`。 |
+| `/清空群记忆` | 仅 SUPERUSER | 删除当前群原始消息、分块、向量和请求计数；保留概率与每小时上限，不影响其他群。 |
 
 非 SUPERUSER 会收到简短权限提示。命令不进入记忆，也不触发随机回复。SUPERUSER 通过 NoneBot 的 `SUPERUSERS` 配置，而不是群管理员身份确定。
 

{nonebot_plugin_group_chat_memory-0.1.3 → nonebot_plugin_group_chat_memory-0.1.4}/README.md

@@ -79,6 +79,7 @@ COMMAND_START=["/"]
 | `GROUP_CHAT_MEMORY_LONG_TERM_MEMORIES` | `5` | 每次回复最多检索的长期片段数；设为 0 可停用长期检索。 |
 | `GROUP_CHAT_MEMORY_CONTEXT_MAX_CHARS` | `6000` | 发送给聊天模型的上下文总字符预算，至少为 1；优先保留当前消息和最近消息。 |
 | `GROUP_CHAT_MEMORY_DEFAULT_PROBABILITY` | `0` | 新群随机回复概率，范围 0～100；已有群使用数据库中的概率。 |
+| `GROUP_CHAT_MEMORY_HOURLY_REQUEST_LIMIT` | `10` | 新群默认每小时模型请求上限，范围 1～10000；已有群可用 `/每小时次数` 修改。 |
 | `GROUP_CHAT_MEMORY_IGNORED_QQ` | `[]` | 完全忽略的 QQ 号 JSON 数组，例如 `[12345, 67890]`；这些账号的消息不记忆也不触发回复。 |
 | `GROUP_CHAT_MEMORY_SYSTEM_PROMPT` | 内置“馒头 + 五更琉璃（黑猫）式性格”人格 | 自定义系统提示词并完全覆盖默认人格；设为空时仅使用内置的发言者区分和当前消息约束。 |
 
@@ -88,7 +89,9 @@ COMMAND_START=["/"]
 
 在群里 @Bot 或回复 Bot 的消息即可对话；这两种定向消息必定进入回复队列，不受随机概率影响。普通纯文本按当前群概率触发，默认 0% 表示关闭随机回复，100% 表示每条符合条件的普通文本都回复。
 
-默认人格为“馒头”：Bot 始终以馒头自称，借用五更琉璃（黑猫）的中二、毒舌、傲娇和外冷内热性格，但不会冒充黑猫本人。插件命令优先级为 `-1`，群聊消息优先级为 `0`；@Bot 或回复 Bot 处理完成后会停止事件继续传播，避免其他 NoneBot 插件同时响应。普通群聊仍不会阻塞其他插件。
+默认人格为“馒头”：Bot 始终以馒头自称，借用五更琉璃（黑猫）的中二、毒舌、傲娇和外冷内热性格，但不会冒充黑猫本人。插件命令优先级为 `-1001`，群聊消息优先级为 `-1000`；@Bot 或回复 Bot 处理完成后会停止事件继续传播，避免其他 NoneBot 插件同时响应。普通群聊仍不会阻塞其他插件。
+
+每个群默认每小时最多触发 10 次模型请求，采用滚动 60 分钟窗口。点名超额会收到简短提示，随机回复超额静默跳过；消息仍写入记忆，命令和 Embedding 不消耗次数。
 
 | 命令 | 权限 | 行为 |
 |---|---|---|
@@ -99,7 +102,9 @@ COMMAND_START=["/"]
 | `/模型配置` | SUPERUSER，私聊或群聊 | 查询全局配置状态，密钥只显示掩码。 |
 | `/回复概率` | 仅 SUPERUSER | 查询当前群概率，显示一位小数。 |
 | `/回复概率 <0～100>` | 仅 SUPERUSER | 设置当前群概率，最多一位小数，例如 `/回复概率 5.5`。 |
-| `/清空群记忆` | 仅 SUPERUSER | 删除当前群原始消息、分块和向量；保留当前群概率，不影响其他群。 |
+| `/每小时次数` | 仅 SUPERUSER | 查询当前群每小时模型请求上限。 |
+| `/每小时次数 <1～10000>` | 仅 SUPERUSER | 设置当前群每小时请求上限，例如 `/每小时次数 20`。 |
+| `/清空群记忆` | 仅 SUPERUSER | 删除当前群原始消息、分块、向量和请求计数；保留概率与每小时上限，不影响其他群。 |
 
 非 SUPERUSER 会收到简短权限提示。命令不进入记忆，也不触发随机回复。SUPERUSER 通过 NoneBot 的 `SUPERUSERS` 配置，而不是群管理员身份确定。
 

{nonebot_plugin_group_chat_memory-0.1.3 → nonebot_plugin_group_chat_memory-0.1.4}/nonebot_plugin_group_chat_memory/config.py

@@ -67,6 +67,7 @@ class Config(BaseModel):
     group_chat_memory_long_term_memories: int = Field(default=5, ge=0)
     group_chat_memory_context_max_chars: int = Field(default=6000, ge=1)
     group_chat_memory_default_probability: float = Field(default=0.0, ge=0.0, le=100.0)
+    group_chat_memory_hourly_request_limit: int = Field(default=10, ge=1, le=10000)
     group_chat_memory_ignored_qq: set[int] = Field(default_factory=set)
     group_chat_memory_system_prompt: str = DEFAULT_SYSTEM_PROMPT
 

{nonebot_plugin_group_chat_memory-0.1.3 → nonebot_plugin_group_chat_memory-0.1.4}/nonebot_plugin_group_chat_memory/handlers.py

@@ -35,6 +35,8 @@ logger = logging.getLogger(__name__)
 GENERIC_REPLY_ERROR = "暂时无法生成回复，请稍后再试。"
 PERMISSION_DENIED = "仅 SUPERUSER 可执行此命令。"
 INVALID_PROBABILITY = "概率需为 0～100 的数字，最多一位小数。"
+INVALID_HOURLY_LIMIT = "每小时请求上限必须是 1 到 10000 的整数。"
+RATE_LIMIT_NOTICE = "本群本小时请求次数已用完，请稍后再来。"
 PROBABILITY_PATTERN = re.compile(r"(?:100(?:\.0)?|\d{1,2}(?:\.\d)?)")
 SECRET_COMMAND_LOG_PATTERN = re.compile(r"(设置聊天密钥|设置向量密钥)\s+[^\r\n]*")
 
@@ -138,11 +140,11 @@ async def apply_setting(key: str, value: str) -> None:
         config.apply_runtime_config(values)
 
 
-chat_url_matcher = on_command("设置聊天地址", priority=-1, block=True)
-chat_key_matcher = on_command("设置聊天密钥", priority=-1, block=True)
-chat_model_matcher = on_command("设置聊天模型", priority=-1, block=True)
-embedding_key_matcher = on_command("设置向量密钥", priority=-1, block=True)
-model_config_matcher = on_command("模型配置", priority=-1, block=True)
+chat_url_matcher = on_command("设置聊天地址", priority=-1001, block=True)
+chat_key_matcher = on_command("设置聊天密钥", priority=-1001, block=True)
+chat_model_matcher = on_command("设置聊天模型", priority=-1001, block=True)
+embedding_key_matcher = on_command("设置向量密钥", priority=-1001, block=True)
+model_config_matcher = on_command("模型配置", priority=-1001, block=True)
 
 
 def _valid_http_url(value: str) -> bool:
@@ -226,10 +228,15 @@ async def handle_model_config(bot: Bot, event: MessageEvent) -> None:
 
 
 probability_matcher = on_command(
-    "回复概率", rule=_eligible_group_message, priority=-1, block=True
+    "回复概率", rule=_eligible_group_message, priority=-1001, block=True
 )
-clear_matcher = on_command("清空群记忆", rule=_eligible_group_message, priority=-1, block=True)
-group_message_matcher = on_message(rule=_eligible_group_message, priority=0, block=False)
+clear_matcher = on_command(
+    "清空群记忆", rule=_eligible_group_message, priority=-1001, block=True
+)
+hourly_limit_matcher = on_command(
+    "每小时次数", rule=_eligible_group_message, priority=-1001, block=True
+)
+group_message_matcher = on_message(rule=_eligible_group_message, priority=-1000, block=False)
 
 
 @probability_matcher.handle()
@@ -261,6 +268,27 @@ async def handle_clear(bot: Bot, event: GroupMessageEvent) -> None:
     await clear_matcher.finish("已清空当前群记忆。")
 
 
+@hourly_limit_matcher.handle()
+async def handle_hourly_limit(
+    bot: Bot,
+    event: GroupMessageEvent,
+    args: Annotated[Message, CommandArg()],
+) -> None:
+    if not await SUPERUSER(bot, event):
+        await hourly_limit_matcher.finish(PERMISSION_DENIED)
+
+    text = args.extract_plain_text().strip()
+    if not text:
+        limit = await store.get_hourly_limit(event.group_id)
+        await hourly_limit_matcher.finish(f"当前群每小时请求上限：{limit} 次")
+    if not text.isdigit() or not 1 <= int(text) <= 10000:
+        await hourly_limit_matcher.finish(INVALID_HOURLY_LIMIT)
+
+    limit = int(text)
+    await store.set_hourly_limit(event.group_id, limit)
+    await hourly_limit_matcher.finish(f"已设置当前群每小时请求上限：{limit} 次")
+
+
 @group_message_matcher.handle()
 async def handle_group_message(bot: Bot, event: GroupMessageEvent) -> None:
     explicit_at = any(
@@ -288,12 +316,16 @@ async def handle_group_message(bot: Bot, event: GroupMessageEvent) -> None:
     _bots[event.group_id] = bot
     await writer.record(memory_message)
     if directed:
-        coordinator.submit(event.group_id, memory_message, explicit=True)
+        if await store.consume_request_slot(event.group_id):
+            coordinator.submit(event.group_id, memory_message, explicit=True)
+        else:
+            await bot.send_group_msg(group_id=event.group_id, message=RATE_LIMIT_NOTICE)
         raise StopPropagation
     elif (
         event.reply is None
         and all(segment.type == "text" for segment in event.message)
         and await coordinator.should_random_reply(event.group_id)
+        and await store.consume_request_slot(event.group_id)
     ):
         coordinator.submit(event.group_id, memory_message, explicit=False)
 

{nonebot_plugin_group_chat_memory-0.1.3 → nonebot_plugin_group_chat_memory-0.1.4}/nonebot_plugin_group_chat_memory/store.py

@@ -7,7 +7,7 @@ import sqlite3
 import struct
 from collections.abc import AsyncIterator, Sequence
 from contextlib import asynccontextmanager, suppress
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 
 import aiosqlite
 import sqlite_vec
@@ -41,10 +41,23 @@ _SCHEMA_STATEMENTS = (
         group_id INTEGER PRIMARY KEY,
         probability REAL NOT NULL DEFAULT 0
             CHECK (probability >= 0 AND probability <= 100),
+        hourly_limit INTEGER NOT NULL DEFAULT 10
+            CHECK (hourly_limit >= 1 AND hourly_limit <= 10000),
         updated_at TEXT NOT NULL
     )
     """,
     """
+    CREATE TABLE IF NOT EXISTS request_usage (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        group_id INTEGER NOT NULL REFERENCES groups(group_id) ON DELETE CASCADE,
+        requested_at REAL NOT NULL
+    )
+    """,
+    """
+    CREATE INDEX IF NOT EXISTS idx_request_usage_group_time
+        ON request_usage(group_id, requested_at)
+    """,
+    """
     CREATE TABLE IF NOT EXISTS chunks (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         group_id INTEGER NOT NULL REFERENCES groups(group_id) ON DELETE CASCADE,
@@ -104,6 +117,7 @@ class MemoryStore:
         self._config = config
         self._dimensions = config.group_chat_memory_embedding_dimensions
         self._default_probability = config.group_chat_memory_default_probability
+        self._default_hourly_limit = config.group_chat_memory_hourly_request_limit
         self._db: aiosqlite.Connection | None = None
         self._use_sqlite_vec = False
         self._lock = asyncio.Lock()
@@ -147,6 +161,7 @@ class MemoryStore:
                 async with self._transaction_on(db) as tx:
                     for statement in _SCHEMA_STATEMENTS:
                         await tx.execute(statement)
+                    await self._ensure_groups_hourly_limit(tx)
                     await self._ensure_dimensions(tx)
                     if use_sqlite_vec:
                         await tx.execute(
@@ -243,6 +258,88 @@ class MemoryStore:
                 (group_id, probability, _format_timestamp(_utc_now())),
             )
 
+    async def get_hourly_limit(self, group_id: int) -> int:
+        """返回当前群每小时模型请求上限。"""
+        async with self._lock:
+            db = self._require_db()
+            cursor = await db.execute(
+                "SELECT hourly_limit FROM groups WHERE group_id = ?", (group_id,)
+            )
+            row = await cursor.fetchone()
+            await cursor.close()
+        if row is None:
+            return self._default_hourly_limit
+        return int(row["hourly_limit"])
+
+    async def set_hourly_limit(self, group_id: int, value: int) -> None:
+        """设置当前群每小时模型请求上限，范围 1 到 10000。"""
+        limit = int(value)
+        if not 1 <= limit <= 10000:
+            raise ValueError("每小时请求上限必须是 1 到 10000 的整数。")
+        async with self._transaction() as db:
+            await db.execute(
+                "INSERT INTO groups(group_id, probability, hourly_limit, updated_at) "
+                "VALUES (?, ?, ?, ?) ON CONFLICT(group_id) DO UPDATE SET "
+                "hourly_limit = excluded.hourly_limit, updated_at = excluded.updated_at",
+                (
+                    group_id,
+                    self._default_probability,
+                    limit,
+                    _format_timestamp(_utc_now()),
+                ),
+            )
+
+    async def consume_request_slot(
+        self, group_id: int, now: datetime | None = None
+    ) -> bool:
+        """在滚动 60 分钟窗口内尝试占用一次模型请求名额。"""
+        current = _as_utc(now or _utc_now())
+        timestamp = current.timestamp()
+        cutoff = (current - timedelta(hours=1)).timestamp()
+        async with self._transaction() as db:
+            await self._ensure_group(db, group_id)
+            await db.execute(
+                "DELETE FROM request_usage WHERE group_id = ? AND requested_at <= ?",
+                (group_id, cutoff),
+            )
+            cursor = await db.execute(
+                "SELECT count(*) AS usage FROM request_usage WHERE group_id = ?",
+                (group_id,),
+            )
+            row = await cursor.fetchone()
+            await cursor.close()
+            cursor = await db.execute(
+                "SELECT hourly_limit FROM groups WHERE group_id = ?", (group_id,)
+            )
+            group_row = await cursor.fetchone()
+            await cursor.close()
+            limit = (
+                int(group_row["hourly_limit"])
+                if group_row is not None
+                else self._default_hourly_limit
+            )
+            if row is not None and int(row["usage"]) >= limit:
+                return False
+            await db.execute(
+                "INSERT INTO request_usage(group_id, requested_at) VALUES (?, ?)",
+                (group_id, timestamp),
+            )
+            return True
+
+    async def get_hour_usage(self, group_id: int, now: datetime | None = None) -> int:
+        """返回当前群滚动 60 分钟窗口内已占用的请求次数。"""
+        cutoff = (_as_utc(now or _utc_now()) - timedelta(hours=1)).timestamp()
+        async with self._lock:
+            db = self._require_db()
+            cursor = await db.execute(
+                "SELECT count(*) AS usage FROM request_usage "
+                "WHERE group_id = ? AND requested_at > ?",
+                (group_id, cutoff),
+            )
+            row = await cursor.fetchone()
+            await cursor.close()
+        return int(row["usage"]) if row is not None else 0
+
     async def get_runtime_config(self) -> dict[str, str]:
         """读取全 Bot 共用的模型运行时配置。"""
         async with self._lock:
@@ -397,13 +494,14 @@ class MemoryStore:
         return [_row_to_chunk(row) for _, _, row in scored[:limit]]
 
     async def clear_group(self, group_id: int) -> None:
-        """删除当前群的消息、片段与向量，保留概率配置。"""
+        """删除当前群的消息、片段、向量和请求计数，保留概率与每小时上限。"""
         async with self._transaction() as db:
             await db.execute(
                 "DELETE FROM memory_vector_blobs WHERE group_id = ?", (group_id,)
             )
             if self._use_sqlite_vec:
                 await db.execute("DELETE FROM memory_vectors WHERE group_id = ?", (group_id,))
+            await db.execute("DELETE FROM request_usage WHERE group_id = ?", (group_id,))
             await db.execute("DELETE FROM messages WHERE group_id = ?", (group_id,))
             await db.execute("DELETE FROM chunks WHERE group_id = ?", (group_id,))
 
@@ -433,11 +531,26 @@ class MemoryStore:
 
     async def _ensure_group(self, db: aiosqlite.Connection, group_id: int) -> None:
         await db.execute(
-            "INSERT INTO groups(group_id, probability, updated_at) VALUES (?, ?, ?) "
-            "ON CONFLICT(group_id) DO NOTHING",
-            (group_id, self._default_probability, _format_timestamp(_utc_now())),
+            "INSERT INTO groups(group_id, probability, hourly_limit, updated_at) "
+            "VALUES (?, ?, ?, ?) ON CONFLICT(group_id) DO NOTHING",
+            (
+                group_id,
+                self._default_probability,
+                self._default_hourly_limit,
+                _format_timestamp(_utc_now()),
+            ),
         )
 
+    async def _ensure_groups_hourly_limit(self, db: aiosqlite.Connection) -> None:
+        cursor = await db.execute("PRAGMA table_info(groups)")
+        rows = await cursor.fetchall()
+        await cursor.close()
+        if not any(row["name"] == "hourly_limit" for row in rows):
+            await db.execute(
+                f"ALTER TABLE groups ADD COLUMN hourly_limit INTEGER NOT NULL DEFAULT "
+                f"{self._default_hourly_limit}"
+            )
+
     async def _ensure_dimensions(self, db: aiosqlite.Connection) -> None:
         cursor = await db.execute("SELECT value FROM meta WHERE key = ?", (DIMENSIONS_META_KEY,))
         row = await cursor.fetchone()

{nonebot_plugin_group_chat_memory-0.1.3 → nonebot_plugin_group_chat_memory-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nonebot-plugin-group-chat-memory"
-version = "0.1.3"
+version = "0.1.4"
 description = "为 NoneBot2 群聊提供共享长期记忆、点名对话和按群概率回复"
 readme = "README.md"
 authors = [{ name = "TonyLiangP2010405" }]