Undefined-bot 3.18.4__tar.gz → 3.18.5__tar.gz

{undefined_bot-3.18.4 → undefined_bot-3.18.5}/ARCHITECTURE.md

@@ -886,6 +886,8 @@ description: 从 PDF 文件中提取文本和表格，填写表单。当用户
 
 微信接入由主进程独立管理，不依赖 OneBot 是否在线。`WeixinService` 先校验帐号与 peer，再把已绑定来源映射为逻辑 QQ 私聊交给 `MessageHandler`；未知来源在写历史或调用 AI 之前进入隔离存储。`DeliveryAddress` 将逻辑身份与物理通道分离：`qq:<id>` 和 `wechat:<id>` 可共享同一个用户历史、认知记忆与权限，但发送器、消息合并 scope 和 transport 元数据保持通道隔离。自动化同样持久化规范 `address`，旧 `target_type + target_id` 在加载时转换为 `group:` 或 `qq:` 地址。
 
+OneBot 消息处理任务由客户端跨连接跟踪。网络断线只结束接收循环、通知未完成的 API 请求连接失败，不等待媒体下载等处理任务即可重连；已有处理任务继续运行。主动断开、停止或取消连接任务时，会取消并等待这些处理任务收尾，连接建立或重连等待阶段收到取消也会执行同样的清理，避免后台任务遗留。
+
 ### "车站-列车" 队列模型
 
 针对高并发消息处理，Undefined 实现了全新的 **ModelQueue** 调度机制：

{undefined_bot-3.18.4 → undefined_bot-3.18.5}/CHANGELOG.md

