mu-agent-bridge 1.0.71 → 1.0.73

package/dist/tests-ts/model-provider-cancellation.test.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = __importDefault(require("node:test"));
+const cdp_client_1 = require("../src-ts/plugins/qwenwork/cdp-client");
+const cdp_client_2 = require("../src-ts/plugins/chatgpt/cdp-client");
+const cdp_client_3 = require("../src-ts/plugins/workbuddy/cdp-client");
+const cdp_client_4 = require("../src-ts/plugins/doubao/cdp-client");
+const flush = () => new Promise(resolve => setImmediate(resolve));
+(0, node_test_1.default)("千问取消后保留生成中的任务，确认本轮空回复结束才收尾", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "Date"] });
+    const client = new cdp_client_1.QwenCdpClient();
+    const controller = new AbortController();
+    let submitted = false;
+    let generating = false;
+    let error;
+    client.ensureVisible = client.recoverDraft = client.waitFor = async () => undefined;
+    client.readArtifacts = async () => [];
+    client.cdp = async () => { submitted = true; };
+    client.close = () => strict_1.default.fail("取消不应关闭桌面连接");
+    client.evaluate = async (expression) => {
+        if (expression === "location.href")
+            return "file:///index.html?chat=model-chat";
+        if (expression.startsWith("JSON.stringify(["))
+            return JSON.stringify(submitted ? [{ id: "current", text: "" }] : []);
+        if (expression.startsWith("Boolean(document.querySelector('button"))
+            return generating;
+        return true;
+    };
+    const running = client.complete("模型提示", 10, controller.signal).catch((value) => { error = value; });
+    await flush();
+    controller.abort();
+    for (let index = 0; index < 2; index++) {
+        t.mock.timers.tick(2000);
+        await flush();
+    }
+    strict_1.default.equal(error, undefined, "尚未观察到本轮生成时不能猜测任务结束");
+    generating = true;
+    t.mock.timers.tick(2000);
+    await flush();
+    strict_1.default.equal(error, undefined);
+    generating = false;
+    t.mock.timers.tick(2000);
+    await flush();
+    strict_1.default.equal(error, undefined, "单次未生成状态不能释放任务");
+    t.mock.timers.tick(2000);
+    await flush();
+    strict_1.default.match(String(error), /QWEN_REQUEST_CANCELLED.*已取消.*本轮.*结束/);
+    await running;
+});
+(0, node_test_1.default)("ChatGPT 取消后等待本轮生成结束，空回复不永久占用原任务", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "Date"] });
+    const client = new cdp_client_2.ChatgptCdpClient();
+    const controller = new AbortController();
+    let active = false;
+    let error;
+    client.waitFor = client.waitForGeneration = client.recoverDraft = async () => undefined;
+    client.activeSession = async () => ({ id: "model", host: "local", title: "模型会话" });
+    client.cdp = async () => undefined;
+    client.close = () => strict_1.default.fail("取消不应关闭桌面连接");
+    client.evaluate = async (expression) => {
+        if (expression.includes("findLast((item, index)"))
+            return JSON.stringify({ submitted: true, active, reply: "", hasArtifacts: false, artifacts: [{ conversationId: "model", messageId: "current" }] });
+        if (expression.startsWith("JSON.stringify("))
+            return "[]";
+        if (expression.endsWith(".length"))
+            return 0;
+        return true;
+    };
+    const running = client.direct("模型提示", 10, undefined, controller.signal).catch((value) => { error = value; });
+    await flush();
+    controller.abort();
+    for (let index = 0; index < 2; index++) {
+        t.mock.timers.tick(800);
+        await flush();
+    }
+    strict_1.default.equal(error, undefined, "消息已提交但尚未开始生成时不能释放任务");
+    active = true;
+    t.mock.timers.tick(800);
+    await flush();
+    strict_1.default.equal(error, undefined);
+    active = false;
+    t.mock.timers.tick(800);
+    await flush();
+    strict_1.default.equal(error, undefined, "单次停止状态不能释放任务");
+    t.mock.timers.tick(800);
+    await flush();
+    strict_1.default.match(String(error), /ChatGPT.*已取消.*本轮.*结束/);
+    await running;
+});
+(0, node_test_1.default)("WorkBuddy 取消后等待本轮完成标记，空回复也能结束等待", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "Date"] });
+    const client = new cdp_client_3.WorkbuddyCdpClient();
+    const controller = new AbortController();
+    let finished = false;
+    let error;
+    client.evaluate = async () => JSON.stringify([{ id: "current", text: "", finished, stopped: false }]);
+    client.readInteraction = async () => undefined;
+    client.readArtifacts = async () => [];
+    client.close = () => strict_1.default.fail("取消不应关闭桌面连接");
+    const running = client.waitForReply(new Set(), 10, undefined, undefined, "model", undefined, controller.signal).catch((value) => { error = value; });
+    controller.abort();
+    t.mock.timers.tick(1000);
+    await flush();
+    strict_1.default.equal(error, undefined);
+    finished = true;
+    t.mock.timers.tick(1000);
+    await flush();
+    strict_1.default.match(String(error), /WORKBUDDY_REQUEST_CANCELLED.*已取消.*本轮.*结束/);
+    await running;
+});
+(0, node_test_1.default)("豆包取消后的空 SSE 终态释放队列，下一轮不会接到前轮结果", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "Date"] });
+    const client = new cdp_client_4.DoubaoCdpClient({ timeoutMs: 10 });
+    const controller = new AbortController();
+    let requests = 0;
+    let finished = false;
+    let error;
+    client.connect = async () => undefined;
+    client.close = () => strict_1.default.fail("取消不应关闭桌面连接");
+    client.evaluate = async (expression) => {
+        if (expression !== "window.__mab_doubao_result") {
+            requests++;
+            return "started";
+        }
+        if (requests === 1)
+            return finished ? JSON.stringify({ ok: true, reply: "", pending: false, conversationId: "123" }) : null;
+        return JSON.stringify({ ok: true, reply: "只属于下一轮的回复", conversationId: "456" });
+    };
+    const first = client.complete("取消提示", controller.signal, undefined, "").catch((value) => { error = value; });
+    await flush();
+    const second = client.complete("新请求", undefined, undefined, "");
+    controller.abort();
+    t.mock.timers.tick(1000);
+    await flush();
+    strict_1.default.equal(error, undefined);
+    strict_1.default.equal(requests, 1, "页面请求未结束时，下一轮不得提交");
+    finished = true;
+    t.mock.timers.tick(1000);
+    await flush();
+    strict_1.default.match(String(error), /豆包.*已取消.*本轮.*结束/);
+    strict_1.default.equal(requests, 2, "已确认空结果后应释放原队列");
+    t.mock.timers.tick(1000);
+    await flush();
+    strict_1.default.deepEqual(await second, { text: "只属于下一轮的回复", sessionId: "456" });
+    await first;
+});

