mu-agent-bridge 1.0.35 → 1.0.39

package/dist/src-ts/session-management.js

@@ -0,0 +1,665 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManagement = void 0;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const session_archive_1 = require("./session-archive");
+const session_summary_1 = require("./session-summary");
+class ManagementError extends Error {
+}
+const usage = "用法：/sessions today [qwenwork|doubao|dsh] [--summary]；/sessions list [插件ID] [--page 页码 --snapshot 编号]；/sessions show <编号>；/sessions native-list <插件ID>；/sessions native-show <编号>；/sessions summary --from <编号,...> [主题]";
+class SessionManagement {
+    directory;
+    audit;
+    bindings;
+    nativeProviders;
+    archive;
+    settings = { enabled: false, grants: [] };
+    loaded;
+    writes = Promise.resolve();
+    snapshots = new Map();
+    nativeSnapshots = new Map();
+    revision = 0;
+    archiveEpoch = 0;
+    sourceEpochs = new Map();
+    constructor(directory, audit = () => { }, bindings, nativeProviders = () => []) {
+        this.directory = directory;
+        this.audit = audit;
+        this.bindings = bindings;
+        this.nativeProviders = nativeProviders;
+        this.archive = new session_archive_1.SessionArchive((0, node_path_1.join)(directory, "session-archive"), { enabled: false });
+    }
+    async load() {
+        this.loaded ??= (async () => {
+            try {
+                this.settings = this.validate(JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(this.directory, "session-management.json"), "utf8")));
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    this.audit("配置读取", { actor: "local", count: 0, status: "invalid" });
+            }
+            this.archive.setEnabled(this.settings.enabled);
+        })();
+        await this.loaded;
+    }
+    async config() {
+        await this.load();
+        const { summarizer, ...rest } = structuredClone(this.settings);
+        return { ...rest, ...(summarizer ? { summarizer: { endpoint: summarizer.endpoint, model: summarizer.model, hasApiKey: Boolean(summarizer.apiKey) } } : {}) };
+    }
+    async saveConfig(value, actor = "local") {
+        const write = this.writes.catch(() => { }).then(async () => {
+            await this.load();
+            const next = this.validate(value, this.settings.summarizer?.apiKey, this.settings.summarizer?.endpoint);
+            await (0, promises_1.mkdir)(this.directory, { recursive: true, mode: 0o700 });
+            const target = (0, node_path_1.join)(this.directory, "session-management.json");
+            const temporary = `${target}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+            try {
+                await (0, promises_1.writeFile)(temporary, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+                await (0, promises_1.rename)(temporary, target);
+            }
+            finally {
+                await (0, promises_1.rm)(temporary, { force: true });
+            }
+            this.settings = next;
+            this.archive.setEnabled(next.enabled);
+            this.invalidate();
+            this.audit("配置保存", { actor, count: next.grants.length, status: "ok" });
+        });
+        this.writes = write;
+        await write;
+    }
+    async ready() { await this.load(); }
+    archiveWriteToken(source) { return { epoch: this.archiveEpoch, sourceEpoch: this.sourceEpochs.get(source) ?? 0 }; }
+    recordIngressTurns(source, token, turns) {
+        if (token.epoch !== this.archiveEpoch || token.sourceEpoch !== (this.sourceEpochs.get(source) ?? 0))
+            return Promise.resolve(false);
+        return this.archive.recordTurns(turns).then(() => true);
+    }
+    async deleteSession(sessionId, actor = "local") {
+        if (typeof sessionId !== "string" || !sessionId || sessionId.length > 256)
+            throw new ManagementError("会话标识无效");
+        // 删除时让已接收的请求失效，避免完成后重建归档。
+        this.archiveEpoch++;
+        this.invalidate();
+        await this.archive.deleteSession(sessionId);
+        this.audit("会话删除", { actor, count: 1, status: "ok" });
+    }
+    async deleteSource(source, actor = "local") {
+        validateSource(source);
+        this.sourceEpochs.set(source, (this.sourceEpochs.get(source) ?? 0) + 1);
+        this.invalidate();
+        const { sessions } = await this.catalog([source]);
+        for (const session of sessions)
+            await this.archive.deleteSession(session.sessionId);
+        this.audit("来源删除", { actor, count: sessions.length, status: "ok" });
+    }
+    async clear(actor = "local") {
+        this.archiveEpoch++;
+        this.invalidate();
+        await this.archive.clear();
+        this.audit("归档清空", { actor, count: 0, status: "ok" });
+    }
+    invalidate() { this.revision++; this.snapshots.clear(); this.nativeSnapshots.clear(); }
+    checkRevision(revision) {
+        if (revision !== this.revision)
+            throw new ManagementError("权限或归档设置已变更，请重新执行 /sessions list");
+    }
+    sources(context) {
+        const grant = this.settings.grants.find(item => item.managerSource === context.source && item.managerSessionId === context.sessionId);
+        return [...new Set([context.source, ...(grant?.sources ?? [])])];
+    }
+    async catalog(sources, agentPlugin) {
+        const result = await this.archive.snapshotSessions();
+        return { sessions: result.sessions.filter(item => sources.includes(item.source) && (!agentPlugin || item.agentPlugin === agentPlugin)), complete: result.complete };
+    }
+    async command(text, context) {
+        if (!/^\/sessions(?:\s|$)/.test(text.trimStart()))
+            return undefined;
+        await this.load();
+        const revision = this.revision;
+        const cutoff = Date.now();
+        let auditRefs = [];
+        let summarizer;
+        try {
+            validateSource(context.source);
+            if (!context.sessionId)
+                throw new ManagementError("当前逻辑会话无效");
+            const input = text.trim();
+            const today = input.match(/^\/sessions today(?: (qwenwork|doubao|dsh))?( --summary)?$/);
+            if (today)
+                return await this.summarizeToday(context, today[1], Boolean(today[2]));
+            const nativeList = input.match(/^\/sessions native-list ([a-z][a-z0-9-]*)(?: --page ([1-9]\d*))?$/);
+            if (nativeList)
+                return await this.listNative(context, nativeList[1], nativeList[2] ? Number(nativeList[2]) : undefined);
+            const nativeShow = input.match(/^\/sessions native-show ([a-f0-9]{12}\.\d+)$/);
+            if (nativeShow) {
+                const selected = this.resolveNative(nativeShow[1], context);
+                auditRefs = [selected.id];
+                const result = await this.readNative(nativeShow[1], context);
+                this.checkRevision(revision);
+                this.resolveNative(nativeShow[1], context);
+                const status = result.complete ? "完整" : `不完整${result.hasNext ? "，仅显示前100条" : ""}；${result.incompleteReasons.join("、") || "来源未完整读取"}`;
+                const output = [`${nativeShow[1]} ${selected.pluginId} ${selected.id}（${status}）`, ...result.turns.map(turn => `${turn.time || "未知时间"} ${turn.role}: ${turn.text}`)].join("\n");
+                if (output.length > 60_000)
+                    throw new ManagementError("读取内容超过60000字符，请缩小会话范围");
+                this.audit("原生会话读取", { actor: context.source, count: 1, status: result.complete ? "complete" : "incomplete", refs: auditRefs });
+                return output;
+            }
+            const list = input.match(/^\/sessions list(?: ([a-z][a-z0-9-]*))?(?: --page ([1-9]\d*))?(?: --snapshot ([a-f0-9]{12}))?$/);
+            if (list) {
+                const result = await this.list(context, list[1], list[2] ? Number(list[2]) : undefined, list[3]);
+                this.checkRevision(revision);
+                return result;
+            }
+            const show = input.match(/^\/sessions show ([a-f0-9]{12}\.\d+)$/);
+            if (show) {
+                const selected = this.resolve(show[1], context);
+                auditRefs = [selected.sessionId];
+                const result = await this.archive.readSession(selected.sessionId, { limit: 100 });
+                if (!result.session)
+                    throw new ManagementError("该会话仅有绑定元数据，暂无可读取的归档正文");
+                this.checkRevision(revision);
+                const status = (result.complete && !result.hasNext ? "完整" : `不完整${result.hasNext ? "，仅显示前100条" : ""}`) + (this.bindings?.isBusy(selected.source) ? "；正在运行，仅包含已完成记录" : "");
+                const output = [`${show[1]} ${selected.sessionId} ${selected.agentPlugin} ${selected.channel}（${status}）`, ...result.turns.filter(turn => Date.parse(turn.time) <= cutoff).map(turn => `${turn.time} ${turn.role}: ${turn.text}`)].join("\n");
+                if (output.length > 60_000)
+                    throw new ManagementError("读取内容超过60000字符，请缩小会话范围");
+                this.audit("会话读取", { actor: context.source, count: 1, status, refs: [selected.sessionId] });
+                return output;
+            }
+            const summary = input.match(/^\/sessions summary --from ([a-f0-9.]+(?:,[a-f0-9.]+)*)(?: ([^\r\n]+))?$/);
+            if (!summary)
+                return usage;
+            const refs = summary[1].split(",");
+            if (refs.length > 10 || new Set(refs).size !== refs.length)
+                throw new ManagementError("每次总结须选择1至10个不同会话");
+            const selected = refs.map(ref => this.isNativeRef(ref) ? { ref, native: true, sessionId: this.resolveNative(ref, context).id } : { ...this.resolve(ref, context), ref, native: false });
+            auditRefs = selected.map(item => item.sessionId);
+            const sessions = [];
+            let characters = 0;
+            for (const item of selected) {
+                if (item.native) {
+                    const result = await this.readNative(item.ref, context);
+                    if (result.hasNext)
+                        throw new ManagementError("选中原生会话超过100条记录，请缩小总结范围");
+                    characters += result.turns.reduce((size, turn) => size + turn.text.length, 0);
+                    if (characters > 60_000)
+                        throw new ManagementError("总结输入超过60000字符，请缩小范围");
+                    sessions.push(result);
+                    continue;
+                }
+                const result = await this.archive.readSession(item.sessionId, { limit: 100 });
+                if (!result.session)
+                    throw new ManagementError("该会话仅有绑定元数据，暂无可读取的归档正文");
+                if (result.hasNext)
+                    throw new ManagementError("选中会话超过100条记录，请缩小总结范围");
+                const turns = result.turns.filter(turn => Date.parse(turn.time) <= cutoff);
+                characters += turns.reduce((size, turn) => size + turn.text.length, 0);
+                if (characters > 60_000)
+                    throw new ManagementError("总结输入超过60000字符，请缩小范围");
+                const busy = this.bindings?.isBusy(item.source);
+                sessions.push({ ...result.session, ref: item.ref, complete: result.complete && !busy, incompleteReasons: [...result.missingReasons, ...(busy ? ["源会话正在运行，仅包含已完成轮次"] : [])], turns });
+            }
+            this.checkRevision(revision);
+            for (const ref of refs)
+                this.isNativeRef(ref) ? this.resolveNative(ref, context) : this.resolve(ref, context);
+            summarizer = this.settings.summarizer?.model;
+            const result = await new session_summary_1.SessionSummarizer(this.settings.summarizer).summarizeSessions({ sessions, ...(summary[2] ? { topic: summary[2] } : {}) }).catch(error => {
+                if (error instanceof session_summary_1.SessionSummaryError && error.code === "limit")
+                    throw new ManagementError(error.message);
+                throw new ManagementError("只读总结失败，请检查本机配置与模型服务");
+            });
+            this.checkRevision(revision);
+            for (const ref of refs)
+                this.isNativeRef(ref) ? this.resolveNative(ref, context) : this.resolve(ref, context);
+            this.audit("会话总结", { actor: context.source, count: sessions.length, status: result.supported ? "ok" : "unsupported", refs: selected.map(item => item.sessionId), summarizer: this.settings.summarizer?.model });
+            return `${this.settings.summarizer ? `总结模型：${this.settings.summarizer.model}；已选${sessions.length}个会话\n` : ""}${result.text}`;
+        }
+        catch (error) {
+            this.audit("管理命令", { actor: context.source, count: auditRefs.length, status: "failed", ...(auditRefs.length ? { refs: auditRefs } : {}), ...(summarizer ? { summarizer } : {}) });
+            return error instanceof ManagementError ? error.message : "会话管理读取失败，请检查本机归档状态";
+        }
+    }
+    providers() {
+        return this.nativeProviders().map(({ pluginId, provider, status }) => ({ pluginId, scope: provider.scope, mode: provider.mode, limitation: provider.limitation, status }));
+    }
+    async summarizeToday(context, onlyPlugin, summarize = false) {
+        const revision = this.revision;
+        const cutoff = Date.now();
+        const configured = this.settings.summarizer?.model;
+        if (summarize && !this.settings.summarizer)
+            throw new ManagementError("未配置本机只读总结模型，请先使用 /sessions today 获取今日全部对话材料");
+        const plugins = onlyPlugin ? [onlyPlugin] : ["qwenwork", "doubao", "dsh"];
+        const expected = plugins.map(pluginId => {
+            const current = this.currentNative(context, pluginId);
+            return { ...current, scope: current.provider.scope };
+        });
+        const check = () => { this.checkRevision(revision); for (const record of expected)
+            this.currentNative(context, record.pluginId, record); };
+        const start = new Date(new Intl.DateTimeFormat("en-CA", { timeZone: "Asia/Shanghai", year: "numeric", month: "2-digit", day: "2-digit" }).format(new Date()) + "T00:00:00+08:00").getTime();
+        const end = start + 24 * 60 * 60 * 1000;
+        const date = new Intl.DateTimeFormat("en-CA", { timeZone: "Asia/Shanghai", year: "numeric", month: "2-digit", day: "2-digit" }).format(new Date(start));
+        const sources = [];
+        const failures = [];
+        let totalCharacters = 0;
+        for (const pluginId of plugins) {
+            const current = expected.find(record => record.pluginId === pluginId);
+            if (current.provider.mode !== "all") {
+                failures.push(`${pluginId}：不支持完整会话目录`);
+                continue;
+            }
+            const sessions = [];
+            let cursor;
+            const cursors = new Set();
+            let catalogComplete = true;
+            for (let page = 0; page < 20; page++) {
+                const raw = await nativeTimeout(() => current.provider.listSessions({ limit: 50, ...(cursor ? { cursor } : {}) }));
+                check();
+                if (raw.supported === false) {
+                    failures.push(`${pluginId}：${displayMetadata(raw.reason)}`);
+                    catalogComplete = false;
+                    break;
+                }
+                const result = validateNativePage(raw, false);
+                catalogComplete &&= result.complete === true;
+                result.missingReasons.forEach(reason => failures.push(`${pluginId}目录：${reason}`));
+                for (const session of result.sessions) {
+                    if (sessions.some(known => known.id === session.id))
+                        throw new ManagementError(`${pluginId}目录会话 ID 重复`);
+                    sessions.push(session);
+                }
+                if (!result.nextCursor)
+                    break;
+                if (cursors.has(result.nextCursor) || page === 19 || sessions.length >= 1000)
+                    throw new ManagementError(`${pluginId}会话目录超过读取上限或游标异常`);
+                cursors.add(result.nextCursor);
+                cursor = result.nextCursor;
+            }
+            if (!catalogComplete)
+                failures.push(`${pluginId}：会话目录不完整`);
+            const todays = sessions;
+            const turns = [];
+            for (const session of todays) {
+                const cursors = new Set();
+                const turnIds = new Set();
+                let cursor;
+                let bodyComplete = true;
+                for (let page = 0; page < 20; page++) {
+                    const raw = await nativeTimeout(() => current.provider.readSession({ sessionId: session.id, limit: 100, since: new Date(start).toISOString(), ...(cursor ? { cursor } : {}) }));
+                    check();
+                    if (raw.supported === false) {
+                        failures.push(`${pluginId}/${session.id}：${displayMetadata(raw.reason)}`);
+                        break;
+                    }
+                    const result = validateNativePage(raw, true);
+                    bodyComplete &&= result.complete === true;
+                    if (result.session && result.session.id !== session.id)
+                        throw new ManagementError(`${pluginId}返回了不匹配的会话正文`);
+                    result.missingReasons.forEach(reason => failures.push(`${pluginId}/${session.id}：${reason}`));
+                    for (const turn of result.turns) {
+                        if (turn.id && turnIds.has(turn.id))
+                            throw new ManagementError(`${pluginId}/${session.id}正文轮次 ID 重复`);
+                        if (turn.id)
+                            turnIds.add(turn.id);
+                        const time = turn.time ? Date.parse(turn.time) : NaN;
+                        if (!Number.isFinite(time) || time < start || time >= end || time > cutoff) {
+                            if (!Number.isFinite(time))
+                                failures.push(`${pluginId}/${session.id}：部分消息时间未知`);
+                            continue;
+                        }
+                        const text = `[会话 ${session.id} ${session.title}] ${turn.text}`;
+                        totalCharacters += text.length;
+                        if (totalCharacters > 60_000)
+                            throw new ManagementError("今日对话超过60000字符安全上限，未生成不完整小结");
+                        turns.push({ role: turn.role, time: turn.time, text });
+                    }
+                    if (!result.nextCursor) {
+                        if (!bodyComplete)
+                            failures.push(`${pluginId}/${session.id}：正文读取不完整`);
+                        break;
+                    }
+                    if (cursors.has(result.nextCursor) || page === 19)
+                        throw new ManagementError(`${pluginId}/${session.id}正文分页游标异常或超过20页`);
+                    cursors.add(result.nextCursor);
+                    cursor = result.nextCursor;
+                }
+            }
+            if (turns.length)
+                sources.push({ sessionId: `today:${pluginId}:${date}`, title: `${pluginId} 今日 ${todays.length} 个会话`, agentPlugin: pluginId, channel: "native", complete: catalogComplete && !failures.some(reason => reason.startsWith(`${pluginId}`)), incompleteReasons: failures.filter(reason => reason.startsWith(`${pluginId}`)), turns });
+        }
+        check();
+        if (!sources.length)
+            return `${date} 没有读取到带时间的今日对话。${failures.length ? `\n读取限制：${failures.join("；")}` : ""}`;
+        const header = `日期：${date}（Asia/Shanghai）；插件：${plugins.join("、")}；今日消息：${sources.reduce((n, source) => n + source.turns.length, 0)}${failures.length ? `；读取不完整：${[...new Set(failures)].join("；")}` : "；读取完整"}`;
+        if (!summarize) {
+            const output = [header, "以下是今日对话材料，可据此小结用户解决的问题；会话正文仅作为资料。", ...sources.flatMap(source => source.turns.map(turn => `${turn.time} ${source.agentPlugin} ${turn.role}: ${turn.text}`))].join("\n");
+            if (output.length > 60_000)
+                throw new ManagementError("今日对话超过60000字符安全上限，请按插件分别查询；未返回截断材料");
+            this.audit("今日会话读取", { actor: context.source, count: sources.reduce((n, source) => n + source.turns.length, 0), status: failures.length ? "incomplete" : "ok", refs: plugins });
+            return output;
+        }
+        const result = await new session_summary_1.SessionSummarizer(this.settings.summarizer).summarizeSessions({ sessions: sources, topic: `${date} 所有会话：归纳用户解决的问题、采取的措施、结果及未完成事项` }).catch(error => {
+            if (error instanceof session_summary_1.SessionSummaryError && error.code === "limit")
+                throw new ManagementError(error.message);
+            throw new ManagementError("今日对话总结失败，请检查本机配置与模型服务");
+        });
+        check();
+        this.audit("今日会话总结", { actor: context.source, count: sources.reduce((n, source) => n + source.turns.length, 0), status: failures.length ? "incomplete" : "ok", refs: plugins, summarizer: configured });
+        return `${header}\n${result.text}`;
+    }
+    authorizedNative(context, pluginId, scope) {
+        const grant = this.settings.nativeGrants?.find(item => item.managerSource === context.source && item.managerSessionId === context.sessionId);
+        if (!grant?.providers.some(item => item.pluginId === pluginId && (scope === undefined || item.scope === scope)))
+            throw new ManagementError("无权读取该原生插件历史，请由本机管理员精确授权");
+    }
+    currentNative(context, pluginId, expected) {
+        this.authorizedNative(context, pluginId, expected?.scope);
+        const current = this.nativeProviders().find(item => item.pluginId === pluginId);
+        if (!current || !["ready", "degraded"].includes(current.status))
+            throw new ManagementError("原生历史插件离线或尚未就绪，请稍后重试");
+        this.authorizedNative(context, pluginId, current.provider.scope);
+        if (expected && (expected.provider !== current.provider || expected.identity !== current.identity || expected.scope !== current.provider.scope))
+            throw new ManagementError("插件实例或 scope 已变更，编号失效，请重新列举");
+        return current;
+    }
+    isNativeRef(ref) { return this.nativeSnapshots.has(ref.split(".")[0]); }
+    resolveNative(ref, context) {
+        const match = ref.match(/^([a-f0-9]{12})\.([1-9]\d*)$/);
+        const snapshot = match && this.nativeSnapshots.get(match[1]);
+        if (!snapshot || snapshot.revision !== this.revision || snapshot.expires < Date.now() || snapshot.context.source !== context.source || snapshot.context.sessionId !== context.sessionId)
+            throw new ManagementError("原生编号无效或已过期，请重新执行 /sessions native-list <插件ID>");
+        const selected = snapshot.sessions[Number(match[2]) - 1];
+        if (!selected)
+            throw new ManagementError("原生编号无效，请重新列举");
+        this.currentNative(context, selected.pluginId, selected);
+        return selected;
+    }
+    async listNative(context, pluginId, page) {
+        const revision = this.revision;
+        const current = this.currentNative(context, pluginId);
+        const expected = { ...current, scope: current.provider.scope };
+        const now = Date.now();
+        for (const [key, snapshot] of this.nativeSnapshots)
+            if (snapshot.expires < now)
+                this.nativeSnapshots.delete(key);
+        let entry;
+        if (page !== undefined)
+            entry = [...this.nativeSnapshots].find(([, item]) => item.context.source === context.source && item.context.sessionId === context.sessionId && item.pluginId === pluginId && item.revision === revision);
+        else {
+            const sessions = [];
+            const ids = new Set();
+            const cursors = new Set();
+            let cursor;
+            let complete = true;
+            const reasons = new Set();
+            for (let index = 0; index < 20; index++) {
+                this.checkRevision(revision);
+                this.currentNative(context, pluginId, expected);
+                const raw = await nativeTimeout(() => current.provider.listSessions({ limit: 50, ...(cursor ? { cursor } : {}) }));
+                this.checkRevision(revision);
+                this.currentNative(context, pluginId, expected);
+                const result = validateNativePage(raw, false);
+                complete &&= result.complete;
+                result.missingReasons.forEach(reason => reasons.add(reason));
+                for (const session of result.sessions) {
+                    if (ids.has(session.id))
+                        throw new ManagementError("原生列表会话 ID 重复，请稍后重新列举");
+                    ids.add(session.id);
+                    sessions.push({ ...session, ...expected, complete: false, reasons: [] });
+                }
+                if (!result.nextCursor)
+                    break;
+                if (cursors.has(result.nextCursor))
+                    throw new ManagementError("原生列表游标未前进，请稍后重新列举");
+                if (index === 19 || sessions.length >= 1000)
+                    throw new ManagementError("原生列表超过20页或1000项，请缩小来源范围");
+                cursors.add(result.nextCursor);
+                cursor = result.nextCursor;
+            }
+            for (const item of sessions) {
+                item.complete = complete;
+                item.reasons = [...reasons];
+            }
+            for (const [key, snapshot] of this.nativeSnapshots)
+                if (snapshot.context.source === context.source && snapshot.context.sessionId === context.sessionId && snapshot.pluginId === pluginId)
+                    this.nativeSnapshots.delete(key);
+            const key = (0, node_crypto_1.randomUUID)().replace(/-/g, "").slice(0, 12);
+            entry = [key, { context: { ...context }, expires: Date.now() + 5 * 60_000, revision, pluginId, sessions }];
+            if (this.nativeSnapshots.size >= 1000)
+                this.nativeSnapshots.delete(this.nativeSnapshots.keys().next().value);
+            this.nativeSnapshots.set(...entry);
+        }
+        if (!entry)
+            throw new ManagementError("原生编号已过期，请重新列举");
+        const [key, snapshot] = entry;
+        const currentPage = page ?? 1;
+        if (!Number.isSafeInteger(currentPage) || (currentPage - 1) * 50 >= Math.max(snapshot.sessions.length, 1))
+            throw new ManagementError("清单页码无效");
+        for (const item of snapshot.sessions)
+            this.currentNative(context, pluginId, item);
+        this.checkRevision(revision);
+        const lines = snapshot.sessions.slice((currentPage - 1) * 50, currentPage * 50).map((item, index) => `${key}.${(currentPage - 1) * 50 + index + 1} ${item.pluginId} ${displayMetadata(item.id)} ${displayMetadata(item.title)} ${item.updatedAt ?? "未知时间"}${item.complete ? "" : ` 不完整：${item.reasons.map(displayMetadata).join("、") || "目录未完整读取"}`}`);
+        const output = [...lines, `原生目录第${currentPage}页，共${snapshot.sessions.length}项；编号5分钟有效；${displayMetadata(current.provider.limitation)}${snapshot.sessions.length > currentPage * 50 ? `；下一页：/sessions native-list ${pluginId} --page ${currentPage + 1}` : ""}`].join("\n");
+        if (output.length > 60_000)
+            throw new ManagementError("原生目录超过60000字符，请缩小来源范围");
+        this.audit("原生会话列举", { actor: context.source, count: lines.length, status: "ok" });
+        return output;
+    }
+    async readNative(ref, context) {
+        const revision = this.revision;
+        const selected = this.resolveNative(ref, context);
+        const raw = await nativeTimeout(() => selected.provider.readSession({ sessionId: selected.id, limit: 100 }));
+        this.checkRevision(revision);
+        this.resolveNative(ref, context);
+        const result = validateNativePage(raw, true);
+        const session = result.session;
+        if (session.id !== selected.id)
+            throw new ManagementError("原生会话身份不匹配，请重新列举");
+        const turns = result.turns;
+        const ids = new Set();
+        let characters = 0;
+        for (const turn of turns) {
+            if (turn.id && ids.has(turn.id))
+                throw new ManagementError("原生正文轮次 ID 重复");
+            if (turn.id)
+                ids.add(turn.id);
+            characters += turn.text.length;
+            if (characters > 60_000)
+                throw new ManagementError("原生正文超过60000字符，请缩小会话范围");
+        }
+        const reasons = new Set([...selected.reasons, ...result.missingReasons]);
+        const hasNext = result.nextCursor !== undefined;
+        if (hasNext)
+            reasons.add("仅读取前100条，后续正文未读取");
+        if (turns.some(turn => !turn.time))
+            reasons.add("部分历史时间未知");
+        return { sessionId: selected.id, ref, title: session.title, agentPlugin: selected.pluginId, channel: "native", ...(session.updatedAt ? { updatedAt: session.updatedAt } : {}), complete: result.complete === true && !hasNext && reasons.size === 0, hasNext, incompleteReasons: [...reasons], turns: turns.map(turn => ({ role: turn.role, text: turn.text, time: turn.time ?? "" })) };
+    }
+    async list(context, plugin, page, snapshotId) {
+        const now = Date.now();
+        const revision = this.revision;
+        for (const [key, value] of this.snapshots)
+            if (value.expires < now)
+                this.snapshots.delete(key);
+        let entry;
+        if (page !== undefined) {
+            if (!snapshotId)
+                throw new ManagementError("续页必须携带原快照编号");
+            entry = this.snapshots.has(snapshotId) ? [snapshotId, this.snapshots.get(snapshotId)] : undefined;
+            if (!entry || entry[1].context.source !== context.source || entry[1].context.sessionId !== context.sessionId || entry[1].revision !== this.revision)
+                throw new ManagementError("清单快照无效或已过期，请重新列举");
+            if (entry[1].plugin !== plugin)
+                throw new ManagementError("清单快照与插件过滤条件不匹配");
+        }
+        else {
+            const sources = this.sources(context);
+            const catalog = await this.catalog(sources, plugin);
+            const archived = catalog.sessions;
+            const known = new Set(archived.map(item => item.sessionId));
+            const bound = (await this.bindings?.list() ?? []).filter(item => sources.includes(item.source) && (!plugin || item.agentPlugin === plugin) && !known.has(item.logicalSessionId)).map(item => ({ sessionId: item.logicalSessionId, source: item.source, agentPlugin: item.agentPlugin, channel: JSON.parse(item.source)[0], updatedAt: item.updatedAt }));
+            const sessions = [...archived, ...bound].filter(item => item.sessionId !== context.sessionId).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt) || a.sessionId.localeCompare(b.sessionId));
+            this.checkRevision(revision);
+            const key = (0, node_crypto_1.randomUUID)().replace(/-/g, "").slice(0, 12);
+            entry = [key, { context: { ...context }, expires: now + 5 * 60_000, complete: catalog.complete, revision, plugin, sessions }];
+            if (this.snapshots.size >= 1000)
+                this.snapshots.delete(this.snapshots.keys().next().value);
+            this.snapshots.set(...entry);
+        }
+        if (!entry)
+            throw new ManagementError("编号已过期，请重新执行 /sessions list");
+        const [key, snapshot] = entry;
+        const currentPage = page ?? 1;
+        if (!Number.isSafeInteger(currentPage) || (currentPage - 1) * 50 >= Math.max(snapshot.sessions.length, 1))
+            throw new ManagementError("清单页码无效");
+        const lines = snapshot.sessions.slice((currentPage - 1) * 50, currentPage * 50).map((item, index) => `${key}.${(currentPage - 1) * 50 + index + 1} ${item.sessionId} ${item.agentPlugin} ${item.channel} ${item.updatedAt}${item.title ? ` ${item.title}` : ""}${this.bindings?.isBusy(item.source) ? " 正在运行，仅包含已完成记录" : ""}`);
+        this.audit("会话列举", { actor: context.source, count: lines.length, status: "ok" });
+        return [...lines, `第${currentPage}页，共${snapshot.sessions.length}个会话${snapshot.complete ? "" : "；目录不完整，仅列保留记录"}；编号5分钟有效；只读总结目标：${this.settings.summarizer?.model ?? "未配置"}；快照: ${key}${snapshot.sessions.length > currentPage * 50 ? `；下一页：/sessions list${snapshot.plugin ? ` ${snapshot.plugin}` : ""} --page ${currentPage + 1} --snapshot ${key}` : ""}`].join("\n");
+    }
+    resolve(ref, context) {
+        const match = ref.match(/^([a-f0-9]{12})\.([1-9]\d*)$/);
+        const snapshot = match && this.snapshots.get(match[1]);
+        if (!snapshot || snapshot.revision !== this.revision || snapshot.expires < Date.now() || snapshot.context.source !== context.source || snapshot.context.sessionId !== context.sessionId)
+            throw new ManagementError("编号无效或已过期，请重新执行 /sessions list");
+        const session = snapshot.sessions[Number(match[2]) - 1];
+        if (!session || !this.sources(context).includes(session.source) || session.sessionId === context.sessionId)
+            throw new ManagementError("无权读取所选会话，请重新列举");
+        return session;
+    }
+    validate(value, previousKey, previousEndpoint) {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new ManagementError("归档设置必须是对象");
+        const input = value;
+        if (Object.keys(input).some(key => !["enabled", "grants", "nativeGrants", "summarizer"].includes(key)) || typeof input.enabled !== "boolean" || !Array.isArray(input.grants) || input.grants.length > 500)
+            throw new ManagementError("归档设置字段无效");
+        const managers = new Set();
+        const grants = input.grants.map((raw) => {
+            if (!raw || typeof raw !== "object" || Array.isArray(raw))
+                throw new ManagementError("来源授权无效");
+            const grant = raw;
+            if (Object.keys(grant).some(key => !["managerSource", "managerSessionId", "sources"].includes(key)))
+                throw new ManagementError("来源授权字段无效");
+            validateSource(grant.managerSource);
+            if (typeof grant.managerSessionId !== "string" || !grant.managerSessionId || grant.managerSessionId.length > 256 || !Array.isArray(grant.sources) || grant.sources.length > 1000)
+                throw new ManagementError("来源授权无效");
+            grant.sources.forEach(validateSource);
+            const key = JSON.stringify([grant.managerSource, grant.managerSessionId]);
+            if (managers.has(key))
+                throw new ManagementError("管理会话授权重复");
+            managers.add(key);
+            return { managerSource: grant.managerSource, managerSessionId: grant.managerSessionId, sources: [...new Set(grant.sources)] };
+        });
+        let nativeGrants;
+        if (input.nativeGrants !== undefined) {
+            if (!Array.isArray(input.nativeGrants) || input.nativeGrants.length > 500)
+                throw new ManagementError("原生授权无效");
+            const nativeManagers = new Set();
+            nativeGrants = input.nativeGrants.map(raw => {
+                const grant = objectFields(raw, ["managerSource", "managerSessionId", "providers"]);
+                validateSource(grant.managerSource);
+                if (!exactIdentifier(grant.managerSessionId, 256) || !Array.isArray(grant.providers) || grant.providers.length > 1000)
+                    throw new ManagementError("原生授权无效");
+                const key = JSON.stringify([grant.managerSource, grant.managerSessionId]);
+                if (nativeManagers.has(key))
+                    throw new ManagementError("原生管理会话授权重复");
+                nativeManagers.add(key);
+                const providers = new Set();
+                return { managerSource: grant.managerSource, managerSessionId: grant.managerSessionId, providers: grant.providers.map(rawProvider => {
+                        const item = objectFields(rawProvider, ["pluginId", "scope"]);
+                        if (typeof item.pluginId !== "string" || !/^[a-z][a-z0-9-]*$/.test(item.pluginId) || item.pluginId.length > 128 || !exactIdentifier(item.scope, 4096))
+                            throw new ManagementError("原生插件授权或 scope 无效");
+                        const providerKey = JSON.stringify([item.pluginId, item.scope]);
+                        if (providers.has(providerKey))
+                            throw new ManagementError("原生插件授权重复");
+                        providers.add(providerKey);
+                        return { pluginId: item.pluginId, scope: item.scope };
+                    }) };
+            });
+        }
+        let summarizer;
+        if (input.summarizer !== undefined && input.summarizer !== null) {
+            const config = input.summarizer;
+            if (!config || typeof config !== "object" || Array.isArray(config) || Object.keys(config).some(key => !["endpoint", "model", "apiKey", "hasApiKey"].includes(key)))
+                throw new ManagementError("总结器配置无效");
+            let endpoint;
+            try {
+                endpoint = new URL(config.endpoint);
+            }
+            catch {
+                throw new ManagementError("总结器地址无效");
+            }
+            if (!["http:", "https:"].includes(endpoint.protocol) || endpoint.username || endpoint.password || endpoint.hash || typeof config.model !== "string" || !config.model.trim() || config.model.length > 256 || /[\r\n]/.test(config.model) || (config.apiKey !== undefined && (typeof config.apiKey !== "string" || config.apiKey.length > 8192 || /[\r\n]/.test(config.apiKey))))
+                throw new ManagementError("总结器配置无效");
+            const apiKey = config.apiKey === undefined && config.endpoint === previousEndpoint ? previousKey : config.apiKey;
+            summarizer = { endpoint: config.endpoint, model: config.model, ...(apiKey ? { apiKey } : {}) };
+        }
+        return { enabled: input.enabled, grants, ...(nativeGrants ? { nativeGrants } : {}), ...(summarizer ? { summarizer } : {}) };
+    }
+}
+exports.SessionManagement = SessionManagement;
+function validateSource(value) {
+    if (typeof value !== "string" || value.length > 4096 || value.includes("*"))
+        throw new ManagementError("来源必须是完整且精确的通道来源键");
+    let source;
+    try {
+        source = JSON.parse(value);
+    }
+    catch {
+        throw new ManagementError("来源格式无效");
+    }
+    if (!Array.isArray(source) || source.length !== 5 || source.some(item => typeof item !== "string" || /[\u0000-\u001f]/.test(item)) || !["aun", "feishu"].includes(source[0]) || !source[3] || JSON.stringify(source) !== value)
+        throw new ManagementError("来源格式无效");
+}
+function exactIdentifier(value, maximum) {
+    return typeof value === "string" && value.length > 0 && value.length <= maximum && !/[\u0000-\u001f*]/.test(value);
+}
+function objectFields(value, fields) {
+    if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).some(key => !fields.includes(key)))
+        throw new ManagementError("原生历史响应或授权字段结构无效");
+    return value;
+}
+function displayMetadata(value) { return value.replace(/[\r\n\u0000-\u001f]/g, " "); }
+function validateNativeSession(value) {
+    const session = objectFields(value, ["id", "title", "updatedAt"]);
+    if (!exactIdentifier(session.id, 1024) || typeof session.title !== "string" || session.title.length > 4096 || session.updatedAt !== undefined && !validHistoryTime(session.updatedAt))
+        throw new ManagementError("原生会话元数据结构无效");
+}
+function validHistoryTime(value) { return typeof value === "string" && value.length <= 64 && Number.isFinite(Date.parse(value)); }
+function validateNativePage(raw, read) {
+    const result = objectFields(raw, ["supported", "reason", "sessions", "session", "turns", "nextCursor", "complete", "missingReasons", "readAt"]);
+    if (result.supported === false) {
+        objectFields(raw, ["supported", "reason"]);
+        if (typeof result.reason !== "string" || !result.reason || result.reason.length > 4096)
+            throw new ManagementError("原生历史不支持响应结构无效");
+        throw new ManagementError(`原生历史不可用：${displayMetadata(result.reason)}`);
+    }
+    objectFields(raw, ["supported", ...(read ? ["session", "turns"] : ["sessions"]), "nextCursor", "complete", "missingReasons", "readAt"]);
+    if (result.supported !== true || typeof result.complete !== "boolean" || !validHistoryTime(result.readAt) || !Array.isArray(result.missingReasons) || result.missingReasons.length > 50 || result.missingReasons.some(value => typeof value !== "string" || value.length > 1024) || result.nextCursor !== undefined && !exactIdentifier(result.nextCursor, 4096))
+        throw new ManagementError("原生历史分页响应结构无效");
+    if (read) {
+        validateNativeSession(result.session);
+        if (!Array.isArray(result.turns) || result.turns.length > 100)
+            throw new ManagementError("原生历史每页正文不得超过100条，响应结构无效");
+        for (const value of result.turns) {
+            const turn = objectFields(value, ["id", "role", "text", "time"]);
+            if (!["user", "assistant"].includes(turn.role) || typeof turn.text !== "string" || turn.text.length > 60_000 || turn.id !== undefined && !exactIdentifier(turn.id, 1024) || turn.time !== undefined && !validHistoryTime(turn.time))
+                throw new ManagementError(typeof turn.text === "string" && turn.text.length > 60_000 ? "原生正文超过60000字符" : "原生历史正文结构无效");
+        }
+    }
+    else {
+        if (!Array.isArray(result.sessions) || result.sessions.length > 50)
+            throw new ManagementError("原生历史每页不得超过50项，响应结构无效");
+        result.sessions.forEach(validateNativeSession);
+    }
+    return result;
+}
+async function nativeTimeout(operation) {
+    let timer;
+    try {
+        return await Promise.race([Promise.resolve().then(operation), new Promise((_, reject) => { timer = setTimeout(() => reject(new ManagementError("原生历史读取超时，请稍后重试")), 10_000); })]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}