@aalis/plugin-tool-onebot 0.11.1 → 0.13.0

package/dist/index.js

@@ -1,102 +1,78 @@
 import { media } from '@aalis/api-media';
-import { getPlatformAdapters, getPlatformNames, platform as platformService, } from '@aalis/api-platform';
+import { callPlatformAction, getPlatformAdapters, getPlatformNames, platform as platformService, resolvePlatformBySession, } from '@aalis/api-platform';
 import { sessionHistory } from '@aalis/api-session-history';
-import { createStorageGateway, storage } from '@aalis/api-storage';
+import { sessionManager, TAKE_UNKNOWN, takeFrom } from '@aalis/api-session-manager';
 import { tools, withToolGroups } from '@aalis/api-tools';
 import { config, definePlugin, events, logger, optional } from '@aalis/core';
 import { defineConfig, parseConfig } from '@aalis/schema-config';
+import { toSource } from '@aalis/schema-i18n';
+import { t } from './texts.js';
 // ===== 插件元数据 =====
-// 这里的开关都不标 onInvalid:'error'：本插件同时提供 OneBot 会话历史的拒绝规则，插件一进 error，规则跟着消失，
-// 而 session_get_history 对没有规则的平台默认放行。坏值回落到默认值并告警：默认拒绝的跨读开关回落后仍是拒绝。
 const configSchema = defineConfig({
     groupManagement: {
-        label: '群管理工具',
+        label: t('groupManagementLabel'),
         fields: {
             enabled: {
                 type: 'boolean',
-                label: '启用群管理工具',
+                label: t('groupManagementEnabledLabel'),
                 default: true,
-                description: '禁言、踢人、设置群名片、撤回消息等',
+                description: t('groupManagementEnabledDescription'),
             },
         },
     },
     groupInfo: {
-        label: '群信息查询',
+        label: t('groupInfoLabel'),
         fields: {
             enabled: {
                 type: 'boolean',
-                label: '启用群信息查询',
+                label: t('groupInfoEnabledLabel'),
                 default: true,
-                description: '查询群/成员信息',
+                description: t('groupInfoEnabledDescription'),
             },
         },
     },
     account: {
-        label: '账号与好友',
+        label: t('accountLabel'),
         fields: {
             enabled: {
                 type: 'boolean',
-                label: '启用账号与好友查询',
+                label: t('accountEnabledLabel'),
                 default: true,
-                description: '群列表、好友列表等',
+                description: t('accountEnabledDescription'),
             },
         },
     },
     interaction: {
-        label: '特殊交互',
+        label: t('interactionLabel'),
         fields: {
             enabled: {
                 type: 'boolean',
-                label: '启用特殊交互',
+                label: t('interactionEnabledLabel'),
                 default: true,
-                description: '戳一戳、群打卡等',
+                description: t('interactionEnabledDescription'),
             },
         },
     },
     sessionHistory: {
-        label: '会话历史读取',
+        label: t('sessionHistoryLabel'),
         fields: {
             enabled: {
                 type: 'boolean',
-                label: '启用 OneBot 专属历史工具',
+                label: t('sessionHistoryEnabledLabel'),
                 default: true,
-                description: '注册 onebot_resolve_session_id / onebot_get_session_history（按群号/QQ 号读取近期历史）。只管这两个工具：下面的访问规则始终生效，同样约束通用的 session_get_history。',
+                description: t('sessionHistoryEnabledDescription'),
             },
             maxLimit: {
                 type: 'number',
-                label: '单次最多读取条数上限',
+                label: t('maxLimitLabel'),
                 default: 100,
-                description: 'agent 传入的 limit 参数会被截断到该上限。',
+                description: t('maxLimitDescription'),
             },
             defaultLimit: {
                 type: 'number',
-                label: '默认读取条数（agent 不传 limit 时）',
+                label: t('defaultLimitLabel'),
                 default: 20,
-                description: '不能超过 maxLimit。',
-            },
-            allowGroupReadPrivate: {
-                type: 'boolean',
-                label: '允许群聊读取私聊历史',
-                default: false,
-                description: '在群会话中调用历史读取工具时，是否允许目标是某个私聊。',
-            },
-            allowCrossSelf: {
-                type: 'boolean',
-                label: '允许跨机器人账号读取',
-                default: false,
-                description: '不同 selfId 之间跨读。多账号部署才需要。',
-            },
-            allowCrossGroup: {
-                type: 'boolean',
-                label: '允许群聊读取其他群聊历史',
-                default: true,
-                description: '群会话 → 另一个群会话。默认允许（便于跨群取上下文）。',
-            },
-            allowCrossPrivate: {
-                type: 'boolean',
-                label: '允许私聊读取其他私聊历史',
-                default: false,
-                description: '私聊会话 → 另一个 QQ 的私聊。默认拒绝（隐私敏感）。',
+                description: t('defaultLimitDescription'),
             },
         },
     },
@@ -105,9 +81,13 @@ const configSchema = defineConfig({
 const uses = {
     tools: optional(tools),
     platform: optional(platformService),
-    storage: optional(storage),
     media: optional(media),
     sessionHistory: optional(sessionHistory),
+    /**
+     * onebot_get_msg 取到的消息所在的会话、onebot_recall_self 的目标会话与 onebot_get_forward_msg 取的转发收到它的会话按它的
+     * 规则判（takeFrom）；不在时只能取当前会话里的
+     */
+    sessionManager: optional(sessionManager),
     events,
     logger,
     config,
@@ -124,29 +104,14 @@ function parseOneBotSession(sessionId) {
         targetId: parts.slice(3).join(':'),
     };
 }
-/** 在已注册的平台适配器里找出支持 callAction 的 OneBot 适配器 */
-function findOneBotAdapter(platform) {
-    return getPlatformAdapters(platform).find(a => a.platform === 'onebot' && typeof a.callAction === 'function');
-}
-/** 从已连接的 OneBot 适配器中找出任意一个 selfId（优先 online） */
-function getAnyOneBotSelfId(platform) {
-    for (const a of getPlatformAdapters(platform)) {
-        if (a.platform !== 'onebot')
-            continue;
-        const conns = a.getConnections();
-        const online = conns.find(c => c.status === 'online' && c.selfId);
-        if (online?.selfId)
-            return online.selfId;
-        const any = conns.find(c => c.selfId);
-        if (any?.selfId)
-            return any.selfId;
-    }
-    return undefined;
-}
+/** 每个用到机器人账号的工具都带的 self_id 参数 */
+const SELF_ID_PARAM = {
+    type: 'string',
+    description: '机器人账号（QQ 号）。在 OneBot 会话里可以省，用这个会话的账号；不在 OneBot 会话里且有多个账号时必填',
+};
 /**
- * 解析出本次工具调用应使用的 selfId（机器人账号）。
- * 优先级：args.self_id → 当前 callCtx 是 OneBot 会话时取它的 selfId → 任意可用 adapter 的第一个 selfId。
- * 找不到则抛错（无可用 OneBot 连接）。
+ * 本次调用用哪个机器人账号：写明的 self_id；否则当前 OneBot 会话的账号；都没有时汇总各 OneBot 实例的已知账号（不论在不在线），
+ * 恰好一个才用它，多个时报错列出账号、要求写明。子任务会话不算 OneBot 会话，账号不从根会话推
  */
 function resolveSelfId(platform, callCtx, args) {
     const fromArgs = args.self_id != null && String(args.self_id).trim() ? String(args.self_id).trim() : '';
@@ -155,10 +120,16 @@ function resolveSelfId(platform, callCtx, args) {
     const parsed = parseOneBotSession(callCtx.sessionId);
     if (parsed?.selfId)
         return parsed.selfId;
-    const fallback = getAnyOneBotSelfId(platform);
-    if (fallback)
-        return fallback;
-    throw new Error('未找到可用的 OneBot 连接');
+    const known = new Map(getPlatformAdapters(platform)
+        .filter(a => a.platform === 'onebot')
+        .flatMap(a => a.getConnections())
+        .flatMap(c => (c.selfId ? [[c.selfId, c.status]] : [])));
+    if (known.size === 1)
+        return [...known.keys()][0];
+    if (known.size === 0)
+        throw new Error('未找到 OneBot 账号');
+    const listed = [...known].map(([selfId, status]) => `${selfId}(${status})`).join('、');
+    throw new Error(`有 ${known.size} 个 OneBot 账号：${listed}，请用 self_id 写明用哪个`);
 }
 /**
  * 解析"目标群"：args.group_id 优先；否则当前会话必须在 OneBot 群里。
@@ -171,7 +142,7 @@ function resolveGroupTarget(platform, callCtx, args) {
         return { selfId, groupId: argGroupId };
     const parsed = parseOneBotSession(callCtx.sessionId);
     if (parsed?.detailType === 'group' && parsed.targetId) {
-        return { selfId: parsed.selfId, groupId: parsed.targetId };
+        return { selfId, groupId: parsed.targetId };
     }
     throw new Error('未提供 group_id，且当前不在 OneBot 群会话中。请在参数中显式传入 group_id。');
 }
@@ -179,45 +150,44 @@ function buildOneBotSessionId(selfId, detailType, targetId) {
     return `onebot:${selfId}:${detailType}:${targetId}`;
 }
 /**
- * 调用 OneBot 协议 action。selfId 决定走哪个机器人账号；
- * adapter 内部只用 sessionId 解析 selfId 来定位 WebSocket 连接，
- * 因此这里用合成 sessionId（"onebot:<selfId>:internal:0"）即可，与目标会话类型无关。
+ * get_msg 取到的消息所在的会话：群按群号，私聊按对端账号（发送者不是机器人自己时就是发送者）。她自己发的私聊消息与没给这些
+ * 字段的实现端拼不出，为 undefined
  */
-async function callAction(platform, selfId, action, params) {
-    const adapter = findOneBotAdapter(platform);
-    if (!adapter?.callAction)
-        throw new Error('OneBot 适配器不可用或不支持 callAction');
-    return adapter.callAction(buildOneBotSessionId(selfId, 'internal', '0'), action, params);
+function sessionOfMessage(selfId, data) {
+    const sender = data?.sender;
+    if (data?.message_type === 'group' && data.group_id != null) {
+        return buildOneBotSessionId(selfId, 'group', String(data.group_id));
+    }
+    if (data?.message_type === 'private' && sender?.user_id != null && String(sender.user_id) !== selfId) {
+        return buildOneBotSessionId(selfId, 'private', String(sender.user_id));
+    }
+    return undefined;
+}
+/**
+ * 机器人账号的合成会话 id。路由与适配器都只看 id 里的 selfId（路由找到账号所属的实例，适配器定位它的连接），
+ * 与目标会话类型无关。
+ */
+function selfSessionId(selfId) {
+    return buildOneBotSessionId(selfId, 'internal', '0');
 }
-function imageMimeFromPath(path) {
-    const cleaned = path.split('?')[0];
-    const dot = cleaned.lastIndexOf('.');
-    const ext = dot >= 0 ? cleaned.slice(dot).toLowerCase() : '';
-    if (ext === '.jpg' || ext === '.jpeg')
-        return 'image/jpeg';
-    if (ext === '.gif')
-        return 'image/gif';
-    if (ext === '.webp')
-        return 'image/webp';
-    if (ext === '.bmp')
-        return 'image/bmp';
-    return 'image/png';
+/** 调用 OneBot 协议 action：selfId 决定走哪个机器人账号，经平台路由发到账号所属实例的连接 */
+async function callAction(platform, selfId, action, params) {
+    return callPlatformAction(platform, selfSessionId(selfId), action, params);
 }
 /**
- * 尝试将 OneBot get_image 返回的文件路径转为 data URI。
- * 仅支持 storage URI 形式（含 ':/'）。裸本地 fs 路径不再处理，
- * 交由上游 vision 退路使用原始 source（该 fallback 本身在实践中极少命中）。
+ * 按顺序调候选动作名，只有实现端回不支持该动作时才换下一个；其余错误（超时、没权限、对方不在群）原样抛出，不换个动作再做
+ * 一次。戳一戳的动作名各实现端不同：NapCat 是 group_poke、friend_poke 与 send_poke，没有 send_group_poke，群里在 NapCat 上
+ * 只有 group_poke 一个，后面的候选留给别的实现端
  */
-async function localImageToDataUri(storage, path) {
-    if (!path.includes(':/'))
-        return null;
+async function callFirstSupported(platform, selfId, actions, params) {
+    const [action, ...rest] = actions;
     try {
-        const buf = (await storage.readFile(path));
-        const b64 = Buffer.from(buf).toString('base64');
-        return `data:${imageMimeFromPath(path)};base64,${b64}`;
+        return await callAction(platform, selfId, action, params);
     }
-    catch {
-        return null;
+    catch (err) {
+        if (rest.length === 0 || err.unsupported !== true)
+            throw err;
+        return callFirstSupported(platform, selfId, rest, params);
     }
 }
 function imageRefKey(ref) {
@@ -270,6 +240,7 @@ function extractImageRefsFromContent(content) {
     }
     return refs;
 }
+/** 合并转发的节点：data 本身、data.messages 或 data.message 是数组；都不是时返回格式认不出，为 undefined */
 function getForwardMessages(data) {
     const root = data;
     if (Array.isArray(root))
@@ -280,7 +251,7 @@ function getForwardMessages(data) {
     if (Array.isArray(root?.message)) {
         return root.message;
     }
-    return [];
+    return undefined;
 }
 function getForwardNodeData(item) {
     const node = item && typeof item === 'object' ? item : {};
@@ -295,43 +266,42 @@ function getForwardNodeContent(item) {
     return nodeData.content ?? node.content ?? nodeData.message ?? node.message;
 }
 function collectForwardImageRefs(data, limit) {
-    return getForwardMessages(data)
+    return (getForwardMessages(data) ?? [])
         .slice(0, limit)
         .flatMap(item => extractImageRefsFromContent(getForwardNodeContent(item)));
 }
-async function resolveForwardImageSource(caps, storage, selfId, ref) {
-    if (/^(https?:|data:)/i.test(ref.source))
+/** 消息段里能当来源读的：网址，或 `data:` 后面紧跟 MIME 类型的 base64 data URL（与 onebot 适配器的 segmentSource 同一条规则） */
+const SEGMENT_SOURCE = /^(?:https?:\/\/|data:[\w.+-]+\/[\w.+-]+(?:;[^;,]*)*;base64,)/i;
+/**
+ * 转发里一张图交给识图的来源。图片段里写的只认网址与 base64 的 data URL；别的（文件名、本机路径、像存储地址的串）只当
+ * get_image 的 file 参数，读的是实现端交回的地址（自己发起的请求的应答），段里写的不读：群友能给文件起名。交回的地址原样
+ * 交给识图，由 media 按文件头认；换不出地址的为 undefined，这张图不识别
+ */
+async function resolveForwardImageSource(caps, selfId, ref) {
+    if (SEGMENT_SOURCE.test(ref.source))
         return ref.source;
     const { platform, logger } = caps;
     try {
         const imageData = (await callAction(platform, selfId, 'get_image', { file: ref.source }));
-        const resolvedSource = imageData.url ?? imageData.file ?? ref.source;
-        if (typeof resolvedSource === 'string') {
-            if (/^(https?:|data:)/i.test(resolvedSource))
-                return resolvedSource;
-            const dataUri = await localImageToDataUri(storage, resolvedSource);
-            if (dataUri)
-                return dataUri;
-            return resolvedSource;
-        }
+        const resolvedSource = imageData.url ?? imageData.file;
+        return typeof resolvedSource === 'string' ? resolvedSource : undefined;
     }
     catch (err) {
-        logger.debug(`get_image 解析转发图片失败 (${ref.source}): ${err}`);
+        logger.use.debug(`get_image 解析转发图片失败 (${ref.source}): ${err}`);
+        return undefined;
     }
-    const dataUri = await localImageToDataUri(storage, ref.source);
-    return dataUri ?? ref.source;
 }
-async function recognizeForwardImages(caps, storage, selfId, data, limit) {
+async function recognizeForwardImages(caps, selfId, data, limit) {
     const refs = collectForwardImageRefs(data, limit);
     const imageDescriptions = new Map();
     if (refs.length === 0)
         return { imageDescriptions };
     const { logger, media } = caps;
-    const mediaService = media.current;
-    if (!mediaService) {
-        logger.debug(`合并转发包含 ${refs.length} 张图片，但 media 服务不可用`);
+    if (!media.present) {
+        logger.use.debug(`合并转发包含 ${refs.length} 张图片，但 media 服务不可用`);
         return { imageDescriptions };
     }
+    const mediaService = media.use;
     const seen = new Set();
     for (const ref of refs) {
         const key = imageRefKey(ref);
@@ -339,13 +309,15 @@ async function recognizeForwardImages(caps, storage, selfId, data, limit) {
             continue;
         seen.add(key);
         try {
-            const imageSource = await resolveForwardImageSource(caps, storage, selfId, ref);
+            const imageSource = await resolveForwardImageSource(caps, selfId, ref);
+            if (!imageSource)
+                continue;
             const description = await mediaService.describeImage(imageSource);
             if (description)
                 imageDescriptions.set(key, description);
         }
         catch (err) {
-            logger.debug(`合并转发图片识别失败 (${ref.source}): ${err}`);
+            logger.use.debug(`合并转发图片识别失败 (${ref.source}): ${err}`);
         }
     }
     return { imageDescriptions };
@@ -405,6 +377,10 @@ function formatCqMessageContent(content, context) {
 }
 function formatForwardMessage(data, limit, context) {
     const rawMessages = getForwardMessages(data);
+    if (!rawMessages)
+        throw new Error('合并转发的返回格式认不出');
+    if (!rawMessages.length)
+        return '合并转发内容为空';
     const messages = rawMessages.slice(0, limit);
     const lines = messages.map((item, index) => {
         const node = item && typeof item === 'object' ? item : {};
@@ -425,79 +401,68 @@ function formatForwardMessage(data, limit, context) {
         return `${index + 1}. ${prefix}: ${content || '[空消息]'}`;
     });
     const header = `合并转发共 ${rawMessages.length} 条${rawMessages.length > messages.length ? `，以下显示前 ${messages.length} 条` : ''}:`;
-    return lines.length > 0 ? `${header}\n${lines.join('\n')}` : '合并转发内容为空或当前 OneBot 实现返回格式无法识别';
+    return `${header}\n${lines.join('\n')}`;
 }
 // ===== 权限检查辅助 =====
 const ROLE_LEVEL = { owner: 3, admin: 2, member: 1 };
 function roleLevel(role) {
     return ROLE_LEVEL[role] ?? 0;
 }
-/** 查询群成员信息（失败返回 null） */
+/** 查询群成员信息，失败时抛出适配器的原话 */
 async function getGroupMemberInfo(platform, selfId, groupId, userId) {
-    try {
-        return (await callAction(platform, selfId, 'get_group_member_info', {
-            group_id: Number(groupId),
-            user_id: Number(userId),
-            no_cache: true,
-        }));
-    }
-    catch {
-        return null;
-    }
+    return (await callAction(platform, selfId, 'get_group_member_info', {
+        group_id: Number(groupId),
+        user_id: Number(userId),
+        no_cache: true,
+    }));
 }
-/** 检查管理操作权限，返回错误消息（null 表示通过或无法验证） */
-async function checkAdminPermission(platform, selfId, groupId, targetUserId, requireOwner) {
-    const selfInfo = await getGroupMemberInfo(platform, selfId, groupId, selfId);
-    if (!selfInfo)
-        return null; // 无法获取自身信息，跳过权限检查
-    const selfRole = String(selfInfo.role ?? 'member');
+/**
+ * 机器人在群里的角色够不够做这个管理操作，不够时抛错。取不到机器人自身信息或其中没有角色时放过检查：真不够权限时实现端的
+ * 返回码会报出来。目标成员的信息或角色取不到（查询失败，或实现端回成功却没给）时报错，不当成普通成员
+ */
+async function assertAdminPermission(platform, selfId, groupId, targetUserId, requireOwner) {
+    const selfInfo = await getGroupMemberInfo(platform, selfId, groupId, selfId).catch(() => null);
+    if (!selfInfo?.role)
+        return;
+    const selfRole = String(selfInfo.role);
     if (requireOwner && selfRole !== 'owner') {
-        return `操作失败：此操作仅群主可执行（当前角色：${selfRole}）`;
+        throw new Error(`操作失败：此操作仅群主可执行（当前角色：${selfRole}）`);
     }
     if (selfRole === 'member') {
-        return `操作失败：机器人不是管理员（当前角色：${selfRole}），无法执行管理操作`;
+        throw new Error(`操作失败：机器人不是管理员（当前角色：${selfRole}），无法执行管理操作`);
     }
     if (targetUserId) {
-        const targetInfo = await getGroupMemberInfo(platform, selfId, groupId, targetUserId);
-        if (!targetInfo) {
-            return `操作失败：无法获取用户 ${targetUserId} 的信息，该用户可能不在群中`;
-        }
-        const targetRole = String(targetInfo.role ?? 'member');
+        const targetInfo = await getGroupMemberInfo(platform, selfId, groupId, targetUserId).catch((err) => {
+            throw new Error(`操作失败：无法获取用户 ${targetUserId} 的信息：${err instanceof Error ? err.message : String(err)}`);
+        });
+        if (!targetInfo)
+            throw new Error(`操作失败：无法获取用户 ${targetUserId} 的信息：实现端没给成员信息`);
+        if (!targetInfo.role)
+            throw new Error(`操作失败：无法获取用户 ${targetUserId} 的信息：实现端没给成员角色`);
+        const targetRole = String(targetInfo.role);
         if (roleLevel(targetRole) >= roleLevel(selfRole)) {
             const targetLabel = targetRole === 'owner' ? '群主' : '管理员';
-            return `操作失败：无法对${targetLabel}执行此操作（机器人角色：${selfRole}，目标角色：${targetRole}）`;
+            throw new Error(`操作失败：无法对${targetLabel}执行此操作（机器人角色：${selfRole}，目标角色：${targetRole}）`);
         }
     }
-    return null;
 }
 export default definePlugin({
     name: '@aalis/plugin-tool-onebot',
-    displayName: 'OneBot 工具',
+    displayName: t('displayName'),
     subsystem: 'tools',
     configSchema,
     uses,
     apply(caps) {
         const { tools, events, logger, platform } = caps;
-        const cfg = parseConfig(configSchema, caps.config, logger);
-        const storage = createStorageGateway(caps.storage);
+        const cfg = parseConfig(configSchema, caps.config.use, logger.use);
         const bundle = {
-            daily: withToolGroups(tools, ['onebot-daily']),
-            group: withToolGroups(tools, ['onebot-group']),
-            personal: withToolGroups(tools, ['onebot-personal']),
+            daily: withToolGroups(tools.use, ['onebot-daily']),
+            group: withToolGroups(tools.use, ['onebot-group']),
+            personal: withToolGroups(tools.use, ['onebot-personal']),
         };
         const maxLimit = Math.max(1, Math.min(1000, cfg.sessionHistory.maxLimit || 100));
         const defaultLimitRaw = Math.max(1, Math.floor(cfg.sessionHistory.defaultLimit || 20));
-        const historyCfg = {
-            maxLimit,
-            defaultLimit: Math.min(defaultLimitRaw, maxLimit),
-            allowGroupReadPrivate: cfg.sessionHistory.allowGroupReadPrivate,
-            allowCrossSelf: cfg.sessionHistory.allowCrossSelf,
-            allowCrossGroup: cfg.sessionHistory.allowCrossGroup,
-            allowCrossPrivate: cfg.sessionHistory.allowCrossPrivate,
-        };
-        // 访问规则始终注册：它同样约束通用的 session_get_history，不随专属工具开关撤掉（关掉工具不能反倒放宽读取）。
-        // 规则只对 onebot 会话 id 表态，与 OneBot 平台在不在场无关：不进下面的平台闸。
-        registerOneBotHistoryAccessChecker(caps, historyCfg);
+        const historyCfg = { maxLimit, defaultLimit: Math.min(defaultLimitRaw, maxLimit) };
         // 仅当 OneBot 平台可用时才注册工具。platform 是可选的多提供者服务，OneBot 适配器可能晚于
         // app:ready 上线（WebUI 启用、市场热装、启动失败后修好），且作为非胜者上线时 follow 不触发：
         // 故在 app:ready 与每次 platform 提供者注册时各判一次，出现 onebot 即注册，之后不再重复。
@@ -507,27 +472,30 @@ export default definePlugin({
             if (toolsRegistered || !getPlatformNames(platform).includes('onebot'))
                 return;
             toolsRegistered = true;
-            logger.info('检测到 OneBot 平台，开始注册 OneBot 工具');
+            logger.use.info('检测到 OneBot 平台，开始注册 OneBot 工具');
             // 注册工具分组：按职责语义切分，彼此不重叠
-            tools.registerGroup({
+            tools.use.registerGroup({
                 name: 'onebot-daily',
-                label: 'OneBot 只读与日常',
+                label: t('dailyGroup'),
+                summary: t('dailyGroupSummary'),
                 description: '只读查询（群信息/成员/好友列表/历史/登录信息）+ 日常低风险互动（戳一戳、好友赞）',
             });
-            tools.registerGroup({
+            tools.use.registerGroup({
                 name: 'onebot-group',
-                label: 'OneBot 群务',
+                label: t('groupGroup'),
+                summary: t('groupGroupSummary'),
                 description: '群务管理：禁言/全员禁言/踢人/撤回消息/设置群名片/改群名/设管理员/群打卡/审批加群申请 等',
             });
-            tools.registerGroup({
+            tools.use.registerGroup({
                 name: 'onebot-personal',
-                label: 'OneBot 个人/私聊',
+                label: t('personalGroup'),
+                summary: t('personalGroupSummary'),
                 description: '影响 bot 账号本身的人际关系：退群、删好友、处理好友申请、接受/拒绝入群邀请',
             });
             if (cfg.groupManagement.enabled)
                 registerGroupManagementTools(caps, bundle);
             if (cfg.groupInfo.enabled)
-                registerGroupInfoTools(caps, storage, bundle);
+                registerGroupInfoTools(caps, bundle);
             if (cfg.account.enabled)
                 registerAccountTools(caps, bundle);
             if (cfg.interaction.enabled)
@@ -536,12 +504,12 @@ export default definePlugin({
                 registerSessionHistoryTools(caps, bundle, historyCfg);
             registerRequestTools(caps, bundle);
         };
-        events.on('app:ready', () => {
+        events.use.on('app:ready', () => {
             registerToolsOnce();
             if (!toolsRegistered)
-                logger.info('未检测到 OneBot 平台，暂不注册 OneBot 工具（平台上线后自动补注册）');
+                logger.use.info('未检测到 OneBot 平台，暂不注册 OneBot 工具（平台上线后自动补注册）');
         });
-        events.on('service:registered', name => {
+        events.use.on('service:changed', name => {
             if (name === platformService.name)
                 registerToolsOnce();
         });
@@ -549,7 +517,7 @@ export default definePlugin({
 });
 // ===== 群管理工具 =====
 function registerGroupManagementTools(caps, bundle) {
-    const { platform, logger } = caps;
+    const { platform, logger, sessionManager } = caps;
     const { group, personal } = bundle;
     // ---- 群禁言（单人）----
     group.register({
@@ -564,6 +532,7 @@ function registerGroupManagementTools(caps, bundle) {
                         user_id: { type: 'string', description: '要禁言的用户QQ号' },
                         duration: { type: 'number', description: '禁言时长（秒），0 = 解除禁言，默认 60' },
                         group_id: { type: 'string', description: '可选：目标群号。不传则使用当前群会话的群号。' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: ['user_id'],
                 },
@@ -572,27 +541,25 @@ function registerGroupManagementTools(caps, bundle) {
         handler: async (args, callCtx) => {
             const { selfId, groupId } = resolveGroupTarget(platform, callCtx, args);
             const duration = typeof args.duration === 'number' ? args.duration : 60;
-            const permError = await checkAdminPermission(platform, selfId, groupId, String(args.user_id));
-            if (permError)
-                return permError;
+            await assertAdminPermission(platform, selfId, groupId, String(args.user_id));
             await callAction(platform, selfId, 'set_group_ban', {
                 group_id: Number(groupId),
                 user_id: Number(args.user_id),
                 duration,
             });
-            // 验证禁言是否生效
-            const info = await getGroupMemberInfo(platform, selfId, groupId, String(args.user_id));
+            // 验证禁言是否生效：查不到成员信息时照报已发出指令、写明无法验证
+            const info = await getGroupMemberInfo(platform, selfId, groupId, String(args.user_id)).catch(() => null);
             if (info && 'shut_up_timestamp' in info) {
                 const shutUp = Number(info.shut_up_timestamp);
                 const now = Math.floor(Date.now() / 1000);
                 if (duration === 0) {
-                    return shutUp <= now ? `已解除 ${args.user_id} 的禁言` : `解除禁言指令已发送，但用户仍在禁言中`;
-                }
-                else {
-                    return shutUp > now
-                        ? `已禁言 ${args.user_id}，时长 ${duration} 秒`
-                        : `禁言操作未生效（API 返回成功但禁言状态未变化），请检查机器人实际权限`;
+                    if (shutUp > now)
+                        throw new Error('解除禁言指令已发送，但用户仍在禁言中');
+                    return `已解除 ${args.user_id} 的禁言`;
                 }
+                if (shutUp <= now)
+                    throw new Error('禁言操作未生效（API 返回成功但禁言状态未变化），请检查机器人实际权限');
+                return `已禁言 ${args.user_id}，时长 ${duration} 秒`;
             }
             return duration === 0
                 ? `已解除 ${args.user_id} 的禁言`
@@ -611,6 +578,7 @@ function registerGroupManagementTools(caps, bundle) {
                     properties: {
                         enable: { type: 'boolean', description: 'true = 开启全群禁言，false = 关闭' },
                         group_id: { type: 'string', description: '可选：目标群号。不传则使用当前群会话的群号。' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: ['enable'],
                 },
@@ -618,9 +586,7 @@ function registerGroupManagementTools(caps, bundle) {
         },
         handler: async (args, callCtx) => {
             const { selfId, groupId } = resolveGroupTarget(platform, callCtx, args);
-            const permError = await checkAdminPermission(platform, selfId, groupId);
-            if (permError)
-                return permError;
+            await assertAdminPermission(platform, selfId, groupId);
             await callAction(platform, selfId, 'set_group_whole_ban', {
                 group_id: Number(groupId),
                 enable: !!args.enable,
@@ -641,6 +607,7 @@ function registerGroupManagementTools(caps, bundle) {
                         user_id: { type: 'string', description: '要踢出的用户QQ号' },
                         reject_add_request: { type: 'boolean', description: '是否拒绝此人再次加群，默认 false' },
                         group_id: { type: 'string', description: '可选：目标群号。不传则使用当前群会话的群号。' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: ['user_id'],
                 },
@@ -648,9 +615,7 @@ function registerGroupManagementTools(caps, bundle) {
         },
         handler: async (args, callCtx) => {
             const { selfId, groupId } = resolveGroupTarget(platform, callCtx, args);
-            const permError = await checkAdminPermission(platform, selfId, groupId, String(args.user_id));
-            if (permError)
-                return permError;
+            await assertAdminPermission(platform, selfId, groupId, String(args.user_id));
             await callAction(platform, selfId, 'set_group_kick', {
                 group_id: Number(groupId),
                 user_id: Number(args.user_id),
@@ -670,6 +635,7 @@ function registerGroupManagementTools(caps, bundle) {
                     type: 'object',
                     properties: {
                         group_id: { type: 'string', description: '要退出的群号；在群聊中可省略，默认当前群' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: [],
                 },
@@ -681,7 +647,7 @@ function registerGroupManagementTools(caps, bundle) {
             const parsed = parseOneBotSession(callCtx.sessionId);
             const groupId = argGroupId || (parsed?.detailType === 'group' ? parsed.targetId : '');
             if (!groupId)
-                return '请提供 group_id，或在要退出的群聊中调用此工具';
+                throw new Error('请提供 group_id，或在要退出的群聊中调用此工具');
             await callAction(platform, selfId, 'set_group_leave', {
                 group_id: Number(groupId),
                 is_dismiss: false,
@@ -702,6 +668,7 @@ function registerGroupManagementTools(caps, bundle) {
                         user_id: { type: 'string', description: '用户QQ号' },
                         card: { type: 'string', description: '新的群名片，空字符串表示取消' },
                         group_id: { type: 'string', description: '可选：目标群号。不传则使用当前群会话的群号。' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: ['user_id', 'card'],
                 },
@@ -709,9 +676,7 @@ function registerGroupManagementTools(caps, bundle) {
         },
         handler: async (args, callCtx) => {
             const { selfId, groupId } = resolveGroupTarget(platform, callCtx, args);
-            const permError = await checkAdminPermission(platform, selfId, groupId);
-            if (permError)
-                return permError;
+            await assertAdminPermission(platform, selfId, groupId);
             await callAction(platform, selfId, 'set_group_card', {
                 group_id: Number(groupId),
                 user_id: Number(args.user_id),
@@ -732,6 +697,7 @@ function registerGroupManagementTools(caps, bundle) {
                     properties: {
                         group_name: { type: 'string', description: '新的群名称' },
                         group_id: { type: 'string', description: '可选：目标群号。不传则使用当前群会话的群号。' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: ['group_name'],
                 },
@@ -739,9 +705,7 @@ function registerGroupManagementTools(caps, bundle) {
         },
         handler: async (args, callCtx) => {
             const { selfId, groupId } = resolveGroupTarget(platform, callCtx, args);
-            const permError = await checkAdminPermission(platform, selfId, groupId);
-            if (permError)
-                return permError;
+            await assertAdminPermission(platform, selfId, groupId);
             await callAction(platform, selfId, 'set_group_name', {
                 group_id: Number(groupId),
                 group_name: String(args.group_name),
@@ -762,6 +726,7 @@ function registerGroupManagementTools(caps, bundle) {
                         user_id: { type: 'string', description: '用户QQ号' },
                         special_title: { type: 'string', description: '专属头衔，空字符串表示取消' },
                         group_id: { type: 'string', description: '可选：目标群号。不传则使用当前群会话的群号。' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: ['user_id', 'special_title'],
                 },
@@ -769,9 +734,7 @@ function registerGroupManagementTools(caps, bundle) {
         },
         handler: async (args, callCtx) => {
             const { selfId, groupId } = resolveGroupTarget(platform, callCtx, args);
-            const permError = await checkAdminPermission(platform, selfId, groupId, undefined, true);
-            if (permError)
-                return permError;
+            await assertAdminPermission(platform, selfId, groupId, undefined, true);
             await callAction(platform, selfId, 'set_group_special_title', {
                 group_id: Number(groupId),
                 user_id: Number(args.user_id),
@@ -794,6 +757,7 @@ function registerGroupManagementTools(caps, bundle) {
                         user_id: { type: 'string', description: '用户QQ号' },
                         enable: { type: 'boolean', description: 'true = 设为管理员，false = 取消管理员' },
                         group_id: { type: 'string', description: '可选：目标群号。不传则使用当前群会话的群号。' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: ['user_id', 'enable'],
                 },
@@ -801,9 +765,7 @@ function registerGroupManagementTools(caps, bundle) {
         },
         handler: async (args, callCtx) => {
             const { selfId, groupId } = resolveGroupTarget(platform, callCtx, args);
-            const permError = await checkAdminPermission(platform, selfId, groupId, undefined, true);
-            if (permError)
-                return permError;
+            await assertAdminPermission(platform, selfId, groupId, undefined, true);
             await callAction(platform, selfId, 'set_group_admin', {
                 group_id: Number(groupId),
                 user_id: Number(args.user_id),
@@ -823,6 +785,7 @@ function registerGroupManagementTools(caps, bundle) {
                     type: 'object',
                     properties: {
                         message_id: { type: 'string', description: '要撤回的消息 ID' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: ['message_id'],
                 },
@@ -853,6 +816,7 @@ function registerGroupManagementTools(caps, bundle) {
                         count: { type: 'number', description: '撤回最近多少条机器人消息（默认 1，上限 10）' },
                         group_id: { type: 'string', description: '可选：目标群号。不传则用当前会话。' },
                         user_id: { type: 'string', description: '可选：目标私聊 QQ 号。不传则用当前会话。' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: [],
                 },
@@ -870,17 +834,22 @@ function registerGroupManagementTools(caps, bundle) {
             else {
                 const parsed = parseOneBotSession(callCtx.sessionId);
                 if (!parsed)
-                    return '当前不在 OneBot 会话中，请用 group_id 或 user_id 指定要撤回的目标会话。';
+                    throw new Error('当前不在 OneBot 会话中，请用 group_id 或 user_id 指定要撤回的目标会话。');
                 targetSessionId = callCtx.sessionId;
             }
-            const adapter = findOneBotAdapter(platform);
+            // 目标会话逐个参与者过会话管理的规则（同 onebot_get_msg）：不放行时在读发出记录之前报错，不撤回，报错里没有她在那里说的话
+            const verdict = await callCtx.approveFor(who => takeFrom(sessionManager, callCtx.sessionId, targetSessionId, who));
+            if (!verdict.ok)
+                throw new Error(toSource(verdict.reason));
+            // 发出记录在发消息的那个实例里：按目标会话路由
+            const adapter = (await resolvePlatformBySession(platform, targetSessionId))?.use;
             if (!adapter?.getSentMessages) {
-                return '未找到支持记录自身发出消息的 OneBot 适配器（getSentMessages 不在平台契约内，第三方适配器可不提供）。如已知 message_id 可改用 onebot_delete_msg。';
+                throw new Error('未找到支持记录自身发出消息的 OneBot 适配器（getSentMessages 不在平台契约内，第三方适配器可不提供）。如已知 message_id 可改用 onebot_delete_msg。');
             }
             const count = Math.max(1, Math.min(10, Math.floor(Number(args.count) || 1)));
             const recent = adapter.getSentMessages(targetSessionId, 10); // 新→旧
             if (recent.length === 0) {
-                return '没有可撤回的记录：机器人近期未在该会话发送消息，或已超出记录时窗（约 30 分钟）。';
+                throw new Error('没有可撤回的记录：机器人近期未在该会话发送消息，或已超出记录时窗（约 30 分钟）。');
             }
             const targets = recent.slice(0, count);
             const recalled = [];
@@ -896,7 +865,7 @@ function registerGroupManagementTools(caps, bundle) {
                 }
             }
             if (recalled.length === 0) {
-                return `撤回失败（可能已超过可撤回时间，QQ 通常限 2 分钟）：${failed.join('；')}`;
+                throw new Error(`撤回失败：${failed.join('；')}`);
             }
             let msg = `已撤回机器人发送的 ${recalled.length} 条消息：${recalled.join('、')}`;
             if (failed.length > 0)
@@ -904,11 +873,11 @@ function registerGroupManagementTools(caps, bundle) {
             return msg;
         },
     });
-    logger.info('OneBot 群管理工具已注册');
+    logger.use.info('OneBot 群管理工具已注册');
 }
 // ===== 群信息查询工具 =====
-function registerGroupInfoTools(caps, storage, bundle) {
-    const { platform, logger } = caps;
+function registerGroupInfoTools(caps, bundle) {
+    const { platform, logger, sessionManager } = caps;
     const { daily } = bundle;
     // ---- 查看合并转发 ----
     daily.register({
@@ -916,7 +885,7 @@ function registerGroupInfoTools(caps, storage, bundle) {
             type: 'function',
             function: {
                 name: 'onebot_get_forward_msg',
-                description: '读取合并转发消息内容（OneBot v11 标准 get_forward_msg）。收到 <forward id="...">[合并转发消息]</forward> 时，必须把尖括号里的 id 字符串作为参数 id 传入；不要使用 message_id、forward_id、res_id 或 m_resid。',
+                description: '读取合并转发消息内容（OneBot v11 标准 get_forward_msg）。收到 <forward id="...">[合并转发消息]</forward> 时，把尖括号里的 id 字符串作为参数 id 传入。',
                 parameters: {
                     type: 'object',
                     properties: {
@@ -925,6 +894,7 @@ function registerGroupInfoTools(caps, storage, bundle) {
                             description: '合并转发 ID（forward 消息段的 data.id），与 OneBot v11 标准参数名一致',
                         },
                         limit: { type: 'number', description: '最多返回多少条节点，默认 30' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: ['id'],
                 },
@@ -933,27 +903,51 @@ function registerGroupInfoTools(caps, storage, bundle) {
         handler: async (args, callCtx) => {
             const selfId = resolveSelfId(platform, callCtx, args);
             if (!args.id)
-                return '参数错误：缺少 id（合并转发 ID）。请使用 <forward id="..."> 中的 id 字符串，不要使用 message_id。';
+                throw new Error('参数错误：缺少 id（合并转发 ID）。请使用 <forward id="..."> 中的 id 字符串。');
             const forwardId = String(args.id);
             const limit = Math.max(1, Math.min(100, typeof args.limit === 'number' ? Math.floor(args.limit) : 30));
-            // 适配器的 callAction 已对 get_forward_msg 做了多参数键回退（id/message_id/res_id/m_resid）
-            // 并维护了一份接收时即抓取并展开（含摘要与图像识别）的缓存。
+            const readFailed = (err) => new Error(`合并转发读取失败：${err instanceof Error ? err.message : String(err)}`);
+            // 适配器的 callAction 维护了一份接收时即抓取并展开（含摘要与图像识别）的缓存，每个收到的转发都记着收到它的会话。
             let data;
             try {
                 data = await callAction(platform, selfId, 'get_forward_msg', { id: forwardId });
             }
             catch (err) {
-                return `合并转发读取失败：${err instanceof Error ? err.message : String(err)}。该转发可能已在协议端过期，或当前 OneBot 实现不支持跨会话读取。`;
+                throw readFailed(err);
             }
-            // 适配器在缓存命中时返回 ForwardEntry 形状（含 fullText / summary / 元信息）。
-            // 此时直接返回原文给 LLM，无需再做协议端结构解析。
-            if (data && typeof data === 'object' && data.__aalisForwardEntry) {
-                const entry = data;
-                const header = `合并转发共 ${entry.count} 条，参与人：${entry.participants.join(', ') || '未知'}`;
+            // 适配器交回收到这条转发的会话：展开过的连同 ForwardEntry 形状（fullText / summary / 元信息与截断标志），没展开过的连同
+            // 按 id 现拉的办法。收到它的会话逐个参与者过会话管理的规则（同 onebot_get_msg），几处之一过得了就行，过了才拉；没记会话的
+            // （从没收到过的、别的适配器交回的原始数据）按判不出拒绝
+            const reply = (data && typeof data === 'object' ? data : {});
+            const recorded = reply.__aalisForwardEntry === true || reply.__aalisForwardReceipt === true;
+            const sessionIds = recorded && Array.isArray(reply.sessionIds) ? reply.sessionIds.map(String) : [];
+            const verdict = sessionIds.length === 0
+                ? { ok: false, reason: TAKE_UNKNOWN }
+                : await callCtx.approveFor(who => {
+                    const verdicts = sessionIds.map(id => takeFrom(sessionManager, callCtx.sessionId, id, who));
+                    return verdicts.find(v => v.ok) ?? verdicts[0];
+                });
+            if (!verdict.ok)
+                throw new Error(toSource(verdict.reason));
+            // 展开过的直接返回原文给 LLM，无需再做协议端结构解析
+            if (reply.__aalisForwardEntry === true) {
+                const entry = reply;
+                const cut = [entry.truncatedDepth && '嵌套超深', entry.truncatedNodes && '节点超限'].filter(Boolean);
+                // 参与人与入站信封同一写法：条目只列前 8 个，没列出的人数另记
+                const participants = [...entry.participants, ...(entry.unlisted ? [`...(+${entry.unlisted} 人未列出)`] : [])];
+                const header = `合并转发共 ${entry.count} 条，参与人：${participants.join(', ') || '未知'}` +
+                    (cut.length ? `，已截断（${cut.join('、')}）` : '');
                 const summaryLine = entry.summary ? `\n摘要：${entry.summary}\n` : '\n';
                 return `${header}${summaryLine}\n原文：\n${entry.fullText}`;
             }
-            const formatContext = await recognizeForwardImages(caps, storage, selfId, data, limit);
+            // 没展开过的：过了判定才按 id 现拉
+            try {
+                data = await reply.fetch();
+            }
+            catch (err) {
+                throw readFailed(err);
+            }
+            const formatContext = await recognizeForwardImages(caps, selfId, data, limit);
             return formatForwardMessage(data, limit, formatContext);
         },
     });
@@ -968,6 +962,7 @@ function registerGroupInfoTools(caps, storage, bundle) {
                     type: 'object',
                     properties: {
                         group_id: { type: 'string', description: '可选：目标群号。不传则使用当前群会话的群号。' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: [],
                 },
@@ -993,6 +988,7 @@ function registerGroupInfoTools(caps, storage, bundle) {
                     properties: {
                         user_id: { type: 'string', description: '可选：要查询的用户 QQ 号。缺省查询机器人自身。' },
                         group_id: { type: 'string', description: '可选：目标群号。不传则使用当前群会话的群号。' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: [],
                 },
@@ -1024,6 +1020,7 @@ function registerGroupInfoTools(caps, storage, bundle) {
                         limit: { type: 'number', description: '本页最多返回条数，默认 30' },
                         offset: { type: 'number', description: '跳过前 N 条用于翻页，默认 0' },
                         group_id: { type: 'string', description: '可选：目标群号。不传则使用当前群会话的群号。' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: [],
                 },
@@ -1087,6 +1084,7 @@ function registerGroupInfoTools(caps, storage, bundle) {
                             type: 'string',
                             description: '可选。指定群号。缺省时查当前会话所在群（私聊时缺省会报错，请显式传入）。',
                         },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: [],
                 },
@@ -1098,14 +1096,10 @@ function registerGroupInfoTools(caps, storage, bundle) {
             const parsed = parseOneBotSession(callCtx.sessionId);
             let groupId = argGroupId;
             if (!groupId) {
-                if (parsed?.detailType !== 'group') {
-                    return JSON.stringify({ available: false, reason: '当前不在群聊中，请显式传入 group_id' });
-                }
+                if (parsed?.detailType !== 'group')
+                    throw new Error('当前不在群聊中，请显式传入 group_id');
                 groupId = parsed.targetId;
             }
-            const adapter = findOneBotAdapter(platform);
-            if (!adapter?.callAction)
-                return JSON.stringify({ available: false, reason: 'OneBot 适配器不可用' });
             let info = null;
             try {
                 info = (await callAction(platform, selfId, 'get_group_member_info', {
@@ -1115,18 +1109,14 @@ function registerGroupInfoTools(caps, storage, bundle) {
                 }));
             }
             catch (err) {
-                return JSON.stringify({
-                    available: false,
-                    reason: `查询失败: ${err instanceof Error ? err.message : String(err)}`,
-                });
+                throw new Error(`查询失败: ${err instanceof Error ? err.message : String(err)}`);
             }
             if (!info)
-                return JSON.stringify({ available: false, reason: '无法获取群成员信息' });
+                throw new Error('无法获取群成员信息');
             const ts = Number(info.shut_up_timestamp ?? 0);
             const nowSec = Math.floor(Date.now() / 1000);
             const muted = ts > nowSec;
             return JSON.stringify({
-                available: true,
                 muted,
                 shutUpTimestamp: ts,
                 untilIso: muted ? new Date(ts * 1000).toISOString() : null,
@@ -1157,23 +1147,16 @@ function registerGroupInfoTools(caps, storage, bundle) {
             },
         },
         handler: async (args) => {
-            const adapter = findOneBotAdapter(platform);
-            if (!adapter?.getSelfMutes) {
-                return JSON.stringify({
-                    supported: false,
-                    reason: '未找到支持记录自身禁言状态的 OneBot 适配器（getSelfMutes 不在平台契约内，第三方适配器可不提供）',
-                });
+            const supporting = getPlatformAdapters(platform).filter((a) => a.platform === 'onebot' && typeof a.getSelfMutes === 'function');
+            if (supporting.length === 0) {
+                throw new Error('未找到支持记录自身禁言状态的 OneBot 适配器（getSelfMutes 不在平台契约内，第三方适配器可不提供）');
             }
             const limit = Math.max(1, Math.min(200, Math.floor(Number(args.limit) || 30)));
             const offset = Math.max(0, Math.floor(Number(args.offset) || 0));
-            const mutes = adapter
-                .getSelfMutes()
-                .slice()
-                .sort((a, b) => a.remainingSec - b.remainingSec);
+            const mutes = supporting.flatMap(a => a.getSelfMutes()).sort((a, b) => a.remainingSec - b.remainingSec);
             const total = mutes.length;
             const sliced = mutes.slice(offset, offset + limit);
             return JSON.stringify({
-                supported: true,
                 total,
                 offset,
                 limit,
@@ -1194,11 +1177,12 @@ function registerGroupInfoTools(caps, storage, bundle) {
             type: 'function',
             function: {
                 name: 'onebot_get_msg',
-                description: '按 message_id 获取单条消息的完整内容（包括发送者、消息段等）。可用于回溯查看历史中的某条消息，或在收到撤回通知后查看被撤回的内容。不限定会话类型，群聊和私聊消息均可查询。',
+                description: '按 message_id 获取单条消息的完整内容（包括发送者、消息段等）。可用于回溯查看历史中的某条消息，或在收到撤回通知后查看被撤回的内容。消息所在的会话按会话管理的跨会话规则判（默认不取别人私聊里的消息）。',
                 parameters: {
                     type: 'object',
                     properties: {
                         message_id: { type: 'string', description: '消息 ID' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: ['message_id'],
                 },
@@ -1207,16 +1191,25 @@ function registerGroupInfoTools(caps, storage, bundle) {
         handler: async (args, callCtx) => {
             const selfId = resolveSelfId(platform, callCtx, args);
             if (!args.message_id)
-                return '参数错误：缺少 message_id';
+                throw new Error('参数错误：缺少 message_id');
+            let data;
             try {
-                const data = await callAction(platform, selfId, 'get_msg', {
+                data = (await callAction(platform, selfId, 'get_msg', {
                     message_id: Number(args.message_id),
-                });
-                return JSON.stringify(data);
+                }));
             }
             catch (err) {
-                return `获取消息失败：${err instanceof Error ? err.message : String(err)}。该消息可能已过期或不在当前 OneBot 实现的作用域内。`;
+                throw new Error(`获取消息失败：${err instanceof Error ? err.message : String(err)}`);
             }
+            // 取到的消息按所在的窗口拼出会话 id 过规则：拼不出（她自己发的私聊消息、实现端不给字段）的按判不出拒绝
+            const target = sessionOfMessage(selfId, data);
+            // 逐个参与者过会话管理的规则：有人过不了（某个参与者自己私聊里的）时发一道参与者审批，由过得了的人批
+            const verdict = target === undefined
+                ? { ok: false, reason: TAKE_UNKNOWN }
+                : await callCtx.approveFor(who => takeFrom(sessionManager, callCtx.sessionId, target, who));
+            if (!verdict.ok)
+                throw new Error(toSource(verdict.reason));
+            return JSON.stringify(data);
         },
     });
     // ---- 获取群荣誉信息 ----
@@ -1235,6 +1228,7 @@ function registerGroupInfoTools(caps, storage, bundle) {
                             description: '荣誉类型：talkative=龙王, performer=群聊之火, legend=群聊炽焰, strong_newbie=冒尖小春笋, emotion=快乐之源, all=全部。默认 all。',
                         },
                         group_id: { type: 'string', description: '可选：目标群号。不传则使用当前群会话的群号。' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: [],
                 },
@@ -1250,7 +1244,7 @@ function registerGroupInfoTools(caps, storage, bundle) {
             return JSON.stringify(data);
         },
     });
-    logger.info('OneBot 群信息查询工具已注册');
+    logger.use.info('OneBot 群信息查询工具已注册');
 }
 // ===== 账号 / 好友 / 群列表查询工具 =====
 function registerAccountTools(caps, bundle) {
@@ -1272,6 +1266,7 @@ function registerAccountTools(caps, bundle) {
                         keyword: { type: 'string', description: '可选：按群名或群号子串模糊匹配（不区分大小写）' },
                         limit: { type: 'number', description: '本页最多返回条数，默认 30' },
                         offset: { type: 'number', description: '跳过前 N 条用于翻页，默认 0' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: [],
                 },
@@ -1321,6 +1316,7 @@ function registerAccountTools(caps, bundle) {
                         keyword: { type: 'string', description: '可选：按昵称、备注或 QQ 号子串模糊匹配（不区分大小写）' },
                         limit: { type: 'number', description: '本页最多返回条数，默认 30' },
                         offset: { type: 'number', description: '跳过前 N 条用于翻页，默认 0' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: [],
                 },
@@ -1369,6 +1365,7 @@ function registerAccountTools(caps, bundle) {
                     properties: {
                         user_id: { type: 'string', description: '要查询的 QQ 号' },
                         no_cache: { type: 'boolean', description: '是否跳过缓存强制刷新，默认 false' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: ['user_id'],
                 },
@@ -1390,11 +1387,11 @@ function registerAccountTools(caps, bundle) {
             function: {
                 name: 'onebot_get_login_info',
                 description: '显式查询当前 OneBot 连接的登录账号信息（QQ 号、昵称）。仅在用户要求核实账号、诊断连接或需要最新平台返回值时使用。',
-                parameters: { type: 'object', properties: {}, required: [] },
+                parameters: { type: 'object', properties: { self_id: SELF_ID_PARAM }, required: [] },
             },
         },
-        handler: async (_args, callCtx) => {
-            const selfId = resolveSelfId(platform, callCtx, _args);
+        handler: async (args, callCtx) => {
+            const selfId = resolveSelfId(platform, callCtx, args);
             const data = await callAction(platform, selfId, 'get_login_info', {});
             return JSON.stringify(data);
         },
@@ -1410,6 +1407,7 @@ function registerAccountTools(caps, bundle) {
                     type: 'object',
                     properties: {
                         user_id: { type: 'string', description: '要删除的好友 QQ 号；在私聊中可省略，默认当前对话用户' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: [],
                 },
@@ -1421,14 +1419,14 @@ function registerAccountTools(caps, bundle) {
             const parsed = parseOneBotSession(callCtx.sessionId);
             const userId = argUserId || (parsed?.detailType === 'private' ? parsed.targetId : '');
             if (!userId)
-                return '请提供 user_id，或在要删除的好友私聊中调用此工具';
+                throw new Error('请提供 user_id，或在要删除的好友私聊中调用此工具');
             await callAction(platform, selfId, 'delete_friend', {
                 user_id: Number(userId),
             });
             return `已删除好友 ${userId}`;
         },
     });
-    logger.info('OneBot 账号 / 好友 / 群列表查询工具已注册');
+    logger.use.info('OneBot 账号 / 好友 / 群列表查询工具已注册');
 }
 // ===== 特殊交互工具 =====
 function registerInteractionTools(caps, bundle) {
@@ -1452,6 +1450,7 @@ function registerInteractionTools(caps, bundle) {
                             type: 'string',
                             description: '可选：目标群号。群聊省略则使用当前群；如显式传值则跨群操作。',
                         },
+                        self_id: SELF_ID_PARAM,
                     },
                 },
             },
@@ -1467,18 +1466,10 @@ function registerInteractionTools(caps, bundle) {
                 if (!argUserId) {
                     throw new Error('群聊戳一戳必须显式提供 user_id（要戳的对象）。');
                 }
-                try {
-                    await callAction(platform, selfId, 'group_poke', {
-                        group_id: Number(groupId),
-                        user_id: Number(argUserId),
-                    });
-                }
-                catch {
-                    await callAction(platform, selfId, 'send_group_poke', {
-                        group_id: Number(groupId),
-                        user_id: Number(argUserId),
-                    });
-                }
+                await callFirstSupported(platform, selfId, ['group_poke', 'send_group_poke'], {
+                    group_id: Number(groupId),
+                    user_id: Number(argUserId),
+                });
                 return `已在群 ${groupId} 戳了 ${argUserId} 一下`;
             }
             // 2) 私聊场景：从 user_id 或当前私聊会话对方取目标
@@ -1486,13 +1477,7 @@ function registerInteractionTools(caps, bundle) {
             if (!userId) {
                 throw new Error('无法判断戳一戳目标：当前不在 OneBot 会话内，请显式传入 group_id+user_id 或 user_id。');
             }
-            // NapCat: friend_poke { user_id }；其他实现可能用 send_poke
-            try {
-                await callAction(platform, selfId, 'friend_poke', { user_id: Number(userId) });
-            }
-            catch {
-                await callAction(platform, selfId, 'send_poke', { user_id: Number(userId) });
-            }
+            await callFirstSupported(platform, selfId, ['friend_poke', 'send_poke'], { user_id: Number(userId) });
             return `已戳了 ${userId} 一下`;
         },
     });
@@ -1508,6 +1493,7 @@ function registerInteractionTools(caps, bundle) {
                     properties: {
                         user_id: { type: 'string', description: '要赞的用户 QQ 号' },
                         times: { type: 'number', description: '赞的次数，默认 1，每天每个好友最多 10 次' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: ['user_id'],
                 },
@@ -1534,6 +1520,7 @@ function registerInteractionTools(caps, bundle) {
                     type: 'object',
                     properties: {
                         group_id: { type: 'string', description: '可选：目标群号。不传则使用当前群会话的群号。' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: [],
                 },
@@ -1547,53 +1534,7 @@ function registerInteractionTools(caps, bundle) {
             return '打卡成功';
         },
     });
-    logger.info('OneBot 特殊交互工具已注册');
-}
-/**
- * 把 OneBot 的细粒度访问规则注册到 session-history 服务。
- * 通用工具 session_get_history 和平台专属工具 onebot_get_session_history
- * 调用 service 时都会走这条规则链 —— 不存在绕过路径。
- */
-function registerOneBotHistoryAccessChecker(caps, cfg) {
-    const { logger, sessionHistory } = caps;
-    const checker = {
-        platform: 'onebot',
-        check({ currentSessionId, targetSessionId }) {
-            const target = parseOneBotSession(targetSessionId);
-            if (!target)
-                return undefined; // 不是合法 onebot 目标, 不表态
-            const current = parseOneBotSession(currentSessionId);
-            // 跨平台调用（current 不是 onebot）走默认放行: session-history scope 已粗筛
-            if (!current)
-                return undefined;
-            if (current.selfId !== target.selfId && !cfg.allowCrossSelf) {
-                return { decision: 'deny', reason: '当前 OneBot 配置不允许跨机器人账号读取会话历史' };
-            }
-            if (current.detailType === 'group' && target.detailType === 'private' && !cfg.allowGroupReadPrivate) {
-                return { decision: 'deny', reason: '当前 OneBot 配置不允许从群聊读取私聊历史' };
-            }
-            if (current.detailType === 'group' &&
-                target.detailType === 'group' &&
-                current.targetId !== target.targetId &&
-                !cfg.allowCrossGroup) {
-                return { decision: 'deny', reason: '当前 OneBot 配置不允许跨群读取其他群历史' };
-            }
-            if (current.detailType === 'private' &&
-                target.detailType === 'private' &&
-                current.targetId !== target.targetId &&
-                !cfg.allowCrossPrivate) {
-                return { decision: 'deny', reason: '当前 OneBot 配置不允许跨私聊读取其他私聊历史' };
-            }
-            return undefined;
-        },
-    };
-    // 规则登记在 session-history 提供者实例的局部状态里：提供者重启或换人后，新实例身上没有这条规则，
-    // 须跟随提供者重挂；返回的注销作为跟随清理，本插件 bounce / 卸载时一并撤回，不在下层泄漏。
-    sessionHistory.follow(svc => {
-        const dispose = svc.registerAccessChecker(checker);
-        logger.info('OneBot 会话历史访问规则已注册到 session-history');
-        return dispose;
-    });
+    logger.use.info('OneBot 特殊交互工具已注册');
 }
 function registerSessionHistoryTools(caps, bundle, cfg) {
     const { platform, logger, sessionHistory } = caps;
@@ -1613,7 +1554,7 @@ function registerSessionHistoryTools(caps, bundle, cfg) {
                             description: 'group = 群聊，private = 私聊',
                         },
                         target_id: { type: 'string', description: '群号或 QQ 号' },
-                        self_id: { type: 'string', description: '机器人账号。可选，默认使用当前 OneBot 会话的 selfId' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: ['target_type', 'target_id'],
                     additionalProperties: false,
@@ -1621,26 +1562,14 @@ function registerSessionHistoryTools(caps, bundle, cfg) {
             },
         },
         handler: async (args, callCtx) => {
-            const current = parseOneBotSession(callCtx.sessionId);
             const targetType = String(args.target_type ?? '').toLowerCase();
             const targetId = String(args.target_id ?? '').trim();
             if (targetType !== 'group' && targetType !== 'private') {
-                return JSON.stringify({ error: `target_type 必须为 group 或 private，收到 ${args.target_type}` });
+                throw new Error(`target_type 必须为 group 或 private，收到 ${args.target_type}`);
             }
             if (!targetId)
-                return JSON.stringify({ error: 'target_id 不能为空' });
-            const argSelfId = args.self_id ? String(args.self_id).trim() : '';
-            const selfId = argSelfId || current?.selfId || getAnyOneBotSelfId(platform) || '';
-            if (!selfId)
-                return JSON.stringify({ error: '无法确定 self_id，且未找到可用的 OneBot 连接' });
-            // 跨账号限制：仅在当前也是 OneBot 会话时才作为参考点检查
-            if (current && !cfg.allowCrossSelf && selfId !== current.selfId) {
-                return JSON.stringify({
-                    error: '当前配置不允许跨机器人账号解析会话',
-                    currentSelfId: current.selfId,
-                    requestedSelfId: selfId,
-                });
-            }
+                throw new Error('target_id 不能为空');
+            const selfId = resolveSelfId(platform, callCtx, args);
             return JSON.stringify({
                 ok: true,
                 sessionId: buildOneBotSessionId(selfId, targetType, targetId),
@@ -1658,7 +1587,7 @@ function registerSessionHistoryTools(caps, bundle, cfg) {
                 description: [
                     '按 QQ 群号或 QQ 号读取对应 OneBot 会话最近若干条历史消息。',
                     '适用场景：用户明确要求你回忆某个群/私聊最近说过什么，或需要核实另一个 OneBot 会话的原文上下文。',
-                    '默认禁止从群聊读取私聊历史；如需语义搜索历史，请优先使用 memory_recall。',
+                    '能读哪些会话按会话管理的跨会话规则（默认不读别人的私聊）；如需语义搜索历史，请优先使用 memory_recall。',
                 ].join('\n'),
                 parameters: {
                     type: 'object',
@@ -1673,7 +1602,7 @@ function registerSessionHistoryTools(caps, bundle, cfg) {
                             type: 'number',
                             description: `读取最近多少条，默认 ${cfg.defaultLimit}，最多 ${cfg.maxLimit}`,
                         },
-                        self_id: { type: 'string', description: '机器人账号。可选，默认使用当前 OneBot 会话的 selfId' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: ['target_type', 'target_id'],
                     additionalProperties: false,
@@ -1681,57 +1610,63 @@ function registerSessionHistoryTools(caps, bundle, cfg) {
             },
         },
         handler: async (args, callCtx) => {
-            const current = parseOneBotSession(callCtx.sessionId);
             const targetType = String(args.target_type ?? '').toLowerCase();
             const targetId = String(args.target_id ?? '').trim();
             if (targetType !== 'group' && targetType !== 'private') {
-                return JSON.stringify({ error: `target_type 必须为 group 或 private，收到 ${args.target_type}` });
+                throw new Error(`target_type 必须为 group 或 private，收到 ${args.target_type}`);
             }
             if (!targetId)
-                return JSON.stringify({ error: 'target_id 不能为空' });
-            const argSelfId = args.self_id ? String(args.self_id).trim() : '';
-            const selfId = argSelfId || current?.selfId || getAnyOneBotSelfId(platform) || '';
-            if (!selfId)
-                return JSON.stringify({ error: '无法确定 self_id，且未找到可用的 OneBot 连接' });
-            const history = sessionHistory.current;
-            if (!history)
-                return JSON.stringify({
-                    error: 'session-history 服务不可用，请启用 @aalis/plugin-tool-session',
-                });
+                throw new Error('target_id 不能为空');
+            const selfId = resolveSelfId(platform, callCtx, args);
+            if (!sessionHistory.present)
+                throw new Error('session-history 服务不可用，请启用 @aalis/plugin-tool-session');
+            const history = sessionHistory.use;
             const limit = Math.max(1, Math.min(cfg.maxLimit, Math.floor(Number(args.limit) || cfg.defaultLimit)));
             const sessionId = buildOneBotSessionId(selfId, targetType, targetId);
+            let result;
             try {
-                // 访问控制（跨账号/群读私/跨群/跨私）由 session-history 服务统一执行，
-                // OneBot 的规则已通过 registerOneBotHistoryAccessChecker 注册。
+                // 能不能读由 session-history 服务按会话管理的规则判（带这次调用的授权身份）。
                 // includeArchived 故意不暴露：archived 是 memory 内部细节，被 summary 替代的老消息
                 // 默认就不该再翻原文（会与 summary 内容双重计费）。如需考古应另起独立工具。
-                const result = await history.getHistory({ sessionId, limit }, callCtx);
-                return JSON.stringify({
-                    ...result,
-                    sessionId,
-                    selfId,
-                    targetType,
-                    targetId,
-                });
+                result = await history.getHistory({ sessionId, limit }, callCtx);
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
-                logger.warn(`onebot_get_session_history 失败 (${sessionId}): ${message}`);
-                return JSON.stringify({ error: `读取 OneBot 会话历史失败: ${message}` });
+                logger.use.warn(`onebot_get_session_history 失败 (${sessionId}): ${message}`);
+                throw new Error(`读取 OneBot 会话历史失败: ${message}`);
             }
+            if ('error' in result)
+                throw new Error(result.error);
+            return JSON.stringify({
+                ...result,
+                sessionId,
+                selfId,
+                targetType,
+                targetId,
+            });
         },
     });
-    logger.info('OneBot 会话历史工具已注册');
+    logger.use.info('OneBot 会话历史工具已注册');
 }
-// ===== 请求处理工具（好友申请 / 群请求）=====
 function registerRequestTools(caps, bundle) {
     const { platform, logger } = caps;
     const { group, personal } = bundle;
-    /** 找到支持 handleFriendRequest 的 OneBot 适配器 */
-    function findRequestAdapter(platform) {
-        const adapter = getPlatformAdapters(platform).find(a => a.platform === 'onebot' && typeof a.handleFriendRequest === 'function');
-        return adapter;
+    /**
+     * 处理申请的账号与 OneBot 适配器：申请挂在收到它的实例上，按当前会话（或 self_id）的账号路由。
+     * 申请的通知注入在收到它的账号的会话里，在那里调用即落到对的实例与账号
+     */
+    async function requestHandler(callCtx, args) {
+        const selfId = resolveSelfId(platform, callCtx, args);
+        const adapter = (await resolvePlatformBySession(platform, selfSessionId(selfId)))?.use;
+        if (typeof adapter?.handleFriendRequest !== 'function')
+            throw new Error('未找到支持请求处理的 OneBot 适配器');
+        return { selfId, adapter: adapter };
     }
+    /** 两个群请求工具各认自己的申请类型：用审批加群申请的工具批不了入群邀请，反之亦然 */
+    const handleGroupRequest = (subType) => async (args, callCtx) => {
+        const { selfId, adapter } = await requestHandler(callCtx, args);
+        return adapter.handleGroupRequest(selfId, subType, String(args.user_id), String(args.group_id), !!args.approve, args.reason ? String(args.reason) : undefined);
+    };
     personal.register({
         definition: {
             type: 'function',
@@ -1744,22 +1679,21 @@ function registerRequestTools(caps, bundle) {
                         user_id: { type: 'string', description: '发起好友申请的用户 QQ 号' },
                         approve: { type: 'boolean', description: 'true = 同意，false = 拒绝' },
                         remark: { type: 'string', description: '同意后添加的备注（可选）' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: ['user_id', 'approve'],
                 },
             },
         },
-        handler: async (args) => {
-            const adapter = findRequestAdapter(platform);
-            if (!adapter)
-                return '未找到支持请求处理的 OneBot 适配器';
-            return adapter.handleFriendRequest(String(args.user_id), !!args.approve, args.remark ? String(args.remark) : undefined);
+        handler: async (args, callCtx) => {
+            const { selfId, adapter } = await requestHandler(callCtx, args);
+            return adapter.handleFriendRequest(selfId, String(args.user_id), !!args.approve, args.remark ? String(args.remark) : undefined);
         },
     });
     // 群相关请求拆成两个工具，对应 OneBot v11 set_group_add_request 的两种 sub_type：
     // - approve_join_request: sub_type=add 「别人申请加入 bot 管理的群」 → 群务
     // - handle_group_invite:  sub_type=invite 「别人邀请 bot 加入群」 → 个人/私聊
-    // 底层共用同一个适配器方法（pendingGroupRequests 内部已记录 subType），区别在于语义与权限归属。
+    // 底层共用同一个适配器方法，各自把要处理的申请类型交给它，类型不符就报错。
     group.register({
         definition: {
             type: 'function',
@@ -1773,17 +1707,13 @@ function registerRequestTools(caps, bundle) {
                         group_id: { type: 'string', description: '相关群号' },
                         approve: { type: 'boolean', description: 'true = 同意加群，false = 拒绝' },
                         reason: { type: 'string', description: '拒绝理由（拒绝时有效，可选）' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: ['user_id', 'group_id', 'approve'],
                 },
             },
         },
-        handler: async (args) => {
-            const adapter = findRequestAdapter(platform);
-            if (!adapter)
-                return '未找到支持请求处理的 OneBot 适配器';
-            return adapter.handleGroupRequest(String(args.user_id), String(args.group_id), !!args.approve, args.reason ? String(args.reason) : undefined);
-        },
+        handler: handleGroupRequest('add'),
     });
     personal.register({
         definition: {
@@ -1798,18 +1728,14 @@ function registerRequestTools(caps, bundle) {
                         group_id: { type: 'string', description: '被邀请加入的群号' },
                         approve: { type: 'boolean', description: 'true = 接受邀请并加入群，false = 拒绝' },
                         reason: { type: 'string', description: '拒绝理由（拒绝时有效，可选）' },
+                        self_id: SELF_ID_PARAM,
                     },
                     required: ['user_id', 'group_id', 'approve'],
                 },
             },
         },
-        handler: async (args) => {
-            const adapter = findRequestAdapter(platform);
-            if (!adapter)
-                return '未找到支持请求处理的 OneBot 适配器';
-            return adapter.handleGroupRequest(String(args.user_id), String(args.group_id), !!args.approve, args.reason ? String(args.reason) : undefined);
-        },
+        handler: handleGroupRequest('invite'),
     });
-    logger.info('OneBot 请求处理工具已注册');
+    logger.use.info('OneBot 请求处理工具已注册');
 }
 //# sourceMappingURL=index.js.map