package/dist/tests-ts/personal-assistant-coordination.test.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_test_1 = require("node:test");
+const coordination_1 = require("../src-ts/plugins/personal-assistant/coordination");
+async function fixture(responses) {
+    const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "pa-coordination-"));
+    const logPath = (0, node_path_1.join)(dir, "args.jsonl");
+    const ecPath = (0, node_path_1.join)(dir, "ec");
+    const responder = `const fs=require('node:fs');const args=process.argv.slice(2);fs.appendFileSync(${JSON.stringify(logPath)},JSON.stringify(args)+'\\n');const value=(${responses.toString()})(args);process.stdout.write(JSON.stringify(value));`;
+    await (0, promises_1.writeFile)(ecPath, `#!/usr/bin/env node\n${responder}\n`);
+    await (0, promises_1.chmod)(ecPath, 0o755);
+    return {
+        coordinator: (0, coordination_1.createCoordinator)({ ecPath, selfAid: "self.agentid.cn", allowedAgents: [{ id: "worker", aids: ["worker.agentid.cn"] }] }),
+        args: async () => { try {
+            return (await (0, promises_1.readFile)(logPath, "utf8")).trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
+        }
+        catch {
+            return [];
+        } },
+        cleanup: () => (0, promises_1.rm)(dir, { recursive: true, force: true }),
+    };
+}
+(0, node_test_1.test)("派活只允许白名单内匹配的 Agent 与 AID", async () => {
+    const value = await fixture(() => ({ thread_id: "thread-1" }));
+    try {
+        await strict_1.default.rejects(value.coordinator.dispatch({ agentId: "other", aid: "worker.agentid.cn", task: "工作" }), /白名单/);
+        await strict_1.default.rejects(value.coordinator.dispatch({ agentId: "worker", aid: "other.agentid.cn", task: "工作" }), /白名单/);
+        await strict_1.default.rejects(value.coordinator.dispatch({ agentId: "worker; touch /tmp/no", aid: "worker.agentid.cn", task: "工作" }), /白名单/);
+        strict_1.default.deepEqual(await value.args(), []);
+    }
+    finally {
+        await value.cleanup();
+    }
+});
+(0, node_test_1.test)("创建 thread 后用 argv 派活，特殊字符作为普通任务文本传入", async () => {
+    const value = await fixture((args) => args[0] === "thread" ? { ok: true, thread_id: "thread-1" } : { ok: true, status: "completed" });
+    try {
+        const task = "检查 x; touch /tmp/no && $(whoami)";
+        const dispatched = await value.coordinator.dispatch({ agentId: "worker", aid: "worker.agentid.cn", task });
+        strict_1.default.deepEqual(dispatched, { status: "pending", agentId: "worker", aid: "worker.agentid.cn", threadId: "thread-1" });
+        strict_1.default.deepEqual(await value.args(), [
+            ["thread", "create", "worker.agentid.cn", "--name", "个人助理派活-worker", "--format", "json"],
+            ["msg", "send", "self.agentid.cn", "worker.agentid.cn", "--text", task, "--thread", "thread-1", "--return", "required", "--format", "json"],
+        ]);
+    }
+    finally {
+        await value.cleanup();
+    }
+});
+(0, node_test_1.test)("thread history 未明确标记完成时保持 pending，且不重发任务", async () => {
+    const value = await fixture((args) => {
+        if (args[0] === "thread" && args[1] === "create")
+            return { thread_id: "thread-1" };
+        if (args[0] === "msg")
+            return { ok: true, status: "completed" };
+        return { messages: [{ from: "worker.agentid.cn", text: "仍在处理" }] };
+    });
+    try {
+        await value.coordinator.dispatch({ agentId: "worker", aid: "worker.agentid.cn", task: "执行任务" });
+        const result = await value.coordinator.getStatus({ aid: "worker.agentid.cn", threadId: "thread-1" });
+        strict_1.default.deepEqual(result, { status: "pending", aid: "worker.agentid.cn", threadId: "thread-1", history: { messages: [{ from: "worker.agentid.cn", text: "仍在处理" }] } });
+        const calls = await value.args();
+        strict_1.default.equal(calls.filter((args) => args[0] === "msg" && args[1] === "send").length, 1);
+        strict_1.default.deepEqual(calls.at(-1), ["thread", "history", "thread-1", "--format", "json"]);
+    }
+    finally {
+        await value.cleanup();
+    }
+});