@@ -1,3 +1,22 @@
+## v3.18.5 会话恢复、消息投递与并发持久化修复
+
+本版本集中修复聊天续接、消息发送和后台任务在切换会话、取消、断线、重启及写入失败时的状态错乱：保留已经完成的投递与提交，避免重复回复、旧响应覆盖新操作，以及界面显示成功但数据尚未保存的问题。
+
+- 聊天恢复与历史一致性：WebChat 只有在任务收尾、历史落盘并释放会话占用后才确认完成，创建任务失败会撤销占用，删除会话与接收新任务按顺序处理。完整任务快照保留正文、工具调用与嵌套 Agent 时间线，Chat 客户端修复断线续接、旧版事件重放和分页恢复；离线期间已经完成的会话也会刷新，旧连接、旧会话和旧请求的迟到结果不会覆盖当前状态。
+- WebUI 与客户端交互：修复切换会话后发送归属错误、旧轮询重复追加正文、迟到历史清空刚发送的消息，以及发送失败覆盖后续草稿的问题。保存连接配置时暂停请求，将未完成上传标记失败并忽略迟到结果，旧缓存迁移失败保留原数据；日志、工作流、表情包编辑和微信登录弹窗隔离各自请求，刷新与翻页保留未保存的编辑。恢复配置失败会保留表单并显示错误，不再误报恢复成功；登录凭据刷新串行执行，避免并发刷新相互失效。
+- 消息投递不再被后续故障误判：微信按每次服务端确认及时记录已发送状态，支持展开嵌套转发；历史、附件登记或使用统计失败不会把已送达内容当作未发送。分片或批量发送已有部分成功、或投递结果无法确认时，微信、抖音、JM 等业务降级不再重发整条内容；仍保留对明确未投递内容的降级。令牌失效、会话暂停、配置错误及明确的连接前失败保留原异常，不再误标为可能送达；认证问题不触发拆分消息的结构降级。微信帐号变更与客户端启停串行，OneBot 重连不再等待消息处理任务阻塞；arXiv 去重按实际平台与投递地址隔离。
+- 配置保存与热更新：整体保存、增量修改、恢复、模板同步和密码更新共用原子写入顺序，同一时刻的备份不会互相覆盖；取消请求会等已开始的写入与必要更新完成。热更新失败可以重试，监听器重启会补读停止窗口内的修改，连续调整轮询间隔不会留下多个监听任务或继续使用旧间隔。内存构建配置不再意外读取本地文件，损坏的 TOML 即使使用 `strict=False` 也会明确报错。
+- 停止与取消：停止 Bot 先关闭新任务入口，等待已接收的回复、后台任务和持久化收尾，再关闭模型队列与消息通道。新增 `[webui].stop_timeout_seconds`（环境变量 `WEBUI_STOP_TIMEOUT_SECONDS`），**默认 `0` 表示等待自然结束，正整数才会在对应秒数后强制终止**；停止按钮、关闭 WebUI 和更新前停止共用此规则。取消模型请求会同步清理排队及重试任务，普通群聊队列裁剪保留已启动调用所依赖的子请求。新增 `[core].group_llm_queue_max_pending`（默认 `128`，支持热更新），每模型普通群聊 LLM 等待队列满时明确拒绝新请求并清理其等待状态，保留已接收任务与重试；这是排队准入限制，不限制在途调用或总内存，过载时普通自动回复可能结束而不发送消息。
+- 连续消息与工具状态：已经回复完成的投机批次及时结束，后续消息开启新批次，避免把旧输入再次回复；批次取消只作用于对应任务，不会误伤独立的 @ 或拍一拍回复。`task_progress` 在多轮工具调用间共享，技能热重载保留在途统计；多模态分析缓存使用完整媒体来源、类型与补充指令，避免长链接或 data URL 前缀相同而串用结果。
+- 记忆与知识库：长期记忆和会话数据在落盘成功后才发布新状态，取消会等待已开始的提交，写入失败不会让内存与磁盘各自保留不同版本。知识文件替换先完成新内容读取、嵌入和写入，再清理旧索引；读取、嵌入或新块写入失败时保留旧索引供重试。侧写昵称刷新与史官跳过合并时也会补齐检索索引，索引失败不再提前确认完成；记忆时间筛选统一比较含时区与不含时区的时间。
+- 表情包生命周期：重分析不会覆盖期间的人工编辑、恢复已删除内容或影响同 UID 重新入库的记录；停用、删除与附件缓存失效保持一致，搜索不会返回已停用条目。使用统计失败保留发送成功结果，容量清理跳过刚置顶或修改的候选，删除失败保留可重试记录；异常退出遗留的处理任务会在后续轮询中恢复，正在执行的任务不会被重复调度。
+- 自动化流程：持久化按顺序完成，取消不会让旧快照覆盖新状态；嵌套并行循环只合并本轮修改的变量，避免覆盖同级节点刚产生的输出。`loop.times.count=0` 正确跳过循环，旧存档的 `count:null` 兼容默认次数；新建、更新与启用任务仍严格拒绝负数、布尔值、字符串及 `null`。
+- 文件与附件：统一解析本地 `file://` URI，保留中文、空格及原始路径中的百分号；CQ 参数转义与解码保留链接里的逗号、方括号和实体文本。HTTP 压缩响应按传输字节校验完整性、按解压后大小执行容量限制。JM、Bilibili、arXiv 下载及 Python 执行目录在取消后等待后台文件操作结束再清理；JM 配置的会话目录生效，畸形输入和单章异常不再拖垮整次处理。侧写路径与归档解压目标限制在各自目录内，缓存清理拒绝符号链接目录，TAR 解压启用安全过滤。
+- 原生显示与连接：附件下载以独占方式创建文件，避免覆盖同名文件；图片仍显示时保留其 Blob，代码高亮失败回落纯文本，生产构建拆分体积并保留完整语言支持。Console 迁移旧连接时保留协议与 IPv6 地址，Android 生命周期监听即使延迟注册也会在退出后释放。恢复应用时保留刷新途中刚获确认的新任务，同一任务不会重复建立在途 SSE 订阅；迟到旧句柄会关闭，避免覆盖当前订阅或在取消后泄漏。
+- 部署与维护：部署向导中断不再继续写配置，备份名称不冲突，IPv6 服务地址正确加括号；容器模式为 Python 解释器映射宿主 Docker 可见的共享目录，LxMusic 配置变化会触发容器重建。`restore_profile.py restore` 现在同时恢复侧写并同步检索正文与向量，失败后可用 `sync` 补齐，**执行前须停止机器人及其他写入进程**。重嵌入的 `--dry-run` 在临时副本上读取，不修改源向量库，但仍会调用嵌入 API；侧写恢复的 `--dry-run` 不写盘、不调用模型。版本脚本支持失败后重跑，补齐全部版本文件与锁文件，并将此前已修改的版本目标纳入提交。
+
+---
+
 ## v3.18.4 添加宣传片链接
 
 在 README.md 中添加了宣传片链接。

