aws-runtime-bridge 1.9.40 → 1.9.41

package/package/aws-client-agent-mcp/dist/mcp-server.test.js

@@ -183,7 +183,7 @@ describe("McpServer unread backlog hydration", () => {
         // The message must arrive via the local buffer (WebSocket push), not a second blocking fetch.
         assert.equal(fetchOptions.length, 1);
         assert.equal(fetchOptions[0].blockIfEmpty, false);
-        assert.equal(fetchOptions[0].includePipelineTasks, false);
+        assert.equal(fetchOptions[0].includePipelineTasks, true);
     });
     it("poll_message should handle hydration error gracefully and receive WebSocket messages", async () => {
         const directMessage = {
@@ -436,7 +436,7 @@ describe("McpServer unread backlog hydration", () => {
         assert.equal(result.fromBuffer, true);
         assert.equal(fetchOptions.length, 1);
         assert.equal(fetchOptions[0]?.blockIfEmpty, false);
-        assert.equal(fetchOptions[0]?.includePipelineTasks, false);
+        assert.equal(fetchOptions[0]?.includePipelineTasks, true);
         assert.equal(fetchOptions[0]?.blockTimeoutMs, undefined);
     });
     it("poll_message should merge existing local cache with newly claimed task notification", async () => {
@@ -478,7 +478,7 @@ describe("McpServer unread backlog hydration", () => {
         assert.equal(result.fromBuffer, true);
         assert.equal(fetchOptions.length, 1);
         assert.equal(fetchOptions[0]?.blockIfEmpty, false);
-        assert.equal(fetchOptions[0]?.includePipelineTasks, false);
+        assert.equal(fetchOptions[0]?.includePipelineTasks, true);
     });
     it("poll_message should wait for WebSocket messages when backend long polling returns empty", async () => {
         const delayedMessage = {
@@ -667,6 +667,93 @@ describe("McpServer unread backlog hydration", () => {
             "thinking",
         ]);
     });
+    it("poll_message should skip reportToolResult when only _acodeAutoDelegate messages are returned", async () => {
+        const statusEvents = [];
+        const reportedResults = [];
+        const delegateMessage = {
+            msgId: "memory-update-pending-1",
+            senderId: "MCP-System",
+            senderName: "系统",
+            receiverId: "agent-self",
+            content: "您有以下 Memory 正处于更新中状态",
+            requireReply: false,
+            timestamp: new Date().toISOString(),
+            _acodeAutoDelegate: {
+                type: "memory_file_change",
+                uris: ["architecture://relay/core-routing"],
+            },
+        };
+        const server = createServerWithUnread({
+            directMessages: [delegateMessage],
+            groupMessages: [],
+        }, {
+            getStatusReporter: () => ({
+                reportToolUse: () => statusEvents.push("tool_using"),
+                reportToolResult: (r) => {
+                    statusEvents.push("tool_result");
+                    reportedResults.push(r);
+                },
+                reportThinking: () => statusEvents.push("thinking"),
+                reportWaitingInput: () => statusEvents.push("waiting_input"),
+                reportError: () => statusEvents.push("error"),
+                reportToolError: () => statusEvents.push("tool_error"),
+            }),
+        });
+        const handleToolCall = getHandleToolCall(server);
+        const result = (await handleToolCall.call(server, "poll_message", {}));
+        assert.equal(result.directMessages.length, 1);
+        assert.deepEqual(statusEvents, ["tool_using", "thinking"]);
+        assert.equal(reportedResults.length, 0);
+    });
+    it("poll_message should filter _acodeAutoDelegate from reportToolResult but keep normal messages", async () => {
+        const statusEvents = [];
+        const reportedResults = [];
+        const delegateMessage = {
+            msgId: "memory-update-pending-2",
+            senderId: "MCP-System",
+            senderName: "系统",
+            receiverId: "agent-self",
+            content: "请继续完成更新工作",
+            requireReply: false,
+            timestamp: new Date().toISOString(),
+            _acodeAutoDelegate: {
+                type: "memory_file_change",
+                uris: ["architecture://overview/system-architecture"],
+            },
+        };
+        const normalMessage = {
+            msgId: "dm-normal-work",
+            senderId: "agent-colleague",
+            senderName: "Colleague",
+            content: "请帮忙看一下这个接口",
+            requireReply: false,
+            timestamp: new Date().toISOString(),
+        };
+        const server = createServerWithUnread({
+            directMessages: [delegateMessage, normalMessage],
+            groupMessages: [],
+        }, {
+            getStatusReporter: () => ({
+                reportToolUse: () => statusEvents.push("tool_using"),
+                reportToolResult: (r) => {
+                    statusEvents.push("tool_result");
+                    reportedResults.push(r);
+                },
+                reportThinking: () => statusEvents.push("thinking"),
+                reportWaitingInput: () => statusEvents.push("waiting_input"),
+                reportError: () => statusEvents.push("error"),
+                reportToolError: () => statusEvents.push("tool_error"),
+            }),
+        });
+        const handleToolCall = getHandleToolCall(server);
+        const result = (await handleToolCall.call(server, "poll_message", {}));
+        assert.equal(result.directMessages.length, 2);
+        assert.deepEqual(statusEvents, ["tool_using", "tool_result", "thinking"]);
+        assert.equal(reportedResults.length, 1);
+        const reported = reportedResults[0];
+        assert.equal(reported.directMessages.length, 1);
+        assert.equal(reported.directMessages[0].msgId, "dm-normal-work");
+    });
 });
 describe("McpServer memory store paths", () => {
     it("uses project permanent memory directory by default", async () => {
@@ -930,17 +1017,9 @@ describe("McpServer memory tools", () => {
             assert.equal(memoryStats.by_type.project_memory?.by_domain.core?.count, 1);
         });
     });
-    it("poll_message injects a cleanup notice when listable memory exceeds soft limits", async () => {
+    it("poll_message returns cleanup notice as a while-type when no unread messages", async () => {
         await withMemoryServer(async (server) => {
             const handleToolCall = getHandleToolCall(server);
-            const directMessage = {
-                msgId: "dm-trigger-cleanup",
-                senderId: "agent-trigger",
-                senderName: "Trigger Agent",
-                content: "trigger cleanup notice",
-                requireReply: false,
-                timestamp: new Date().toISOString(),
-            };
             Reflect.set(server, "agentClient", {
                 fetchUnreadMessages: async () => ({
                     directMessages: [],
@@ -956,27 +1035,29 @@ describe("McpServer memory tools", () => {
                     content: `recent ${index}`,
                 });
             }
-            // poll_message blocks until a real message arrives; cleanup notice is prepended.
+            // Override poll to resolve immediately with empty (simulating timeout without waiting 30s)
             const buffer = Reflect.get(server, "messageBuffer");
-            setTimeout(() => {
-                buffer.push(directMessage);
-            }, 50);
+            const originalPoll = buffer.poll.bind(buffer);
+            let pollCallCount = 0;
+            buffer.poll = ((_timeoutMs) => {
+                pollCallCount++;
+                return Promise.resolve({ directMessages: [], groupMessages: [] });
+            });
             const result = (await handleToolCall.call(server, "poll_message", {}));
             assert.equal(result.groupMessages.length, 0);
-            // cleanup notice prepended before the real message
-            assert.equal(result.directMessages.length, 2);
+            // cleanup notice returned as a while-type (no unread messages)
+            assert.equal(result.directMessages.length, 1);
             assert.match(result.directMessages[0]?.msgId, /^memory-cleanup-/);
             assert.equal(result.directMessages[0]?.senderId, "MCP-System");
             assert.equal(result.directMessages[0]?.receiverId, "agent-self");
             assert.match(result.directMessages[0]?.content ?? "", /本地 memory 已超过建议容量/);
-            assert.match(result.directMessages[0]?.content ?? "", /agent_memory\/recent 类型下当前 33 条 memory/);
             assert.match(result.directMessages[0]?.content ?? "", /get_memory_stats/);
             assert.match(result.directMessages[0]?.prompt ?? "", /无需持久化/);
-            // real message follows the cleanup notice
-            assert.equal(result.directMessages[1]?.msgId, directMessage.msgId);
+            // 非紧急类在初始路径直接返回，不进入 while 循环
+            assert.equal(pollCallCount, 0);
         });
     });
-    it("poll_message should claim backend tasks before returning a cleanup notice", async () => {
+    it("poll_message returns task notification without cleanup notice (while-type not stacked)", async () => {
         await withMemoryServer(async (server) => {
             const handleToolCall = getHandleToolCall(server);
             const taskNotification = {
@@ -1008,13 +1089,11 @@ describe("McpServer memory tools", () => {
                 });
             }
             const result = (await handleToolCall.call(server, "poll_message", {}));
-            assert.equal(fetchOptions.length, 1);
-            assert.equal(fetchOptions[0]?.blockIfEmpty, false);
-            assert.equal(fetchOptions[0]?.includePipelineTasks, false);
+            // Task notification is returned as an unread message; cleanup is a while-type
+            // that is only checked when there are no unread messages - not stacked with messages.
             assert.equal(result.groupMessages.length, 0);
-            assert.equal(result.directMessages.length, 2);
-            assert.match(result.directMessages[0]?.msgId, /^memory-cleanup-/);
-            assert.equal(result.directMessages[1]?.msgId, taskNotification.msgId);
+            assert.equal(result.directMessages.length, 1);
+            assert.equal(result.directMessages[0]?.msgId, taskNotification.msgId);
         });
     });
     it("get_message injects a cleanup notice when listable memory exceeds soft limits", async () => {
@@ -1164,7 +1243,7 @@ describe("McpServer memory tools", () => {
             assert.deepEqual(missingDelete, { deleted: false });
         });
     });
-    it("rejects empty append-only updates as no-op", async () => {
+    it("allows no-content update for status-only refresh (empty append)", async () => {
         await withMemoryServer(async (server) => {
             const handleToolCall = getHandleToolCall(server);
             await handleToolCall.call(server, "create_memory", {
@@ -1172,10 +1251,12 @@ describe("McpServer memory tools", () => {
                 uri: "core://agent/noop",
                 content: "original",
             });
-            await assert.rejects(() => handleToolCall.call(server, "update_memory", {
+            // 空 append 不再报错，而是执行无内容更新（仅刷新状态/MD5）
+            const result = await handleToolCall.call(server, "update_memory", {
                 uri: "core://agent/noop",
                 append: "",
-            }), /Provide either old_string\/new_string or append/);
+            });
+            assert.ok(result, "no-content update should succeed");
         });
     });
     it("rejects create_memory when bound_files contain non-existent paths", async () => {
@@ -1800,7 +1881,7 @@ describe("McpServer todo reminder on poll_message", () => {
             timestamp: new Date().toISOString(),
         };
     }
-    it("injects todo reminder when incomplete todos exist", async () => {
+    it("returns todo alone when incomplete todos exist and no unread messages", async () => {
         await writeTodoFile([
             { content: "任务A", status: "pending", priority: "high" },
             { content: "任务B", status: "completed", priority: "low" },
@@ -1809,11 +1890,33 @@ describe("McpServer todo reminder on poll_message", () => {
             const server = createServerForTodo();
             const handleToolCall = getHandleToolCall(server);
             const result = (await handleToolCall.call(server, "poll_message", {}));
+            // 无未读消息时，todo 单独返回（组合2）
             assert.equal(result.directMessages.length, 1);
-            const notice = result.directMessages[0];
-            assert.equal(notice.senderId, "MCP-System");
-            assert.equal(notice.senderName, "系统");
-            assert.match(notice.content, /Todo 列表存在 1 项未完成/);
+            assert.equal(result.directMessages[0].senderId, "MCP-System");
+            assert.equal(result.directMessages[0].senderName, "系统");
+            assert.match(result.directMessages[0].content, /Todo 列表存在 1 项未完成/);
+        }
+        finally {
+            await cleanupTodoFile();
+        }
+    });
+    it("returns messages + todo when both unread messages and incomplete todos exist", async () => {
+        await writeTodoFile([
+            { content: "任务A", status: "pending", priority: "high" },
+        ]);
+        try {
+            const server = createServerForTodo();
+            // 先把消息放入 buffer，模拟已有未读消息
+            const buffer = Reflect.get(server, "messageBuffer");
+            const msg = makeDirectMessage("msg-before-poll");
+            buffer.push(msg);
+            const handleToolCall = getHandleToolCall(server);
+            const result = (await handleToolCall.call(server, "poll_message", {}));
+            // 有未读消息 + todo -> 组合4: 未读消息 + todo
+            assert.equal(result.directMessages.length, 2);
+            assert.equal(result.directMessages[0].senderId, "MCP-System");
+            assert.match(result.directMessages[0].content, /Todo 列表存在 1 项未完成/);
+            assert.equal(result.directMessages[1].msgId, "msg-before-poll");
         }
         finally {
             await cleanupTodoFile();
@@ -1830,7 +1933,7 @@ describe("McpServer todo reminder on poll_message", () => {
             setTimeout(() => buffer.push(wake), 50);
             const handleToolCall = getHandleToolCall(server);
             const result = (await handleToolCall.call(server, "poll_message", {}));
-            // 全完成时不应注入 todo 通知，仅返回 push 的唤醒消息
+            // 全完成时无 todo，进入 while 循环等待消息后返回
             assert.equal(result.directMessages.length, 1);
             assert.equal(result.directMessages[0].msgId, "wake-completed");
         }
@@ -1838,46 +1941,43 @@ describe("McpServer todo reminder on poll_message", () => {
             await cleanupTodoFile();
         }
     });
-    it("does not repeat todo reminder when fingerprint unchanged", async () => {
+    it("returns todo alone on every poll_message when incomplete todos exist", async () => {
         await writeTodoFile([
             { content: "任务A", status: "pending", priority: "high" },
         ]);
         try {
             const server = createServerForTodo();
             const handleToolCall = getHandleToolCall(server);
-            // 第一次：应返回 todo 通知
+            // 第一次 poll：无未读消息 -> todo 单独返回（组合2）
             const result1 = (await handleToolCall.call(server, "poll_message", {}));
             assert.equal(result1.directMessages.length, 1);
-            assert.match(result1.directMessages[0].content, /Todo 列表存在/);
-            // 第二次：指纹未变，应进入阻塞等待。push 一条消息让 poll 返回
-            const buffer = Reflect.get(server, "messageBuffer");
-            const wake = makeDirectMessage("wake-unchanged");
-            setTimeout(() => buffer.push(wake), 50);
+            assert.match(result1.directMessages[0].content, /Todo 列表存在 1 项未完成/);
+            // 第二次 poll（待办未变）：仍返回 todo
             const result2 = (await handleToolCall.call(server, "poll_message", {}));
-            // 第二次不应再注入 todo 通知，仅返回 push 的唤醒消息
             assert.equal(result2.directMessages.length, 1);
-            assert.equal(result2.directMessages[0].msgId, "wake-unchanged");
+            assert.match(result2.directMessages[0].content, /Todo 列表存在 1 项未完成/);
         }
         finally {
             await cleanupTodoFile();
         }
     });
-    it("re-injects todo reminder when todos change after being notified", async () => {
+    it("returns todo with updated count when todo file changes", async () => {
         await writeTodoFile([
             { content: "任务A", status: "pending", priority: "high" },
         ]);
         try {
             const server = createServerForTodo();
             const handleToolCall = getHandleToolCall(server);
-            // 第一次：返回 todo 通知（1 项未完成）
+            // 第一次 poll：1 项未完成
             const result1 = (await handleToolCall.call(server, "poll_message", {}));
+            assert.equal(result1.directMessages.length, 1);
             assert.match(result1.directMessages[0].content, /Todo 列表存在 1 项未完成/);
-            // 修改 todo：新增一项未完成（指纹变化）
+            // 修改 todo：新增一项
             await writeTodoFile([
                 { content: "任务A", status: "pending", priority: "high" },
                 { content: "任务B", status: "in_progress", priority: "medium" },
             ]);
-            // 第二次：指纹变化，应再次返回 todo 通知（2 项未完成）
+            // 第二次 poll：2 项未完成
             const result2 = (await handleToolCall.call(server, "poll_message", {}));
             assert.equal(result2.directMessages.length, 1);
             assert.match(result2.directMessages[0].content, /Todo 列表存在 2 项未完成/);
@@ -1895,7 +1995,7 @@ describe("McpServer todo reminder on poll_message", () => {
         setTimeout(() => buffer.push(wake), 50);
         const handleToolCall = getHandleToolCall(server);
         const result = (await handleToolCall.call(server, "poll_message", {}));
-        // 无 todo 文件不应注入通知，仅返回 push 的唤醒消息
+        // 无 todo 文件 -> 进入 while 循环等待消息后返回
         assert.equal(result.directMessages.length, 1);
         assert.equal(result.directMessages[0].msgId, "wake-no-file");
     });