package/dist/tests-ts/personal-assistant-extensions.test.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = require("node:test");
+const tools_1 = require("../src-ts/plugins/personal-assistant/tools");
+const management = {
+    listAgents: async () => [{ id: "worker", displayName: "工作 Agent", status: "ready", available: true, reason: "", capabilities: ["chat"], aids: ["worker.agentid.cn"], callable: true }],
+    callAgent: async () => ({ text: "" }), listAunIdentities: async () => ({}), createAunIdentity: async () => ({}), bindAunIdentity: async () => ({}),
+    runSessionCommand: async () => "", summarizeToday: async () => ({ supported: false, text: "", sources: [], complete: false }),
+};
+(0, node_test_1.test)("扩展工具只向配置的 Provider 访问远程 Ability", async () => {
+    let calls = 0;
+    const remoteAbility = { discover: async () => { calls++; return []; }, call: async () => { calls++; return { status: "completed" }; }, getRequest: async () => { calls++; return { status: "pending" }; } };
+    await strict_1.default.rejects((0, tools_1.executeTool)("ability_discover", { providerAid: "other.agentid.cn" }, management, [], { allowedProviders: ["provider.agentid.cn"], remoteAbility: remoteAbility }));
+    strict_1.default.deepEqual(await (0, tools_1.executeTool)("ability_discover", { providerAid: "provider.agentid.cn" }, management, [], { allowedProviders: ["provider.agentid.cn"], remoteAbility: remoteAbility }), []);
+    strict_1.default.equal(calls, 1);
+});
+(0, node_test_1.test)("协调派活要求核心可用状态、Agent 白名单和绑定 AID 同时匹配", async () => {
+    const args = { agentId: "worker", aid: "worker.agentid.cn", task: "执行工作" };
+    await strict_1.default.rejects((0, tools_1.executeTool)("coordination_dispatch", args, management, [], { selfAid: "assistant.agentid.cn" }), /白名单/);
+    await strict_1.default.rejects((0, tools_1.executeTool)("coordination_dispatch", { ...args, aid: "other.agentid.cn" }, management, ["worker"], { selfAid: "assistant.agentid.cn" }), /不可派活/);
+    strict_1.default.deepEqual((0, tools_1.toolDefinitions)().map((tool) => tool.function.name).slice(-6), ["ability_discover", "ability_call", "ability_request_get", "coordination_dispatch", "coordination_status", "owner_context_read"]);
+});
+(0, node_test_1.test)("thread 状态查询只允许当前插件进程已派发的 thread", async () => {
+    await strict_1.default.rejects((0, tools_1.executeTool)("coordination_status", { aid: "worker.agentid.cn", threadId: "thread-1" }, management, [], { selfAid: "assistant.agentid.cn", threads: new Map() }), /不属于/);
+});

