agent-bridge-aun 1.0.40 → 1.0.44

package/dist/src-ts/plugins/aun/index.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AunPlugin = void 0;
 const promises_1 = require("node:fs/promises");
@@ -8,12 +11,17 @@ const node_module_1 = require("node:module");
 const node_path_1 = require("node:path");
 const node_os_1 = require("node:os");
 const node_url_1 = require("node:url");
+const _2020_1 = __importDefault(require("ajv/dist/2020"));
 const agent_1 = require("../../agent");
 const evolcore_1 = require("./evolcore");
 const messages_1 = require("./messages");
 const attachments_1 = require("./attachments");
+const ability_publication_1 = require("./ability-publication");
+const ability_operations_1 = require("./ability-operations");
+const ability_operation_store_1 = require("./ability-operation-store");
+const ability_owner_1 = require("./ability-owner");
 const manifest = {
-    id: "aun", version: "1.0.40", type: "channel", displayName: "AUN 通道",
+    id: "aun", version: "1.0.44", type: "channel", displayName: "AUN 通道",
     entry: "dist/src-ts/plugins/aun/index.js", apiVersion: "1", process: "in-process",
     capabilities: ["channel", "channel.identity.create", "channel.receive", "channel.send", "health", "cli"],
     configSchema: "config.schema.json",
@@ -83,6 +91,15 @@ class AunPlugin {
     createdAids = new Set();
     bindings = {};
     bindingTimes = {};
+    abilitySelections = {};
+    abilityLedgers = {};
+    abilityOwners = {};
+    abilityOperations;
+    abilityAuditUnavailable = false;
+    ownerProof = new ability_owner_1.OwnerProof();
+    abilityPublications = new Map();
+    revokingAbilityAids = new Set();
+    abilityRevisions = new Map();
     creating = false;
     unregister = [];
     ingress;
@@ -203,6 +220,8 @@ class AunPlugin {
                 throw new Error("只能关联 Agent 插件");
             if (this.context?.pluginStatus(pluginId) !== "ready")
                 throw new Error("目标 Agent 插件未启动");
+            if (this.bindings[aid] && this.bindings[aid] !== pluginId)
+                await this.revokePublishedAbilities(aid);
             const previous = this.bindings;
             const previousTimes = this.bindingTimes;
             const connection = this.clients.get(aid);
@@ -270,6 +289,7 @@ class AunPlugin {
                 throw new Error("指定 AID 当前未关联到该 Agent");
             if ([...this.pendingMessages.keys()].some(key => JSON.parse(key)[0] === aid))
                 throw new Error("该 AID 正在处理消息，请等待任务完成后再解绑");
+            await this.revokePublishedAbilities(aid);
             const previous = this.bindings;
             const previousTimes = this.bindingTimes;
             this.bindings = { ...previous };
@@ -309,6 +329,9 @@ class AunPlugin {
         this.config.created_aids = [...new Set([...this.createdAids, ...this.legacyCreatedAids])].sort();
         this.config.bindings = this.bindings;
         this.config.binding_times = this.bindingTimes;
+        this.config.ability_selections = this.abilitySelections;
+        this.config.ability_ledgers = this.abilityLedgers;
+        this.config.ability_owners = this.abilityOwners;
         await (0, promises_1.writeFile)((0, node_path_1.join)(this.context.dataDir, "config.json"), `${JSON.stringify(this.config, null, 2)}\n`, { mode: 0o600 });
     }
     async activate(context) {
@@ -349,6 +372,16 @@ class AunPlugin {
             throw new Error("运行时未提供通道消息入口");
         this.sdk ??= await loadSdk();
         await (0, promises_1.mkdir)(this.path(), { recursive: true });
+        this.ownerProof.clear();
+        this.abilityAuditUnavailable = false;
+        try {
+            this.abilityOperations = await ability_operation_store_1.AbilityOperationStore.open((0, node_path_1.join)(context.dataDir, "ability-operations.json"));
+        }
+        catch (error) {
+            this.abilityOperations = undefined;
+            this.abilityAuditUnavailable = true;
+            context.logger.error("AUN Ability 操作账本不可读，已停用 Ability 发布与执行；普通聊天仍可用", { code: "operation_store_corrupt", error: safeError(error) });
+        }
         this.store = this.newStore();
         for (const [method, path, handler] of [
             ["POST", "/api/plugins/aun/aid", this.createAid],
@@ -356,6 +389,11 @@ class AunPlugin {
             ["POST", "/api/plugins/aun/bind", this.bindAgent],
             ["POST", "/api/plugins/aun/unbind", this.unbindAgent],
             ["POST", "/api/plugins/aun/settings", this.saveSettings],
+            ["GET", "/api/plugins/aun/abilities", this.listAbilities],
+            ["POST", "/api/plugins/aun/abilities/publish", this.publishAbilities],
+            ["POST", "/api/plugins/aun/abilities/owner-challenge", this.challengeAbilityOwner],
+            ["GET", "/api/plugins/aun/abilities/pending", this.pendingAbilityOperations],
+            ["POST", "/api/plugins/aun/abilities/confirm", this.confirmAbilityOperation],
             ["GET", "/api/plugins/aun/commands", this.listCommands],
             ["POST", "/api/plugins/aun/commands", this.runCommand],
             ...(["", "/app.js", "/style.css"].map((suffix) => ["GET", `/abweb/channels/aun${suffix}`, this.servePage])),
@@ -367,6 +405,15 @@ class AunPlugin {
         this.aid = typeof this.config.aid === "string" ? this.config.aid.trim() : "";
         this.bindings = this.config.bindings && typeof this.config.bindings === "object" && !Array.isArray(this.config.bindings) ? { ...this.config.bindings } : {};
         this.bindingTimes = this.config.binding_times && typeof this.config.binding_times === "object" && !Array.isArray(this.config.binding_times) ? { ...this.config.binding_times } : {};
+        this.abilitySelections = this.config.ability_selections && typeof this.config.ability_selections === "object" && !Array.isArray(this.config.ability_selections)
+            ? Object.fromEntries(Object.entries(this.config.ability_selections).map(([aid, paths]) => [aid, Array.isArray(paths) ? paths.filter((path) => typeof path === "string") : []])) : {};
+        this.abilityLedgers = this.config.ability_ledgers && typeof this.config.ability_ledgers === "object" && !Array.isArray(this.config.ability_ledgers)
+            ? this.config.ability_ledgers : {};
+        const owners = this.config.ability_owners;
+        if (owners !== undefined && (!owners || typeof owners !== "object" || Array.isArray(owners)
+            || Object.entries(owners).some(([provider, owner]) => !aidPattern.test(provider) || typeof owner !== "string" || !aidPattern.test(owner))))
+            throw new Error("ability_owners 必须按 Provider AID 配置有效的 Owner AID");
+        this.abilityOwners = { ...owners };
         for (const aid of Array.isArray(this.config.identities) ? this.config.identities : []) {
             if (typeof aid === "string" && aidPattern.test(aid))
                 this.identities.add(aid);
@@ -425,14 +472,18 @@ class AunPlugin {
     async deactivate(_reason) {
         this.status = "degraded";
         this.acceptingMessages = false;
+        this.ownerProof.clear();
         for (const { subscription } of this.clients.values())
             subscription?.unsubscribe();
+        await this.abilityOperations?.interruptExecuting();
         await Promise.allSettled(this.pendingMessages.values());
         for (const { client } of this.clients.values())
             await client.close();
         this.clients.clear();
         await this.store?.close();
         this.store = undefined;
+        this.abilityOperations = undefined;
+        this.abilityAuditUnavailable = false;
         for (const dispose of this.unregister.splice(0))
             dispose();
         this.context?.http.unregister("aun");
@@ -539,6 +590,255 @@ class AunPlugin {
         const localAids = this.listStoreAids().filter((aid) => !connected.has(aid));
         this.json(response, 200, { groups, localAids, bindings: this.bindings, bindingTimes: this.bindingTimes });
     };
+    async abilityDefinitions(aid) {
+        const pluginId = this.bindings[aid];
+        if (!pluginId || this.context?.pluginStatus(pluginId) !== "ready" || !this.context?.listPluginAbilities)
+            return [];
+        return this.context.listPluginAbilities(pluginId, aid);
+    }
+    listAbilities = async (request, response) => {
+        try {
+            const result = {};
+            const session = this.context?.managementSession?.(request);
+            for (const aid of Object.keys(this.bindings)) {
+                const definitions = await this.abilityDefinitions(aid);
+                const ownerAid = this.abilityOwners[aid];
+                const ownerVerified = Boolean(session && ownerAid && this.ownerProof.verified(session, aid, ownerAid));
+                const publishAvailable = Boolean(this.context?.managementActor?.(request) && ownerVerified && this.context?.callPluginAbility && this.abilityOperations && !this.abilityAuditUnavailable);
+                result[aid] = { agent: this.bindings[aid], selected: this.abilitySelections[aid] ?? [], definitions, published: Object.keys(this.abilityLedgers[aid] ?? {}).length > 0, pluginVersion: this.context?.pluginVersion?.(this.bindings[aid]), ownerAid, ownerVerified, publishAvailable, reason: publishAvailable ? "需本机已认证管理会话，每次执行仍须明确批准。" : "逐次 Owner 确认需本机已认证管理会话，并验证明确配置的 Owner AID；已有索引仍可撤销。" };
+            }
+            this.json(response, 200, { abilities: result });
+        }
+        catch (error) {
+            this.json(response, 500, { error: safeError(error) });
+        }
+    };
+    publishAbilities = async (request, response) => {
+        if (!this.context?.managementActor?.(request))
+            return this.json(response, 403, { error: "能力发布需要本机或已配对的管理会话" });
+        try {
+            const body = await this.readJsonBody(request);
+            const aid = typeof body.aid === "string" ? body.aid.trim() : "";
+            if (!aidPattern.test(aid) || !this.bindings[aid])
+                return this.json(response, 400, { error: "需要已关联 Agent 的有效 AID" });
+            const publish = body.publish !== false;
+            const paths = publish ? (Array.isArray(body.paths) && body.paths.every((path) => typeof path === "string") ? body.paths : undefined) : [];
+            if (!paths)
+                return this.json(response, 400, { error: "发布路径必须是字符串数组" });
+            if (paths.length) {
+                const session = this.context?.managementSession?.(request);
+                const owner = this.abilityOwners[aid];
+                if (!session || !owner || !this.ownerProof.verified(session, aid, owner) || !this.context?.callPluginAbility || !this.abilityOperations || this.abilityAuditUnavailable)
+                    return this.json(response, 409, { error: "逐次 Owner 确认需可用操作账本、本机已认证管理会话，并先验证该 Provider 的 Owner AID" });
+                const operation = (this.abilityPublications.get(aid) ?? Promise.resolve()).catch(() => undefined).then(async () => {
+                    if (!this.ownerProof.verified(session, aid, owner) || this.abilityOwners[aid] !== owner || this.revokingAbilityAids.has(aid))
+                        throw new Error("Owner 验证已失效或身份正在撤销，请重新确认");
+                    const storage = this.clients.get(aid)?.client.storage;
+                    if (!storage)
+                        throw new Error("AUN 身份存储不可用");
+                    const pluginId = this.bindings[aid];
+                    const definitions = await this.abilityDefinitions(aid);
+                    const published = await (0, ability_publication_1.publishAbilityCatalog)({ storage, aid, pluginId, pluginVersion: this.context?.pluginVersion?.(pluginId) ?? "", definitions: definitions.map(definition => ({ ...definition })), selectedPaths: paths, ledger: this.abilityLedgers[aid] ?? {}, beforeIndexWrite: async (pending) => { this.abilityLedgers[aid] = pending; await this.persist(); } });
+                    this.abilityLedgers[aid] = published.ledger;
+                    this.abilitySelections[aid] = [...new Set(paths)];
+                    await this.persist();
+                });
+                this.abilityPublications.set(aid, operation);
+                try {
+                    await operation;
+                }
+                finally {
+                    if (this.abilityPublications.get(aid) === operation)
+                        this.abilityPublications.delete(aid);
+                }
+                return this.json(response, 200, { ok: true, aid, revoked: false });
+            }
+            await this.revokePublishedAbilities(aid);
+            return this.json(response, 200, { ok: true, aid, revoked: true });
+        }
+        catch (error) {
+            this.context?.logger.warn("AUN Ability 能力索引更新失败", { error: safeError(error) });
+            return this.json(response, 409, { error: safeError(error) });
+        }
+    };
+    challengeAbilityOwner = async (request, response) => {
+        const session = this.context?.managementSession?.(request);
+        if (!this.context?.managementActor?.(request) || !session)
+            return this.json(response, 403, { error: "验证 Owner 需本机已认证管理会话" });
+        try {
+            const body = await this.readJsonBody(request);
+            const aid = typeof body.aid === "string" ? body.aid.trim() : "";
+            const ownerAid = typeof body.ownerAid === "string" ? body.ownerAid.trim() : "";
+            if (!aidPattern.test(aid) || !this.bindings[aid] || !aidPattern.test(ownerAid))
+                return this.json(response, 400, { error: "需要已关联的 Provider AID 和明确指定的 Owner AID" });
+            if (this.abilityOwners[aid] !== ownerAid) {
+                this.revokingAbilityAids.add(aid);
+                this.abilityRevisions.set(aid, (this.abilityRevisions.get(aid) ?? 0) + 1);
+                this.ownerProof.clear(aid);
+                try {
+                    await this.invalidateAbilityOperations(aid);
+                    const previous = this.abilityOwners;
+                    this.abilityOwners = { ...previous, [aid]: ownerAid };
+                    try {
+                        await this.persist();
+                    }
+                    catch (error) {
+                        this.abilityOwners = previous;
+                        throw error;
+                    }
+                }
+                finally {
+                    this.revokingAbilityAids.delete(aid);
+                }
+            }
+            const challenge = this.ownerProof.start(session, aid, ownerAid);
+            await this.callAunWithRecovery(aid, { to: ownerAid, encrypt: true, payload: { type: "text", text: `请在本次管理会话发起后回复以下指令，证明你控制 Owner AID。此操作只验证身份，不批准任何能力调用：\n/ability-owner ${challenge.nonce}` } });
+            this.context?.logger.info("AUN Owner 会话验证已发起，需本机已认证管理会话", { aid, ownerAid });
+            this.json(response, 200, { ok: true, aid, ownerAid, expiresAt: challenge.expiresAt });
+        }
+        catch (error) {
+            this.json(response, 409, { error: safeError(error) });
+        }
+    };
+    pendingAbilityOperations = async (request, response) => {
+        if (!this.context?.managementActor?.(request) || !this.context?.managementSession?.(request))
+            return this.json(response, 403, { error: "读取待确认能力需本机已认证管理会话" });
+        try {
+            this.json(response, 200, { operations: await this.abilityOperations?.pending() ?? [] });
+        }
+        catch (error) {
+            this.json(response, 503, { error: safeError(error) });
+        }
+    };
+    confirmAbilityOperation = async (request, response) => {
+        const session = this.context?.managementSession?.(request);
+        if (!this.context?.managementActor?.(request) || !session)
+            return this.json(response, 403, { error: "逐次 Owner 确认需本机已认证管理会话" });
+        const store = this.abilityOperations;
+        if (!store || this.abilityAuditUnavailable)
+            return this.json(response, 503, { error: "持久操作账本不可用" });
+        try {
+            const body = await this.readJsonBody(request);
+            if (typeof body.key !== "string" || typeof body.confirmationFingerprint !== "string" || typeof body.approved !== "boolean")
+                return this.json(response, 400, { error: "必须明确提交操作键、完整确认指纹和批准或拒绝决定" });
+            const original = await store.get(body.key);
+            if (!original)
+                return this.json(response, 404, { error: "能力操作不存在" });
+            const ownerAid = this.abilityOwners[original.providerAid];
+            if (!ownerAid || !this.ownerProof.verified(session, original.providerAid, ownerAid))
+                return this.json(response, 403, { error: "需本机已认证管理会话，并完成该 Provider 的 Owner AID 验证" });
+            if (original.confirmationFingerprint !== body.confirmationFingerprint)
+                return this.json(response, 409, { error: "确认指纹与待确认请求不一致" });
+            const revision = this.abilityRevisions.get(original.providerAid) ?? 0;
+            if (body.approved && original.state === "pending_confirmation") {
+                const failure = await this.abilityInvocationFailure(original.providerAid, original.authenticatedCaller, original.path, original.definitionId, original.params);
+                const pluginId = this.bindings[original.providerAid];
+                if (failure || (this.abilityRevisions.get(original.providerAid) ?? 0) !== revision || this.revokingAbilityAids.has(original.providerAid) || original.executionTarget.pluginId !== pluginId || original.executionTarget.ownerAid !== ownerAid || original.executionTarget.pluginVersion !== (this.context?.pluginVersion?.(pluginId) ?? ""))
+                    return this.json(response, 409, { error: failure?.message ?? "能力执行目标或 Owner 配置已改变，请重新发起调用" });
+            }
+            if (!this.acceptingMessages || !this.ownerProof.verified(session, original.providerAid, ownerAid))
+                return this.json(response, 403, { error: "通道或 Owner 管理会话已失效" });
+            const confirmation = body.approved ? await store.approve(original.key, body.confirmationFingerprint) : await store.reject(original.key, body.confirmationFingerprint);
+            let entry = confirmation.entry;
+            if (confirmation.started) {
+                let result;
+                let state;
+                let handlerAuthorized = false;
+                try {
+                    const failure = await this.abilityInvocationFailure(entry.providerAid, entry.authenticatedCaller, entry.path, entry.definitionId, entry.params);
+                    const expired = Date.now() >= entry.expiresAt;
+                    const invalidated = (this.abilityRevisions.get(entry.providerAid) ?? 0) !== revision || this.revokingAbilityAids.has(entry.providerAid);
+                    if (failure || expired || invalidated || !this.ownerProof.verified(session, entry.providerAid, ownerAid) || this.abilityOwners[entry.providerAid] !== entry.executionTarget.ownerAid || this.bindings[entry.providerAid] !== entry.executionTarget.pluginId || (this.context?.pluginVersion?.(String(entry.executionTarget.pluginId)) ?? "") !== entry.executionTarget.pluginVersion) {
+                        result = { ...(0, ability_operations_1.abilityFailureResult)({ call_id: entry.callId, operation_id: entry.operationId, ability_path: entry.path, definition_id: entry.definitionId }, expired ? "message_expired" : failure?.code ?? (invalidated ? "provider_invalidated" : "permission_denied"), expired ? "调用已超过最晚启动时间" : failure?.message ?? "Owner 管理会话或执行目标已改变，本次能力没有执行"), execution_state: "not_executed" };
+                        state = "failed";
+                    }
+                    else {
+                        const context = this.context;
+                        const confirmed = entry;
+                        const beforeStart = () => {
+                            const currentSession = context.managementSession?.(request);
+                            if (this.context !== context || this.abilityOperations !== store || this.abilityAuditUnavailable || !this.acceptingMessages || !context.managementActor?.(request) || !currentSession || currentSession.id !== session.id || !this.ownerProof.verified(session, confirmed.providerAid, ownerAid) || !this.ownerProof.verified(currentSession, confirmed.providerAid, ownerAid))
+                                throw Object.assign(new Error("管理会话、Owner 证明或操作账本已失效，本次能力没有执行"), { code: "confirmation_unavailable" });
+                            const pluginId = String(confirmed.executionTarget.pluginId);
+                            const rules = String(this.config.allow_from ?? "").split(",").map(value => value.trim()).filter(Boolean);
+                            if ((this.abilityRevisions.get(confirmed.providerAid) ?? 0) !== revision || this.revokingAbilityAids.has(confirmed.providerAid) || !this.clients.has(confirmed.providerAid) || this.bindings[confirmed.providerAid] !== pluginId || this.abilityOwners[confirmed.providerAid] !== confirmed.executionTarget.ownerAid || (context.pluginVersion?.(pluginId) ?? "") !== confirmed.executionTarget.pluginVersion || context.pluginStatus(pluginId) !== "ready" || !this.abilitySelections[confirmed.providerAid]?.includes(confirmed.path) || this.abilityLedgers[confirmed.providerAid]?.[confirmed.path]?.definition_id !== confirmed.definitionId || (rules.length && !rules.includes("*") && !rules.includes(confirmed.authenticatedCaller)))
+                                throw Object.assign(new Error("Provider 发布、Owner policy 或执行目标已改变，本次能力没有执行"), { code: "provider_invalidated" });
+                            handlerAuthorized = true;
+                        };
+                        const value = await context.callPluginAbility(String(entry.executionTarget.pluginId), entry.path, entry.params, { providerAid: entry.providerAid, expiresAt: entry.expiresAt, beforeStart });
+                        result = { type: "ability", role: "result", ok: true, execution_state: "completed", result: value };
+                        state = "succeeded";
+                    }
+                }
+                catch (error) {
+                    this.context?.logger.warn("AUN Ability 执行失败，结果将持久保存", { aid: entry.providerAid, path: entry.path, error: safeError(error) });
+                    const code = error.code;
+                    const notExecuted = !handlerAuthorized && ["message_expired", "provider_invalidated", "confirmation_unavailable"].includes(code ?? "");
+                    result = { ...(0, ability_operations_1.abilityFailureResult)({ call_id: entry.callId, operation_id: entry.operationId, ability_path: entry.path, definition_id: entry.definitionId }, notExecuted ? code : "execution_failed", notExecuted ? (code === "message_expired" ? "调用已超过最晚启动时间" : "管理会话或 Provider 状态已改变，本次能力没有执行") : "能力执行失败，请检查 Provider 运行日志；不会自动重试"), execution_state: notExecuted ? "not_executed" : "failed" };
+                    state = "failed";
+                }
+                entry = await store.finish(entry.key, state, result);
+            }
+            const delivered = await this.sendAbilityResponse(entry.providerAid, entry.authenticatedCaller, this.abilityOperationResponse(entry));
+            this.context?.logger.info("AUN Ability 逐次确认完成，需本机已认证管理会话", { aid: entry.providerAid, callerAid: entry.authenticatedCaller, operationId: entry.operationId, state: entry.state, delivered });
+            this.json(response, 200, { ok: true, state: entry.state, result: entry.result, delivered });
+        }
+        catch (error) {
+            this.json(response, 409, { error: safeError(error) });
+        }
+    };
+    async revokePublishedAbilities(aid) {
+        this.revokingAbilityAids.add(aid);
+        this.abilityRevisions.set(aid, (this.abilityRevisions.get(aid) ?? 0) + 1);
+        const operation = (this.abilityPublications.get(aid) ?? Promise.resolve()).catch(() => undefined).then(async () => {
+            await this.invalidateAbilityOperations(aid);
+            this.abilitySelections[aid] = [];
+            await this.persist();
+            const ledger = this.abilityLedgers[aid] ?? {};
+            if (!Object.keys(ledger).length)
+                return;
+            const storage = this.clients.get(aid)?.client.storage;
+            if (!storage)
+                throw new Error("AUN 能力撤销失败：身份存储不可用；调用已停用，请恢复连接后重试解绑");
+            const pluginId = this.bindings[aid];
+            const version = this.context?.pluginVersion?.(pluginId) ?? Object.values(ledger)[0].plugin_version;
+            const published = await (0, ability_publication_1.publishAbilityCatalog)({ storage, aid, pluginId, pluginVersion: version, definitions: [], selectedPaths: [], ledger, beforeIndexWrite: async (pending) => { this.abilityLedgers[aid] = pending; await this.persist(); } });
+            this.abilityLedgers[aid] = published.ledger;
+            await this.persist();
+            this.context?.logger.info("AUN 已撤销解绑身份的能力索引", { aid, catalogRevision: published.index.catalog_revision });
+        });
+        this.abilityPublications.set(aid, operation);
+        try {
+            await operation;
+        }
+        finally {
+            if (this.abilityPublications.get(aid) === operation)
+                this.abilityPublications.delete(aid);
+            this.revokingAbilityAids.delete(aid);
+        }
+    }
+    async invalidateAbilityOperations(aid) {
+        try {
+            await this.abilityOperations?.invalidateProvider(aid);
+        }
+        catch (error) {
+            this.abilityAuditUnavailable = true;
+            this.context?.logger.error("AUN Ability 待确认记录失效结果无法持久保存，已停用 Ability 发布与执行", { aid, code: "audit_unavailable", error: safeError(error) });
+            throw error;
+        }
+    }
+    async readJsonBody(request) {
+        let raw = "";
+        for await (const chunk of request) {
+            raw += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+            if (raw.length > 65536)
+                throw new Error("请求内容过大");
+        }
+        const body = JSON.parse(raw || "{}");
+        if (!body || typeof body !== "object" || Array.isArray(body))
+            throw new Error("请求正文必须是 JSON 对象");
+        return body;
+    }
     saveSettings = async (request, response) => {
         try {
             let raw = "";
@@ -893,12 +1193,57 @@ class AunPlugin {
         }
     };
     async onMessage(payload, aid) {
+        const raw = payload && typeof payload === "object" ? payload : undefined;
+        const inboundId = typeof raw?.message_id === "string" ? raw.message_id : (0, node_crypto_1.randomUUID)();
+        this.context?.logger.info("AUN 入站回调", { traceId: inboundId, aid, messageId: typeof raw?.message_id === "string" ? raw.message_id : "", stage: "SDK收到" });
         const agentPlugin = this.bindings[aid];
-        if (!this.acceptingMessages || !agentPlugin)
+        if (!this.acceptingMessages) {
+            this.context?.logger.warn("AUN 入站消息已忽略", { traceId: inboundId, aid, stage: "通道未接收", reason: "通道未就绪" });
+            return;
+        }
+        if (!agentPlugin) {
+            this.context?.logger.warn("AUN 入站消息已忽略", { traceId: inboundId, aid, stage: "绑定检查", reason: "未绑定 Agent" });
+            return;
+        }
+        const body = raw?.payload && typeof raw.payload === "object" && !Array.isArray(raw.payload) ? raw.payload : undefined;
+        const ownerCommand = typeof body?.text === "string" && /^\/ability-owner(?:\s|$)/.test(body.text) ? body.text.match(/^\/ability-owner ([0-9a-f]{64})$/) : undefined;
+        if (typeof body?.text === "string" && /^\/ability-owner(?:\s|$)/.test(body.text)) {
+            const envelope = raw?.envelope && typeof raw.envelope === "object" ? raw.envelope : undefined;
+            const sender = typeof raw?.from === "string" ? raw.from : typeof envelope?.from === "string" ? envelope.from : undefined;
+            const verified = Boolean(ownerCommand && (envelope?.from === undefined || envelope.from === sender) && this.ownerProof.accept(aid, sender, ownerCommand[1], raw?.encrypted === true));
+            this.context?.logger.info("AUN 宿主委托的 Owner 控制权验证已处理", { aid, verified });
+            if (sender && raw?.encrypted === true && (envelope?.from === undefined || envelope.from === sender)) {
+                const text = verified
+                    ? `Owner 控制权验证成功：${aid} 的当前管理会话已通过验证。此操作不会批准任何能力调用，请回到 ABWeb 继续操作。`
+                    : !ownerCommand
+                        ? "Owner 控制权验证失败：指令格式不正确，请复制最新验证消息中的完整 /ability-owner 指令。"
+                        : "Owner 控制权验证失败：验证指令已过期、已使用，或与本次 Owner 身份不匹配。请在 ABWeb 重新发起验证，并使用指定 Owner AID 回复。";
+                try {
+                    await this.sendText(aid, sender, text, typeof body.thread_id === "string" ? body.thread_id : undefined, true);
+                }
+                catch (error) {
+                    this.context?.logger.warn("AUN Owner 验证结果回复失败", { aid, peer: sender, verified, stage: "发送 Owner 验证回执", error: safeError((0, agent_1.errorDetails)(error)) });
+                }
+            }
+            return;
+        }
+        if ((0, ability_operations_1.isAbilityMessage)(payload)) {
+            if (this.revokingAbilityAids.has(aid)) {
+                this.context?.logger.warn("AUN 身份正在撤销能力索引，能力调用已阻止", { aid, traceId: inboundId, stage: "撤销保护" });
+                return;
+            }
+            await this.onAbilityMessage(payload, aid);
             return;
+        }
         const message = (0, messages_1.normalizeAunMessage)(payload, aid, typeof this.config.allow_from === "string" ? this.config.allow_from : undefined);
-        if (!message || !this.seen.add(message.messageId ? `${aid}:${message.messageId}` : ""))
+        if (!message) {
+            this.context?.logger.warn("AUN 入站消息已忽略", { traceId: inboundId, aid, stage: "消息校验", reason: "消息格式、白名单或系统事件不符合任务条件" });
+            return;
+        }
+        if (!this.seen.add(message.messageId ? `${aid}:${message.messageId}` : "")) {
+            this.context?.logger.warn("AUN 入站消息已忽略", { traceId: inboundId, aid, messageId: message.messageId ?? "", stage: "去重", reason: "重复消息" });
             return;
+        }
         const sourceKey = JSON.stringify([aid, message.peerId, message.threadId ?? ""]);
         const pending = this.pendingMessages.get(sourceKey);
         if (pending && !message.attachments?.length && !message.attachmentError && newSessionCommand.test(message.text.trim())) {
@@ -910,7 +1255,7 @@ class AunPlugin {
             }
             return;
         }
-        const current = (pending ?? Promise.resolve()).catch(() => undefined).then(() => this.processMessage(message, aid, agentPlugin));
+        const current = (pending ?? Promise.resolve()).catch(() => undefined).then(() => this.processMessage(message, aid, agentPlugin, inboundId));
         this.pendingMessages.set(sourceKey, current);
         try {
             await current;
@@ -920,9 +1265,138 @@ class AunPlugin {
                 this.pendingMessages.delete(sourceKey);
         }
     }
-    async processMessage(message, aid, agentPlugin) {
+    async onAbilityMessage(value, aid) {
+        const receivedAt = Date.now();
+        const call = (0, ability_operations_1.parseAbilityEnvelope)(value);
+        if (!call) {
+            this.context?.logger.warn("AUN Ability 入站消息校验失败，未进入聊天或执行", { aid, stage: "认证与协议校验" });
+            return;
+        }
+        const { payload, callerAid } = call;
+        const rules = String(this.config.allow_from ?? "").split(",").map(value => value.trim()).filter(Boolean);
+        let result;
+        if (rules.length && !rules.includes("*") && !rules.includes(callerAid))
+            result = (0, ability_operations_1.abilityFailureResult)(payload, "permission_denied", "调用来源不在 AUN 允许名单中");
+        else if (payload.ability_path === "protocol/discover") {
+            const params = payload.params;
+            const window = params?.window_seconds;
+            if (params?.spec_version !== "aid-ability/2" || !Number.isInteger(window) || Number(window) < 1 || Number(window) > 30 || payload.ttl !== window || payload.definition_id !== undefined)
+                result = (0, ability_operations_1.abilityFailureResult)(payload, "invalid_params", "Discover 窗口必须为 1–30 秒，ttl 必须与窗口一致且不携带 definition_id");
+            else {
+                const definitions = await this.abilityDefinitions(aid);
+                const capabilities = this.abilityOwners[aid] && this.abilityOperations && !this.abilityAuditUnavailable && this.context?.callPluginAbility
+                    ? definitions.filter(definition => (this.abilitySelections[aid] ?? []).includes(definition.path) && this.abilityLedgers[aid]?.[definition.path]?.definition_id === (0, ability_publication_1.abilityDefinitionId)({ ...definition })).map(({ contract_revision: _revision, ...definition }) => ({ ...definition, definition_id: this.abilityLedgers[aid][definition.path].definition_id })) : [];
+                result = { type: "ability", role: "result", call_id: payload.call_id, operation_id: payload.operation_id, ability_path: "protocol/discover", ok: true, execution_state: "completed", result: { spec_version: "aid-ability/2", capabilities } };
+            }
+        }
+        else {
+            try {
+                const store = this.abilityOperations;
+                if (this.abilityAuditUnavailable || !store)
+                    throw Object.assign(new Error("持久操作账本不可用"), { code: "audit_unavailable" });
+                const key = (0, ability_operation_store_1.abilityOperationKey)({ providerAid: aid, authenticatedCaller: callerAid, operationId: String(payload.operation_id) });
+                const existing = await store?.get(key);
+                if (existing) {
+                    const expected = { path: existing.path, definitionId: existing.definitionId, params: existing.params, async: existing.async ?? false };
+                    const incoming = { path: payload.ability_path, definitionId: payload.definition_id, params: payload.params ?? {}, async: payload.async ?? false };
+                    result = (0, ability_publication_1.abilityDefinitionId)(expected) === (0, ability_publication_1.abilityDefinitionId)(incoming) ? this.abilityOperationResponse((await store.replay(key, String(payload.call_id)))) : (0, ability_operations_1.abilityFailureResult)(payload, "idempotency_conflict", "相同 operation_id 的请求内容已改变");
+                }
+                else {
+                    const path = String(payload.ability_path);
+                    const params = payload.params ?? {};
+                    const revision = this.abilityRevisions.get(aid) ?? 0;
+                    const pluginId = this.bindings[aid];
+                    const pluginVersion = this.context?.pluginVersion?.(pluginId) ?? "";
+                    const ownerAid = this.abilityOwners[aid];
+                    const failure = await this.abilityInvocationFailure(aid, callerAid, path, String(payload.definition_id), params);
+                    if (failure)
+                        result = (0, ability_operations_1.abilityFailureResult)(payload, failure.code, failure.message);
+                    else if (!ownerAid || !this.context?.callPluginAbility)
+                        result = (0, ability_operations_1.abilityFailureResult)(payload, "confirmation_unavailable", "缺少宿主委托的 Owner 控制权证明配置或确认通道，本次能力没有执行");
+                    else {
+                        const sentAt = payload.sent_at;
+                        const ttl = payload.ttl;
+                        const expiresAt = (sentAt === undefined ? receivedAt : Math.min(receivedAt, Number(sentAt))) + Number(ttl) * 1000;
+                        if ((sentAt !== undefined && (!Number.isSafeInteger(sentAt) || Number(sentAt) < 0)) || !Number.isSafeInteger(ttl) || Number(ttl) < 1 || Number(ttl) > 3600 || !Number.isSafeInteger(expiresAt) || (payload.async !== undefined && typeof payload.async !== "boolean"))
+                            result = (0, ability_operations_1.abilityFailureResult)(payload, "invalid_params", "调用需有效的 1–3600 秒 ttl；sent_at 和布尔 async 可省略");
+                        else if (expiresAt <= Date.now())
+                            result = (0, ability_operations_1.abilityFailureResult)(payload, "message_expired", "调用已超过最晚启动时间");
+                        else {
+                            const definition = (await this.abilityDefinitions(aid)).find(item => item.path === path);
+                            if ((this.abilityRevisions.get(aid) ?? 0) !== revision || !this.acceptingMessages || this.abilityAuditUnavailable || this.revokingAbilityAids.has(aid) || this.abilityOperations !== store || this.bindings[aid] !== pluginId || this.abilityOwners[aid] !== ownerAid || (this.context?.pluginVersion?.(pluginId) ?? "") !== pluginVersion || this.context?.pluginStatus(pluginId) !== "ready" || !this.abilitySelections[aid]?.includes(path) || this.abilityLedgers[aid]?.[path]?.definition_id !== payload.definition_id)
+                                result = (0, ability_operations_1.abilityFailureResult)(payload, "provider_invalidated", "Provider 发布或 Owner policy 已改变，本次调用不会执行");
+                            else if (!definition || (0, ability_publication_1.abilityDefinitionId)({ ...definition }) !== payload.definition_id)
+                                result = (0, ability_operations_1.abilityFailureResult)(payload, "contract_changed", "能力契约已变更，请重新发现后确认");
+                            else {
+                                const draft = await store.draft({ providerAid: aid, authenticatedCaller: callerAid, operationId: String(payload.operation_id), callId: String(payload.call_id), path, definitionId: String(payload.definition_id), params, effects: definition.effects, dedupeRetentionSeconds: definition.dedupe_retention_seconds, executionTarget: { pluginId, pluginVersion, ownerAid }, expiresAt, ...(payload.async === undefined ? {} : { async: payload.async }) });
+                                result = this.abilityOperationResponse(draft.entry);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                const code = typeof error.code === "string" ? error.code : "audit_unavailable";
+                this.context?.logger.warn("AUN Ability 操作账本拒绝请求", { aid, callerAid, code, error: safeError(error) });
+                result = (0, ability_operations_1.abilityFailureResult)(payload, code, code === "idempotency_conflict" ? "相同 operation_id 的请求内容已改变" : "操作账本校验或持久化失败，本次能力没有执行");
+            }
+        }
+        await this.sendAbilityResponse(aid, callerAid, result);
+    }
+    async abilityInvocationFailure(aid, callerAid, path, definitionId, params) {
+        if (this.abilityAuditUnavailable)
+            return { code: "audit_unavailable", message: "持久操作账本不可用，本次能力没有执行" };
+        const rules = String(this.config.allow_from ?? "").split(",").map(value => value.trim()).filter(Boolean);
+        if (rules.length && !rules.includes("*") && !rules.includes(callerAid))
+            return { code: "permission_denied", message: "调用来源不在 AUN 允许名单中" };
+        const pluginId = this.bindings[aid];
+        const published = this.abilityLedgers[aid]?.[path];
+        const ownerAid = this.abilityOwners[aid];
+        const revision = this.abilityRevisions.get(aid) ?? 0;
+        const pluginVersion = this.context?.pluginVersion?.(pluginId);
+        const store = this.abilityOperations;
+        if (!this.acceptingMessages || this.revokingAbilityAids.has(aid) || !this.clients.has(aid) || this.context?.pluginStatus(pluginId) !== "ready")
+            return { code: "provider_unavailable", message: "绑定的 Agent 插件或通道尚未就绪，本次能力没有执行" };
+        if (!(this.abilitySelections[aid] ?? []).includes(path) || !published)
+            return { code: "ability_not_published", message: "当前 AID 没有发布指定能力" };
+        const definition = (await this.abilityDefinitions(aid)).find(item => item.path === path);
+        if (this.abilityAuditUnavailable)
+            return { code: "audit_unavailable", message: "持久操作账本不可用，本次能力没有执行" };
+        const currentRules = String(this.config.allow_from ?? "").split(",").map(value => value.trim()).filter(Boolean);
+        if (currentRules.length && !currentRules.includes("*") && !currentRules.includes(callerAid))
+            return { code: "permission_denied", message: "调用来源不在 AUN 允许名单中" };
+        if ((this.abilityRevisions.get(aid) ?? 0) !== revision || this.bindings[aid] !== pluginId || this.abilityOwners[aid] !== ownerAid || this.abilityLedgers[aid]?.[path] !== published || !this.abilitySelections[aid]?.includes(path) || (this.context?.pluginVersion?.(pluginId)) !== pluginVersion || this.abilityOperations !== store)
+            return { code: "provider_invalidated", message: "Provider 发布或 Owner policy 已改变，本次调用不会执行" };
+        if (!this.acceptingMessages || this.revokingAbilityAids.has(aid) || !this.clients.has(aid) || this.context?.pluginStatus(pluginId) !== "ready")
+            return { code: "provider_unavailable", message: "绑定的 Agent 插件或通道尚未就绪，本次能力没有执行" };
+        if (!definition)
+            return { code: "ability_not_found", message: "绑定的 Agent 不再声明指定能力" };
+        if (published.definition_id !== definitionId || definitionId !== (0, ability_publication_1.abilityDefinitionId)({ ...definition }))
+            return { code: "contract_changed", message: "能力契约已变更，请重新发现后确认" };
+        const ajv = new _2020_1.default({ allErrors: true, strict: false });
+        const validate = ajv.compile(definition.params_schema);
+        if (!validate(params))
+            return { code: "invalid_params", message: `能力参数不符合契约：${ajv.errorsText(validate.errors)}` };
+    }
+    abilityOperationResponse(entry) {
+        return entry.result ?? { type: "ability", role: "ack", call_id: entry.callId, operation_id: entry.operationId, ability_path: entry.path, definition_id: entry.definitionId, execution_state: entry.state === "executing" ? "executing" : "pending" };
+    }
+    async sendAbilityResponse(aid, callerAid, payload) {
+        try {
+            const sent = await this.callAunWithRecovery(aid, { to: callerAid, payload, encrypt: true });
+            if (typeof sent?.status !== "string" || !successfulSendStatuses.has(sent.status))
+                throw new Error("AUN 协议响应投递状态未确认");
+            this.context?.logger.info("AUN Ability 协议响应已发送", { aid, callerAid, path: payload.ability_path, callId: payload.call_id, stage: "Ability 响应" });
+            return true;
+        }
+        catch (error) {
+            this.context?.logger.error("AUN Ability 协议响应发送失败，结果可从账本重投", { aid, callerAid, path: payload.ability_path, error: safeError(error) });
+            return false;
+        }
+    }
+    async processMessage(message, aid, agentPlugin, inboundId) {
         let deliveryFailed = false;
-        const trace = { aid, peer: message.peerId, threadId: message.threadId ?? "", messageId: message.messageId ?? "", agentPlugin };
+        const trace = { traceId: message.messageId || inboundId, aid, peer: message.peerId, threadId: message.threadId ?? "", messageId: message.messageId ?? "", agentPlugin };
         this.context?.logger.info("AUN 收到任务", { ...trace, stage: "接收消息", attachments: message.attachments?.length ?? 0 });
         const client = this.clients.get(aid)?.client;
         let attachments = [];
@@ -956,7 +1430,7 @@ class AunPlugin {
             return;
         }
         const channelMessage = {
-            channel: "aun", recipientId: aid, peerId: message.peerId, messageId: message.messageId, text: message.text, threadId: message.threadId,
+            channel: "aun", recipientId: aid, peerId: message.peerId, messageId: message.messageId, traceId: message.messageId || inboundId, text: message.text, threadId: message.threadId,
             ...(attachments.length ? { attachments } : {}),
             agentPlugin,
             reply: async (text, signal) => {
@@ -964,7 +1438,7 @@ class AunPlugin {
                 if (!text.trim())
                     return;
                 try {
-                    await this.sendText(aid, message.peerId, text, message.threadId);
+                    await this.sendText(aid, message.peerId, text, message.threadId, false, "markdown");
                     this.context?.logger.info("AUN 文本已发送", { ...trace, stage: "发送文本消息" });
                 }
                 catch (error) {
@@ -1003,7 +1477,7 @@ class AunPlugin {
                         signal?.throwIfAborted();
                         const payloadText = withAttachmentDownloadLinks(text || (kind === "image" ? "图片已生成。" : kind === "video" ? "视频已生成。" : "文件已生成。"), kind, group);
                         // AUN 网页会隐藏带普通正文的单图卡片，图片说明需另发文本。
-                        const payload = { type: kind, ...(kind === "image" ? {} : { text: payloadText }), attachments: group };
+                        const payload = { type: kind, ...(kind === "image" ? {} : { text: payloadText, format: "markdown" }), attachments: group };
                         if (message.threadId)
                             payload.thread_id = message.threadId;
                         if (message.messageId)
@@ -1022,7 +1496,7 @@ class AunPlugin {
                             try {
                                 signal?.throwIfAborted();
                                 const { attachments: _attachments, ...caption } = payload;
-                                const result = await this.callAunWithRecovery(aid, { to: message.peerId, payload: { ...caption, type: "text", text: payloadText }, encrypt: true });
+                                const result = await this.callAunWithRecovery(aid, { to: message.peerId, payload: { ...caption, type: "text", text: payloadText, format: "markdown" }, encrypt: true });
                                 if (typeof result?.status !== "string" || !successfulSendStatuses.has(result.status))
                                     throw new Error(`AUN 图片说明发送状态未确认：${result?.status === undefined ? "未返回状态" : String(result.status)}`);
                                 this.context?.logger.info("AUN 图片说明已发送", { ...trace, stage: "发送图片说明" });
@@ -1040,7 +1514,7 @@ class AunPlugin {
                     const progress = sending ? `（已确认发送 ${sent}/${groupsCount} 组，当前组结果未确认，请勿重复发送）` : "";
                     const fallback = fallbackText && fallbackLinks.length ? `\n${withFailureDownloadLinks(fallbackText, fallbackLinks.map((url) => ({ url })))}` : "";
                     try {
-                        await this.sendText(aid, message.peerId, `附件回传失败${progress}：${safeError((0, agent_1.errorDetails)(failure))}${fallback}`, message.threadId, true);
+                        await this.sendText(aid, message.peerId, `附件回传失败${progress}：${safeError((0, agent_1.errorDetails)(failure))}${fallback}`, message.threadId, true, "markdown");
                     }
                     catch { /* 尽力反馈 */ }
                     throw failure;
@@ -1065,8 +1539,8 @@ class AunPlugin {
             }
         }
     }
-    async sendText(aid, peerId, text, threadId, encryptedOnly = false) {
-        const payload = { type: "text", text };
+    async sendText(aid, peerId, text, threadId, encryptedOnly = false, format) {
+        const payload = { type: "text", text, ...(format ? { format } : {}) };
         if (threadId)
             payload.thread_id = threadId;
         const params = { to: peerId, payload, encrypt: true };