{undefined_bot-3.18.4 → undefined_bot-3.18.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: Undefined-bot
-Version: 3.18.4
+Version: 3.18.5
 Summary: QQ bot platform with cognitive memory architecture and multi-agent Skills, via OneBot V11.
 Project-URL: Repository, https://github.com/69gg/Undefined
 Project-URL: Issues, https://github.com/69gg/Undefined/issues

{undefined_bot-3.18.4 → undefined_bot-3.18.5}/config.toml.example

@@ -28,6 +28,9 @@ context_recent_messages_limit = 20
 # zh: 单次 LLM 请求失败时最大静默重试次数（0=不重试，默认2）。失败的请求会回到原队列的第 2 个位置。
 # en: Max silent retries for a single failed LLM request (0=no retry, default 2). Failed requests are reinserted at position 2 of their original queue lane.
 ai_request_max_retries = 2
+# zh: 每模型普通群聊 LLM 等待队列的新请求准入上限（正整数，默认128，可热更新）。满时拒绝新请求；保留已接收请求和重试，不限制在途调用。
+# en: Per-model admission limit for new ordinary-group queued LLM calls (positive integer, default 128, hot reload). Rejects new calls when full; retains accepted calls and retries, and does not cap in-flight calls.
+group_llm_queue_max_pending = 128
 # zh: 模型返回纯文本但未调用 send_message/end 等工具时的最大纠正重试次数（0=不重试，默认3）。
 # en: Max correction retries when the model returns plain text without tool calls (0=no retry, default 3).
 missing_tool_call_retries = 3
@@ -1611,8 +1614,8 @@ request_timeout = 20.0
 # zh: 图片下载超时（秒）。<=0 回退 60，>600 截断到 600。
 # en: Image download timeout (seconds). <=0 falls back to 60, >600 is clamped to 600.
 image_timeout = 60.0
-# zh: jmcpy 的配置目录（登录态与会话文件所在目录，可指向已登录的 JMCPY_HOME）。留空使用平台默认目录。
-# en: jmcpy config directory (login session files; point it at an existing JMCPY_HOME). Empty uses the platform default directory.
+# zh: jmcpy 的配置目录（登录态与会话文件所在目录）。显式值优先；留空读取 JMCPY_HOME，两者均为空时使用平台默认目录。
+# en: jmcpy config directory (login session files). An explicit value takes precedence; empty falls back to JMCPY_HOME, then the platform default directory.
 session_dir = ""
 
 # zh: Code Delivery Agent 配置（代码交付 Agent，在 Docker 容器中编写代码并打包上传）。
@@ -1685,6 +1688,9 @@ autostart_bot = false
 # zh: 每次打开 WebUI 时是否在后台检查 GitHub Release 更新。
 # en: Check GitHub Releases for updates in the background whenever WebUI is opened.
 check_updates = true
+# zh: 停止机器人时等待优雅收尾的秒数；0 等待自然结束，正整数超时后强制终止。
+# en: Graceful bot shutdown timeout in seconds; 0 waits until completion, positive values force termination after the deadline.
+stop_timeout_seconds = 0
 
 # zh: 微信 ClawBot/iLink 私聊接入。凭据与游标仅写入 state_dir，不写入本配置。
 # zh: 关闭时不会创建网络连接；二维码登录只能从管理界面显式发起。

{undefined_bot-3.18.4 → undefined_bot-3.18.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "Undefined-bot"
-version = "3.18.4"
+version = "3.18.5"
 description = "QQ bot platform with cognitive memory architecture and multi-agent Skills, via OneBot V11."
 readme = "README.md"
 authors = [

{undefined_bot-3.18.4 → undefined_bot-3.18.5}/src/Undefined/__init__.py

@@ -24,7 +24,7 @@ if TYPE_CHECKING:
     from .skills.registry import BaseRegistry as BaseRegistry
     from .skills.tools import ToolRegistry as ToolRegistry
 
-__version__: str = "3.18.4"
+__version__: str = "3.18.5"
 
 # symbol -> (module_path, attribute_name)；首次访问时才 importlib 加载
 _LAZY_IMPORTS: dict[str, tuple[str, str]] = {

{undefined_bot-3.18.4 → undefined_bot-3.18.5}/src/Undefined/ai/client/ask_loop.py

@@ -316,6 +316,7 @@ class ClientAskLoopMixin(ClientQueueMixin):
         # 注入常用资源（用于工具执行）
         tool_context.setdefault("ai_client", self)
         tool_context.setdefault("runtime_config", self._get_runtime_config())
+        tool_context.setdefault("_task_progress", [])
         if not isinstance(
             tool_context.get(MUSIC_TRACK_STORE_CONTEXT_KEY),
             MusicTrackReferenceStore,

{undefined_bot-3.18.4 → undefined_bot-3.18.5}/src/Undefined/ai/client/queue.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+from dataclasses import dataclass
 import logging
 from typing import Any
 from uuid import uuid4
@@ -29,6 +30,19 @@ from Undefined.ai.client.setup import ClientSetupMixin
 logger = logging.getLogger(__name__)
 
 
+@dataclass(slots=True)
+class QueuedLLMCallState:
+    """Share caller cancellation with queued retries and the active model task."""
+
+    cancelled: bool = False
+    task: asyncio.Task[dict[str, Any]] | None = None
+
+    def cancel(self) -> None:
+        self.cancelled = True
+        if self.task is not None and not self.task.done():
+            self.task.cancel()
+
+
 class ClientQueueMixin(ClientSetupMixin):
     """统一队列 LLM 调用与会话摘要投递。"""
 
@@ -107,6 +121,7 @@ class ClientQueueMixin(ClientSetupMixin):
             )
         request_id = uuid4().hex
         event: asyncio.Event = asyncio.Event()
+        call_state = QueuedLLMCallState()
         # 挂起表：QueueManager 回调 set_llm_call_result 时唤醒等待方
         self._pending_llm_calls[request_id] = (event, None)
         model_name = getattr(model_config, "model_name", "default")
@@ -121,6 +136,7 @@ class ClientQueueMixin(ClientSetupMixin):
             "max_tokens": effective_max_tokens,
             "transport_state": transport_state,
             "skip_prefetch_tools": skip_prefetch_tools,
+            "_llm_call_state": call_state,
         }
         ctx = RequestContext.current()
         if ctx is not None:
@@ -168,6 +184,7 @@ class ClientQueueMixin(ClientSetupMixin):
                 )
                 raise
         finally:
+            call_state.cancel()
             entry = self._pending_llm_calls.pop(request_id, None)
         _, result = entry if entry is not None else (None, None)
         if isinstance(result, Exception):

{undefined_bot-3.18.4 → undefined_bot-3.18.5}/src/Undefined/ai/multimodal/analyzer.py

@@ -329,7 +329,7 @@ class MultimodalAnalyzer:
     ) -> dict[str, str]:
         """分析媒体文件。
 
-        始终调用视觉模型进行真实分析，不会因历史缓存而跳过。
+        相同媒体类型、完整来源与补充指令复用本次进程内的分析结果。
 
         Args:
             media_url: 媒体文件 URL 或本地路径
@@ -350,7 +350,11 @@ class MultimodalAnalyzer:
             len(prompt_extra),
         )
 
-        cache_key = f"{detected_type}:{media_url[:100]}:{prompt_extra}"
+        cache_key = hashlib.sha256(
+            json.dumps(
+                [detected_type, media_url, prompt_extra], ensure_ascii=False
+            ).encode("utf-8")
+        ).hexdigest()
         if cache_key in self._cache:
             logger.debug("[媒体分析] 命中缓存: key=%s", cache_key[:120])
             return self._cache[cache_key]

{undefined_bot-3.18.4 → undefined_bot-3.18.5}/src/Undefined/api/_helpers.py

@@ -8,7 +8,7 @@ import json
 import logging
 from contextlib import suppress
 from dataclasses import dataclass
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Awaitable, Callable
 from urllib.parse import urlsplit
 
@@ -191,6 +191,7 @@ def _optional_query_param(request: web.Request, key: str) -> str | None:
 
 
 def _parse_query_time(value: str | None) -> datetime | None:
+    """统一为 UTC；旧记录及无时区查询沿用系统本地时间含义。"""
     text = str(value or "").strip()
     if not text:
         return None
@@ -198,8 +199,8 @@ def _parse_query_time(value: str | None) -> datetime | None:
     if "T" in text:
         candidates.append(text.replace("T", " "))
     for candidate in candidates:
-        with suppress(ValueError):
-            return datetime.fromisoformat(candidate)
+        with suppress(ValueError, OverflowError, OSError):
+            return datetime.fromisoformat(candidate).astimezone(timezone.utc)
     return None
 
 

{undefined_bot-3.18.4 → undefined_bot-3.18.5}/src/Undefined/api/app.py

@@ -44,6 +44,8 @@ from .routes import (
 
 logger = logging.getLogger(__name__)
 
+RUNTIME_API_CONTEXT_APP_KEY = web.AppKey("runtime_api_context", RuntimeAPIContext)
+
 
 class RuntimeAPIServer:
     def __init__(
@@ -60,6 +62,8 @@ class RuntimeAPIServer:
         self._runner: web.AppRunner | None = None
         self._sites: list[web.TCPSite] = []
         self._background_tasks: set[asyncio.Task[Any]] = set()
+        self._request_tasks: set[asyncio.Task[Any]] = set()
+        self._stopping = False
         self._naga_state = NagaState()
         self._chat_job_manager = chat.ChatJobManager(context)
         transport = getattr(context.onebot, "file_transport", None)
@@ -94,10 +98,22 @@ class RuntimeAPIServer:
         cfg = self._context.config_getter()
         logger.info("[RuntimeAPI] 已启动: %s", cfg.api.display_url)
 
+    def begin_shutdown(self) -> None:
+        """关闭普通 API 接入，但保留待发 OneBot 文件的 HTTP 服务。"""
+        self._stopping = True
+        self._chat_job_manager.begin_shutdown()
+
+    async def drain_requests(self) -> None:
+        await self._chat_job_manager.stop()
+        tasks = self._request_tasks - {asyncio.current_task()}
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
+
     async def stop(self) -> None:
+        self.begin_shutdown()
+        await self.drain_requests()
         if self._file_store is not None:
             self._file_store.unavailable()
-        await self._chat_job_manager.stop()
 
         for task in self._background_tasks:
             task.cancel()
@@ -140,12 +156,24 @@ class RuntimeAPIServer:
                         response = _json_error("Unauthorized", status=401)
                         _apply_cors_headers(request, response)
                         return response
-            response = await handler(request)
+            is_file_request = onebot_files.is_file_request(request)
+            if self._stopping and not is_file_request:
+                response = _json_error("Runtime is shutting down", status=503)
+                _apply_cors_headers(request, response)
+                return response
+            task = asyncio.current_task()
+            if task is not None and not is_file_request:
+                self._request_tasks.add(task)
+            try:
+                response = await handler(request)
+            finally:
+                if task is not None:
+                    self._request_tasks.discard(task)
             _apply_cors_headers(request, response)
             return response
 
         app = web.Application(middlewares=[_auth_middleware])
-        app["runtime_api_context"] = self._context
+        app[RUNTIME_API_CONTEXT_APP_KEY] = self._context
         app.add_routes(
             [
                 web.get("/health", self._health_handler),

{undefined_bot-3.18.4 → undefined_bot-3.18.5}/src/Undefined/api/routes/chat.py

@@ -260,6 +260,14 @@ class ChatJob:
         now = time.time()
         elapsed_ms = _job_elapsed_ms(self, now)
         stage_elapsed_ms = _stage_elapsed_ms(self, now)
+        timeline_events = (
+            _finalize_webchat_history_events(self)
+            if self.status in {"done", "error", "cancelled"}
+            else [
+                {"seq": item.seq, "event": item.event, "payload": dict(item.payload)}
+                for item in self.webchat_events
+            ]
+        )
         return {
             "job_id": self.job_id,
             "conversation_id": self.conversation_id,
@@ -280,7 +288,9 @@ class ChatJob:
             "messages": list(self.outputs),
             "current_agent_stages": self.current_agent_stage_snapshots(now),
             "current_tool_calls": self.current_tool_call_snapshots(now),
-            "history_finalized": self.history_finalized,
+            "current_timeline": _build_webchat_timeline(timeline_events),
+            # 对外完成信号与新任务/历史修改的放行门槛一致。
+            "history_finalized": self.history_finalized and self.done.is_set(),
             "waiting_input": None,
         }
 
@@ -378,14 +388,23 @@ class ChatJob:
         return payloads
 
 
+class ChatJobManagerClosingError(RuntimeError):
+    """Runtime 正在收尾，不能接受新的聊天任务。"""
+
+
 class ChatJobManager:
     def __init__(self, ctx: RuntimeAPIContext) -> None:
         self._ctx = ctx
         self._jobs: dict[str, ChatJob] = {}
         self._lock = asyncio.Lock()
+        self._closing = False
         self._title_schedule_lock = asyncio.Lock()
         self.conversation_store = WebChatConversationStore()
 
+    def begin_shutdown(self) -> None:
+        """立即关闭任务创建入口，已有任务由 stop 收尾。"""
+        self._closing = True
+
     async def create_job(
         self,
         text: str,
@@ -396,68 +415,84 @@ class ChatJobManager:
         pre_record_user_history: bool = False,
         reuse_previous_user_history: bool = False,
     ) -> ChatJob:
+        if self._closing:
+            raise ChatJobManagerClosingError("Chat service is stopping")
         await self.conversation_store.ensure_ready(self._ctx.history_manager)
         requested_conversation_id = str(conversation_id or "").strip()
         resolved_conversation_id = requested_conversation_id or _DEFAULT_CONVERSATION_ID
-        conversation = await self.conversation_store.get_conversation(
-            resolved_conversation_id
-        )
-        if conversation is None:
-            if requested_conversation_id:
-                raise KeyError(resolved_conversation_id)
-            conversation = await self.conversation_store.ensure_default_conversation()
-            resolved_conversation_id = str(conversation["id"])
-        now = time.time()
-        job = ChatJob(
-            job_id=uuid4().hex,
-            text=text,
-            created_at=now,
-            updated_at=now,
-            conversation_id=resolved_conversation_id,
-            user_history_attachments=list(user_history_attachments or []),
-            user_history_references=list(user_history_references or []),
-            user_history_pre_recorded=pre_record_user_history
-            or reuse_previous_user_history,
-        )
         async with self._lock:
+            if self._closing:
+                raise ChatJobManagerClosingError("Chat service is stopping")
+            # 会话存在性检查与 job 接受必须和删除共用同一串行边界。
+            # 历史写入也在锁内，其他会话需等待写入完成，确保 stop/删除不会漏掉在途创建。
+            conversation = await self.conversation_store.get_conversation(
+                resolved_conversation_id
+            )
+            if conversation is None:
+                if requested_conversation_id:
+                    raise KeyError(resolved_conversation_id)
+                conversation = (
+                    await self.conversation_store.ensure_default_conversation()
+                )
+                resolved_conversation_id = str(conversation["id"])
             if any(
                 self._job_blocks_history_mutation(existing)
                 for existing in self._jobs.values()
                 if existing.conversation_id == resolved_conversation_id
             ):
                 raise RuntimeError("Chat job is still running")
-            self._jobs[job.job_id] = job
-        if pre_record_user_history:
-            await self.conversation_store.append_message(
-                resolved_conversation_id,
-                role="user",
-                text_content=text,
-                display_name=_VIRTUAL_USER_NAME,
-                user_name=_VIRTUAL_USER_NAME,
-                attachments=job.user_history_attachments or None,
-                references=job.user_history_references or None,
+            now = time.time()
+            job = ChatJob(
+                job_id=uuid4().hex,
+                text=text,
+                created_at=now,
+                updated_at=now,
+                conversation_id=resolved_conversation_id,
+                user_history_attachments=list(user_history_attachments or []),
+                user_history_references=list(user_history_references or []),
+                user_history_pre_recorded=pre_record_user_history
+                or reuse_previous_user_history,
             )
+            self._jobs[job.job_id] = job
+            try:
+                # stop 必须等创建阶段收敛后再快照，避免漏掉稍后才启动的 task。
+                if pre_record_user_history:
+                    await self.conversation_store.append_message(
+                        resolved_conversation_id,
+                        role="user",
+                        text_content=text,
+                        display_name=_VIRTUAL_USER_NAME,
+                        user_name=_VIRTUAL_USER_NAME,
+                        attachments=job.user_history_attachments or None,
+                        references=job.user_history_references or None,
+                    )
+                await self._append_event(
+                    job,
+                    "meta",
+                    {
+                        "job_id": job.job_id,
+                        "conversation_id": job.conversation_id,
+                        "virtual_user_id": _VIRTUAL_USER_ID,
+                        "permission": "superadmin",
+                    },
+                )
+                await self._append_stage(job, "received")
+                job.task = asyncio.create_task(
+                    self._run_job(job), name=f"webchat:{job.job_id}"
+                )
+            except BaseException:
+                self._jobs.pop(job.job_id, None)
+                raise
         logger.info(
             "[RuntimeAPI][WebChat] 创建 job: job_id=%s conversation_id=%s text_len=%s",
             job.job_id,
             job.conversation_id,
             len(text),
         )
-        await self._append_event(
-            job,
-            "meta",
-            {
-                "job_id": job.job_id,
-                "conversation_id": job.conversation_id,
-                "virtual_user_id": _VIRTUAL_USER_ID,
-                "permission": "superadmin",
-            },
-        )
-        await self._append_stage(job, "received")
-        job.task = asyncio.create_task(self._run_job(job), name=f"webchat:{job.job_id}")
         return job
 
     async def stop(self) -> None:
+        self.begin_shutdown()
         async with self._lock:
             jobs = list(self._jobs.values())
         for job in jobs:
@@ -565,6 +600,18 @@ class ChatJobManager:
                 or 0
             )
 
+    async def delete_conversation_when_idle(self, conversation_id: str) -> bool | None:
+        """删除空闲会话；None 表示会话仍被已接受的任务占用。"""
+        await self.conversation_store.ensure_ready(self._ctx.history_manager)
+        async with self._lock:
+            if any(
+                self._job_blocks_history_mutation(job)
+                and job.conversation_id == conversation_id
+                for job in self._jobs.values()
+            ):
+                return None
+            return await self.conversation_store.delete_conversation(conversation_id)
+
     async def cancel_job(self, job_id: str) -> ChatJob | None:
         job = await self.get_job(job_id)
         if job is None:
@@ -926,9 +973,8 @@ class ChatJobManager:
         if len(job.events) > _CHAT_JOB_EVENT_BUFFER_LIMIT:
             job.events = job.events[-_CHAT_JOB_EVENT_BUFFER_LIMIT:]
         if item.event in _WEBCHAT_HISTORY_EVENTS:
+            # 展示快照与历史需要完整内容；只有 SSE 重放缓冲采用固定上限。
             job.webchat_events.append(item)
-            if len(job.webchat_events) > _CHAT_JOB_EVENT_BUFFER_LIMIT:
-                job.webchat_events = job.webchat_events[-_CHAT_JOB_EVENT_BUFFER_LIMIT:]
         job.changed.notify_all()
         return item
 
@@ -2810,11 +2856,10 @@ async def chat_conversation_delete_handler(
     job_manager: ChatJobManager,
     request: web.Request,
 ) -> Response:
-    await job_manager.conversation_store.ensure_ready(ctx.history_manager)
     conversation_id = str(request.match_info.get("conversation_id", "") or "").strip()
-    if await job_manager.has_running_job(conversation_id):
+    existed = await job_manager.delete_conversation_when_idle(conversation_id)
+    if existed is None:
         return _json_error("Chat job is still running", status=409)
-    existed = await job_manager.conversation_store.delete_conversation(conversation_id)
     if not existed:
         return _json_error("Conversation not found", status=404)
     logger.info(
@@ -2955,6 +3000,8 @@ async def chat_handler(
             job = await job_manager.create_job(text, conversation_id)
         except KeyError:
             return _json_error("Conversation not found", status=404)
+        except ChatJobManagerClosingError as exc:
+            return _json_error(str(exc), status=503)
         except RuntimeError:
             return _json_error("Chat job is still running", status=409)
         try:
@@ -2988,6 +3035,8 @@ async def chat_handler(
         job = await job_manager.create_job(text, conversation_id)
     except KeyError:
         return _json_error("Conversation not found", status=404)
+    except ChatJobManagerClosingError as exc:
+        return _json_error(str(exc), status=503)
     except RuntimeError:
         return _json_error("Chat job is still running", status=409)
     logger.info(
@@ -3105,6 +3154,8 @@ async def chat_job_create_handler(
         return _json_error("Attachment not found", status=404)
     except ValueError as exc:
         return _json_error(str(exc), status=400)
+    except ChatJobManagerClosingError as exc:
+        return _json_error(str(exc), status=503)
     except RuntimeError:
         return _json_error("Chat job is still running", status=409)
     logger.info(

{undefined_bot-3.18.4 → undefined_bot-3.18.5}/src/Undefined/api/routes/cognitive.py

@@ -75,7 +75,10 @@ async def cognitive_profile_handler(
     if not entity_type or not entity_id:
         return _json_error("entity_type/entity_id are required", status=400)
 
-    profile = await cognitive_service.get_profile(entity_type, entity_id)
+    try:
+        profile = await cognitive_service.get_profile(entity_type, entity_id)
+    except ValueError as exc:
+        return _json_error(str(exc), status=400)
     return web.json_response(
         {
             "entity_type": entity_type,

{undefined_bot-3.18.4 → undefined_bot-3.18.5}/src/Undefined/api/routes/memory.py

@@ -104,7 +104,10 @@ async def memory_create_handler(
     fact = str(body.get("fact", "") or "").strip()
     if not fact:
         return _json_error("fact must not be empty", status=400)
-    new_uuid = await memory_storage.add(fact)
+    try:
+        new_uuid = await memory_storage.add(fact)
+    except OSError:
+        return _json_error("Failed to persist memory", status=500)
     if new_uuid is None:
         return _json_error("Failed to create memory", status=500)
     existing = [m for m in memory_storage.get_all() if m.uuid == new_uuid]
@@ -135,7 +138,10 @@ async def memory_update_handler(
     fact = str(body.get("fact", "") or "").strip()
     if not fact:
         return _json_error("fact must not be empty", status=400)
-    ok = await memory_storage.update(target_uuid, fact)
+    try:
+        ok = await memory_storage.update(target_uuid, fact)
+    except OSError:
+        return _json_error("Failed to persist memory", status=500)
     if not ok:
         return _json_error(f"Memory {target_uuid} not found", status=404)
     return web.json_response({"uuid": target_uuid, "fact": fact, "updated": True})
@@ -150,7 +156,10 @@ async def memory_delete_handler(
     target_uuid = str(request.match_info.get("uuid", "")).strip()
     if not target_uuid:
         return _json_error("uuid is required", status=400)
-    ok = await memory_storage.delete(target_uuid)
+    try:
+        ok = await memory_storage.delete(target_uuid)
+    except OSError:
+        return _json_error("Failed to persist memory", status=500)
     if not ok:
         return _json_error(f"Memory {target_uuid} not found", status=404)
     return web.json_response({"uuid": target_uuid, "deleted": True})