package/dist/tests-ts/personal-assistant-owner-context.test.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_test_1 = require("node:test");
+const owner_context_1 = require("../src-ts/plugins/personal-assistant/owner-context");
+async function fixture(responses) {
+    const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "pa-owner-context-"));
+    const logPath = (0, node_path_1.join)(dir, "args.jsonl");
+    const ecPath = (0, node_path_1.join)(dir, "ec");
+    const responder = `const fs=require('node:fs');const args=process.argv.slice(2);const log=${JSON.stringify(logPath)};const calls=fs.existsSync(log)?fs.readFileSync(log,'utf8').split('\\n').filter(Boolean).length:0;fs.appendFileSync(log,JSON.stringify(args)+'\\n');const value=(${responses.toString()})(args,calls);process.stdout.write(JSON.stringify(value));`;
+    await (0, promises_1.writeFile)(ecPath, `#!/usr/bin/env node\n${responder}\n`);
+    await (0, promises_1.chmod)(ecPath, 0o755);
+    return {
+        ecPath,
+        args: async () => (await (0, promises_1.readFile)(logPath, "utf8")).trim().split("\n").filter(Boolean).map((line) => JSON.parse(line)),
+        cleanup: () => (0, promises_1.rm)(dir, { recursive: true, force: true }),
+    };
+}
+(0, node_test_1.test)("只用固定 Owner AID 和规范路径经 execFile 读取，内容标记为参考资料", async () => {
+    const fake = await fixture(() => ({ command: "cat", binary: false, text: "仅供参考" }));
+    try {
+        const store = (0, owner_context_1.createOwnerContextStore)({ ownerAid: "owner.agentid.cn", path: "/profile/context.md", ttlMs: 1000, ecPath: fake.ecPath });
+        const result = await store.get();
+        strict_1.default.equal(result.content, "仅供参考");
+        strict_1.default.equal(result.status, "fresh");
+        strict_1.default.equal(result.trust, "reference_only");
+        strict_1.default.deepEqual(await fake.args(), [["fs", "cat", "owner.agentid.cn:/profile/context.md", "--format", "json"]]);
+    }
+    finally {
+        await fake.cleanup();
+    }
+});
+(0, node_test_1.test)("TTL 内复用缓存，refresh 强制读取新值", async () => {
+    let now = 10_000;
+    const fake = await fixture((_args, calls) => ({ command: "cat", binary: false, text: `版本${calls + 1}` }));
+    try {
+        const store = (0, owner_context_1.createOwnerContextStore)({ ownerAid: "owner.agentid.cn", path: "/profile/context.md", ttlMs: 1000, ecPath: fake.ecPath, now: () => now });
+        strict_1.default.equal((await store.get()).content, "版本1");
+        now += 500;
+        const cached = await store.get();
+        strict_1.default.equal(cached.content, "版本1");
+        strict_1.default.equal(cached.status, "cached");
+        strict_1.default.equal(cached.ageMs, 500);
+        strict_1.default.equal((await store.refresh()).content, "版本2");
+        strict_1.default.equal((await fake.args()).length, 2);
+    }
+    finally {
+        await fake.cleanup();
+    }
+});
+(0, node_test_1.test)("刷新失败保留上次成功值并标记 stale", async () => {
+    let now = 10_000;
+    const fake = await fixture((_args, calls) => {
+        if (calls === 0)
+            return { command: "cat", binary: false, text: "最后一次有效资料" };
+        throw new Error("读取失败");
+    });
+    try {
+        const store = (0, owner_context_1.createOwnerContextStore)({ ownerAid: "owner.agentid.cn", path: "/profile/context.md", ttlMs: 1000, ecPath: fake.ecPath, now: () => now });
+        const first = await store.get();
+        now += 1500;
+        const stale = await store.get();
+        strict_1.default.equal(first.content, stale.content);
+        strict_1.default.equal(stale.status, "stale");
+        strict_1.default.equal(stale.ageMs, 1500);
+        strict_1.default.equal((await fake.args()).length, 2);
+    }
+    finally {
+        await fake.cleanup();
+    }
+});
+(0, node_test_1.test)("拒绝无效 AID、非绝对或非规范路径及无效 TTL", async () => {
+    const fake = await fixture(() => ({ command: "cat", binary: false, text: "unused" }));
+    try {
+        for (const options of [
+            { ownerAid: "owner; touch /tmp/injected", path: "/profile/context.md", ttlMs: 1000 },
+            { ownerAid: "owner.agentid.cn", path: "profile/context.md", ttlMs: 1000 },
+            { ownerAid: "owner.agentid.cn", path: "/profile/../secret.md", ttlMs: 1000 },
+            { ownerAid: "owner.agentid.cn", path: "/profile/context.md", ttlMs: 0 },
+        ]) {
+            strict_1.default.throws(() => (0, owner_context_1.createOwnerContextStore)({ ...options, ecPath: fake.ecPath }));
+        }
+    }
+    finally {
+        await fake.cleanup();
+    }
+});
+(0, node_test_1.test)("拒绝超限文本，且不缓存无效读取", async () => {
+    let now = 10_000;
+    const fake = await fixture((_args, calls) => ({ command: "cat", binary: false, text: calls === 0 ? "ok" : "过长" }));
+    try {
+        const store = (0, owner_context_1.createOwnerContextStore)({ ownerAid: "owner.agentid.cn", path: "/profile/context.md", ttlMs: 1000, maxBytes: 3, ecPath: fake.ecPath, now: () => now });
+        strict_1.default.equal((await store.get()).content, "ok");
+        now += 2000;
+        strict_1.default.equal((await store.get()).content, "ok");
+        strict_1.default.equal((await fake.args()).length, 2);
+    }
+    finally {
+        await fake.cleanup();
+    }
+});

package/dist/tests-ts/personal-assistant-remote-ability.test.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_test_1 = require("node:test");
+const remote_ability_1 = require("../src-ts/plugins/personal-assistant/remote-ability");
+async function fixture(responses, globals = {}) {
+    const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "pa-remote-ability-"));
+    const logPath = (0, node_path_1.join)(dir, "args.jsonl");
+    const ecPath = (0, node_path_1.join)(dir, "ec");
+    const defaultIndex = `const fs=require('node:fs');const logPath=${JSON.stringify(logPath)};const index=()=>({abilities:[{path:"status/read",definition_id:"status-v1",detail_ref:"ability/status.json",params_schema:{type:"object",additionalProperties:false,properties:{device:{type:"string"}},required:["device"]},result_schema:{type:"object"},effects:["read"],auth_required:false,require_confirm:false}]});const response=(overrides={})=>({type:"ability",role:"result",call_id:"call-fixed",operation_id:"op-fixed",ability_path:"status/read",definition_id:"status-v1",ok:true,execution_state:"completed",result:{online:true},...overrides});`;
+    const declarations = Object.entries(globals).map(([key, value]) => `const ${key}=${JSON.stringify(value)};`).join("");
+    const responder = `${defaultIndex}${declarations}globalThis.fs=fs;globalThis.logPath=logPath;const args=process.argv.slice(2);fs.appendFileSync(logPath,JSON.stringify(args)+'\\n');const value=(${responses.toString()})(args);process.stdout.write(JSON.stringify(value));`;
+    await (0, promises_1.writeFile)(ecPath, `#!/usr/bin/env node\n${responder}\n`);
+    await (0, promises_1.chmod)(ecPath, 0o755);
+    return {
+        client: new remote_ability_1.RemoteAbilityClient({ selfAid: "self.agentid.cn", ecPath }),
+        args: async () => (await (0, promises_1.readFile)(logPath, "utf8")).trim().split("\n").filter(Boolean).map((line) => JSON.parse(line)),
+        cleanup: () => (0, promises_1.rm)(dir, { recursive: true, force: true }),
+    };
+}
+function index(overrides = {}) {
+    return {
+        abilities: [{ path: "status/read", definition_id: "status-v1", detail_ref: "ability/status.json", params_schema: { type: "object", additionalProperties: false, properties: { device: { type: "string" } }, required: ["device"] }, result_schema: { type: "object" }, effects: ["read"], auth_required: false, require_confirm: false, ...overrides }],
+    };
+}
+function response(overrides = {}) {
+    return { type: "ability", role: "result", call_id: "call-fixed", operation_id: "op-fixed", ability_path: "status/read", definition_id: "status-v1", ok: true, execution_state: "completed", result: { online: true }, ...overrides };
+}
+(0, node_test_1.test)("命令参数经 execFile 直传，远端 schema 和只读契约控制调用", async () => {
+    const fixtureValue = await fixture((args) => {
+        if (args[0] === "fs")
+            return { command: "cat", binary: false, text: JSON.stringify(args[2].endsWith("index.json") ? index() : index().abilities[0]) };
+        if (args[0] === "msg" && args[1] === "send") {
+            const payload = JSON.parse(args[args.indexOf("--payload") + 1]);
+            return { ok: true, request_state: "completed", request_id: payload.call_id, response: response({ call_id: payload.call_id, operation_id: payload.operation_id }) };
+        }
+        throw new Error("unexpected command");
+    });
+    try {
+        const providerAid = "provider.agentid.cn";
+        await fixtureValue.client.discover(providerAid);
+        const unsafeText = "x; touch /tmp/remote-ability-injected";
+        const result = await fixtureValue.client.call(providerAid, "status/read", { device: unsafeText });
+        strict_1.default.equal(result.status, "completed");
+        strict_1.default.deepEqual(result.result, { online: true });
+        const args = await fixtureValue.args();
+        strict_1.default.deepEqual(args[0], ["fs", "cat", `${providerAid}:/ability/index.json`, "--format", "json"]);
+        strict_1.default.deepEqual(args[1], ["fs", "cat", `${providerAid}:/ability/status.json`, "--format", "json"]);
+        strict_1.default.equal(args[2][0], "msg");
+        strict_1.default.equal(args[2][1], "send");
+        strict_1.default.ok(args[2].includes("--payload"));
+        strict_1.default.ok(args[2].includes("--return"));
+        strict_1.default.ok(args[2].includes("required"));
+        strict_1.default.equal(args[2].includes("--shell"), false);
+        const payload = JSON.parse(args[2][args[2].indexOf("--payload") + 1]);
+        strict_1.default.equal(payload.params.device, unsafeText);
+        strict_1.default.match(payload.call_id, /^c-/);
+        strict_1.default.match(payload.operation_id, /^op-/);
+    }
+    finally {
+        await fixtureValue.cleanup();
+    }
+});
+(0, node_test_1.test)("拒绝无效 AID、参数 schema 和非只读或需授权契约", async () => {
+    const fixtureValue = await fixture((args) => ({ command: "cat", binary: false, text: JSON.stringify(args[2].endsWith("index.json") ? index() : index().abilities[0]) }));
+    try {
+        await strict_1.default.rejects(fixtureValue.client.discover("bad aid"), /AID/);
+        await fixtureValue.client.discover("provider.agentid.cn");
+        await strict_1.default.rejects(fixtureValue.client.call("provider.agentid.cn", "status/read", {}), /schema/);
+        await strict_1.default.rejects(fixtureValue.client.call("provider.agentid.cn", "other", { device: "x" }), /能力/);
+    }
+    finally {
+        await fixtureValue.cleanup();
+    }
+    for (const denied of [{ effects: ["read", "write"] }, { auth_required: true }, { require_confirm: true }, { detail_ref: "../secret.json" }]) {
+        const entry = index(denied).abilities[0];
+        const fake = await fixture((args) => args[2].endsWith("index.json") ? { abilities: [entry] } : entry, { entry });
+        try {
+            await strict_1.default.rejects(fake.client.call("provider.agentid.cn", "status/read", { device: "x" }), /契约|引用|路径/);
+            strict_1.default.equal((await fake.args()).filter((args) => args[0] === "msg").length, 0);
+        }
+        finally {
+            await fake.cleanup();
+        }
+    }
+});
+(0, node_test_1.test)("pending 不重发，request get 读取业务结果并校验关联字段", async () => {
+    const fixtureValue = await fixture((args) => {
+        if (args[0] === "fs")
+            return { command: "cat", binary: false, text: JSON.stringify(args[2].endsWith("index.json") ? index() : index().abilities[0]) };
+        if (args[1] === "send") {
+            const payload = JSON.parse(args[args.indexOf("--payload") + 1]);
+            return { ok: true, request_state: "pending", request_id: payload.call_id };
+        }
+        if (args[1] === "request" && args[2] === "get") {
+            const lines = globalThis.fs.readFileSync(globalThis.logPath, "utf8").trim().split(String.fromCharCode(10)).filter(Boolean);
+            const sent = JSON.parse(lines.find((line) => JSON.parse(line)[1] === "send"));
+            const payload = JSON.parse(sent[sent.indexOf("--payload") + 1]);
+            return { ok: true, request: { state: "completed", responsePayload: response({ call_id: payload.call_id, operation_id: payload.operation_id }) } };
+        }
+        throw new Error("unexpected command");
+    });
+    try {
+        const providerAid = "provider.agentid.cn";
+        const pending = await fixtureValue.client.call(providerAid, "status/read", { device: "phone" });
+        strict_1.default.equal(pending.status, "pending");
+        strict_1.default.equal((await fixtureValue.args()).filter((args) => args[1] === "send").length, 1);
+        const completed = await fixtureValue.client.getRequest(providerAid, pending.requestId);
+        strict_1.default.equal(completed.status, "completed");
+        strict_1.default.deepEqual(completed.result, { online: true });
+        strict_1.default.equal((await fixtureValue.args()).filter((args) => args[1] === "send").length, 1);
+        await strict_1.default.rejects(fixtureValue.client.getRequest(providerAid, "bad id"), /request_id/);
+    }
+    finally {
+        await fixtureValue.cleanup();
+    }
+});