@xalia/agent 0.5.8 → 0.6.0

package/dist/agent/src/test/chatContextManager.test.js

@@ -0,0 +1,392 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const chatContextManager_1 = require("../chat/server/chatContextManager");
+const agent_1 = require("../agent/agent");
+const compressingContextManager_1 = require("../agent/compressingContextManager");
+const conversation_1 = require("../chat/server/conversation");
+const sessionFileManager_1 = require("../chat/server/sessionFileManager");
+const MESSAGES = [
+    {
+        message_idx: 200,
+        is_for_llm: true,
+        sender_uuid: "user",
+        content: { role: "user", content: "msg200" },
+    },
+    {
+        message_idx: 300,
+        is_for_llm: true,
+        content: { role: "assistant", content: "msg300" },
+    },
+    {
+        message_idx: 400,
+        is_for_llm: true,
+        sender_uuid: "user",
+        content: { role: "user", content: "msg400" },
+    },
+    {
+        message_idx: 500,
+        is_for_llm: true,
+        content: {
+            role: "assistant",
+            content: "msg500",
+            tool_calls: [
+                {
+                    id: "tool_call_0",
+                    type: "function",
+                    function: { name: "tool1", arguments: "" },
+                },
+            ],
+        },
+    },
+    {
+        message_idx: 501,
+        is_for_llm: true,
+        content: {
+            role: "tool",
+            content: "msg501",
+            tool_call_id: "tool_call_0",
+        },
+    },
+    {
+        message_idx: 502,
+        is_for_llm: true,
+        content: { role: "assistant", content: "msg502" },
+    },
+];
+function testSuccessfulAgentLoop(cm, startIdx) {
+    // 2 user messages arrive as ClientUserMessage. Assign message indices and
+    // convert them to ServerUserMessages.
+    const serverUserMessage0 = cm.processUserMessage({
+        type: "msg",
+        message: "UserMessage0",
+    }, "user0");
+    (0, vitest_1.expect)(serverUserMessage0).eql({
+        type: "user_msg",
+        session_id: "some_session_id",
+        user_uuid: "user0",
+        message_idx: startIdx + 0 * conversation_1.MESSAGE_INDEX_FULL_INCREMENT,
+        message: "UserMessage0",
+    });
+    const serverUserMessage1 = cm.processUserMessage({
+        type: "msg",
+        message: "UserMessage1",
+    }, "user1");
+    (0, vitest_1.expect)(serverUserMessage1).eql({
+        type: "user_msg",
+        session_id: "some_session_id",
+        user_uuid: "user1",
+        message_idx: startIdx + 1 * conversation_1.MESSAGE_INDEX_FULL_INCREMENT,
+        message: "UserMessage1",
+    });
+    // Begin processing an agent response.
+    //
+    // Agent response has a tool call.  It is assigned 2 *
+    // MESSAGE_INDEX_FULL_INCREMENT
+    const userMsgs = [serverUserMessage0, serverUserMessage1];
+    const { llmUserMessages, agentFirstChunk } = cm.startAgentResponse(userMsgs);
+    (0, vitest_1.expect)(agentFirstChunk.message_idx).eql(startIdx + 2 * conversation_1.MESSAGE_INDEX_FULL_INCREMENT);
+    (0, vitest_1.expect)(llmUserMessages).eql(userMsgs.map((su) => {
+        return {
+            role: "user",
+            name: su.user_uuid,
+            content: su.message,
+        };
+    }));
+    // The agent sends message chunks.  Check the message_idx
+    const chunkMsg0 = cm.processAgentMessage("AgentMe", false);
+    (0, vitest_1.expect)(chunkMsg0).eql({
+        type: "agent_msg_chunk",
+        session_id: "some_session_id",
+        message_idx: startIdx + 2 * conversation_1.MESSAGE_INDEX_FULL_INCREMENT,
+        message: "AgentMe",
+        end: false,
+    });
+    const chunkMsg1 = cm.processAgentMessage("ssage2", true);
+    (0, vitest_1.expect)(chunkMsg1).eql({
+        type: "agent_msg_chunk",
+        session_id: "some_session_id",
+        message_idx: startIdx + 2 * conversation_1.MESSAGE_INDEX_FULL_INCREMENT,
+        message: "ssage2",
+        end: true,
+    });
+    // A full response (with toolcall) is returned
+    const agentResponseWithToolCall = {
+        role: "assistant",
+        tool_calls: [
+            {
+                id: "tool_call_0",
+                type: "function",
+                function: {
+                    name: "tool0",
+                    arguments: "",
+                },
+            },
+            {
+                id: "tool_call_1",
+                type: "function",
+                function: {
+                    name: "tool1",
+                    arguments: "arg1",
+                },
+            },
+        ],
+        content: "AgentMessage2",
+    };
+    cm.processAgentResponse(agentResponseWithToolCall);
+    // Meanwhile, a new user message comes in.  It is assigned idx
+    // startIdx + 3*MESSAGE_INDEX_FULL_INCREMENT.
+    const serverUserMessage3 = cm.processUserMessage({
+        type: "msg",
+        message: "UserMessage3",
+    }, "user3");
+    (0, vitest_1.expect)(serverUserMessage3).eql({
+        type: "user_msg",
+        session_id: "some_session_id",
+        user_uuid: "user3",
+        message_idx: startIdx + 3 * conversation_1.MESSAGE_INDEX_FULL_INCREMENT,
+        message: "UserMessage3",
+    });
+    // Tool call results arrive.  They should have indices:
+    // - 2*MESSAGE_INDEX_FULL_INCREMENT + 1*MESSAGE_INDEX_SUB_INCREMENT
+    // - 2*MESSAGE_INDEX_FULL_INCREMENT + 2*MESSAGE_INDEX_SUB_INCREMENT
+    const toolCallResults = [
+        {
+            role: "tool",
+            tool_call_id: "tool_call_0",
+            content: "tool_response_0",
+        },
+        {
+            role: "tool",
+            tool_call_id: "tool_call_1",
+            content: "tool_response_1",
+        },
+    ];
+    const toolCallMesasge0 = cm.processToolCallResult(toolCallResults[0]);
+    (0, vitest_1.expect)(toolCallMesasge0.message_idx).eql(startIdx +
+        2 * conversation_1.MESSAGE_INDEX_FULL_INCREMENT +
+        1 * conversation_1.MESSAGE_INDEX_SUB_INCREMENT);
+    const toolCallMesasge1 = cm.processToolCallResult(toolCallResults[1]);
+    (0, vitest_1.expect)(toolCallMesasge1.message_idx).eql(startIdx +
+        2 * conversation_1.MESSAGE_INDEX_FULL_INCREMENT +
+        2 * conversation_1.MESSAGE_INDEX_SUB_INCREMENT);
+    // Final agent response
+    const finalAgentResponse = {
+        role: "assistant",
+        content: "AgentMessage2",
+    };
+    // The agent adds the messages to the context at the end of processing
+    cm.addMessages(llmUserMessages);
+    cm.addMessage(agentResponseWithToolCall);
+    cm.addMessage(toolCallResults[0]);
+    cm.addMessage(toolCallResults[1]);
+    cm.addMessage(finalAgentResponse);
+    // Agent then returns the final response to the caller (OpenSession)
+    cm.processAgentResponse(finalAgentResponse);
+    const dbMessages = cm.endAgentResponse();
+    // Expect
+    const expectDbMessages = [
+        {
+            message_idx: startIdx + 0,
+            sender_uuid: "user0",
+            is_for_llm: true,
+            content: (0, agent_1.createUserMessageEnsure)(userMsgs[0].message, userMsgs[0].imageB64, "user0"),
+        },
+        {
+            message_idx: startIdx + conversation_1.MESSAGE_INDEX_FULL_INCREMENT,
+            sender_uuid: "user1",
+            is_for_llm: true,
+            content: (0, agent_1.createUserMessageEnsure)(userMsgs[1].message, userMsgs[1].imageB64, "user1"),
+        },
+        // agent response with tool calls
+        {
+            message_idx: startIdx + conversation_1.MESSAGE_INDEX_FULL_INCREMENT * 2,
+            is_for_llm: true,
+            content: agentResponseWithToolCall,
+        },
+        // 2 tool results
+        {
+            message_idx: startIdx +
+                2 * conversation_1.MESSAGE_INDEX_FULL_INCREMENT +
+                conversation_1.MESSAGE_INDEX_SUB_INCREMENT,
+            is_for_llm: true,
+            content: toolCallResults[0],
+        },
+        {
+            message_idx: startIdx +
+                2 * conversation_1.MESSAGE_INDEX_FULL_INCREMENT +
+                2 * conversation_1.MESSAGE_INDEX_SUB_INCREMENT,
+            is_for_llm: true,
+            content: toolCallResults[1],
+        },
+        // Final agent message
+        {
+            message_idx: startIdx +
+                2 * conversation_1.MESSAGE_INDEX_FULL_INCREMENT +
+                3 * conversation_1.MESSAGE_INDEX_SUB_INCREMENT,
+            is_for_llm: true,
+            content: finalAgentResponse,
+        },
+    ];
+    (0, vitest_1.expect)(dbMessages).eql(expectDbMessages);
+}
+describe("IndexingCompressingContextManager", () => {
+    // TODO: move to contextCompression.test.ts
+    it("restoring with checkpoint", function () {
+        // Checkpoint with index 50 (smaller than all)
+        const checkpoint50 = {
+            message_idx: 50,
+            summary: "SUMMARY_50",
+        };
+        const resolved50 = (0, chatContextManager_1.resolveConversationWithCheckpoint)(MESSAGES, checkpoint50);
+        (0, vitest_1.expect)(resolved50).eql({
+            messages: [
+                (0, compressingContextManager_1.createCheckpointMessage)(checkpoint50.summary),
+                ...MESSAGES.map((msg) => msg.content),
+            ],
+            lastEntryIdx: 502,
+        });
+        // Checkpoint with index 300 (in the middle)
+        const checkpoint300 = {
+            message_idx: 300,
+            summary: "SUMMARY_300",
+        };
+        const resolved300 = (0, chatContextManager_1.resolveConversationWithCheckpoint)(MESSAGES, checkpoint300);
+        (0, vitest_1.expect)(resolved300).eql({
+            messages: [
+                (0, compressingContextManager_1.createCheckpointMessage)(checkpoint300.summary),
+                // Messages after 300: 400, 500, 501, 502
+                MESSAGES[2].content, // msg400
+                MESSAGES[3].content, // msg500 (with tool_calls)
+                MESSAGES[4].content, // msg501 (tool result)
+                MESSAGES[5].content, // msg502
+            ],
+            lastEntryIdx: 502,
+        });
+        // Checkpoint with index 502 (at the end)
+        const checkpoint502 = {
+            message_idx: 502,
+            summary: "SUMMARY_502",
+        };
+        const resolved502 = (0, chatContextManager_1.resolveConversationWithCheckpoint)(MESSAGES, checkpoint502);
+        (0, vitest_1.expect)(resolved502).eql({
+            messages: [
+                (0, compressingContextManager_1.createCheckpointMessage)(checkpoint502.summary),
+                // No messages after 502
+            ],
+            lastEntryIdx: 502,
+        });
+        // Checkpoint with index 600 (greater than all messages)
+        const checkpoint600 = {
+            message_idx: 600,
+            summary: "SUMMARY_600",
+        };
+        const resolved600 = (0, chatContextManager_1.resolveConversationWithCheckpoint)(MESSAGES, checkpoint600);
+        (0, vitest_1.expect)(resolved600).eql({
+            messages: [
+                (0, compressingContextManager_1.createCheckpointMessage)(checkpoint600.summary),
+                // No messages after 600 (checkpoint covers all messages)
+            ],
+            lastEntryIdx: 600, // Should be max(502, 600) = 600
+        });
+    });
+    it("conversation processing behaviour", () => {
+        const writer = {
+            writeCheckpoint: (_sc) => {
+                return new Promise((r) => {
+                    r();
+                });
+            },
+        };
+        const cm = new chatContextManager_1.ChatContextManager("sys_prompt", [], "some_session_id", "no_such_user", undefined, "", "", "", writer, new sessionFileManager_1.MemoryFileManager());
+        testSuccessfulAgentLoop(cm, 0);
+    });
+    it("error handling", () => {
+        const writer = {
+            writeCheckpoint: (_sc) => {
+                return new Promise((r) => {
+                    r();
+                });
+            },
+        };
+        const cm = new chatContextManager_1.ChatContextManager("sys_prompt", [], "some_session_id", "no_such_user", undefined, "", "", "", writer, new sessionFileManager_1.MemoryFileManager());
+        //  1 user messages
+        const serverUserMessage0 = cm.processUserMessage({ type: "msg", message: "UserMessage0" }, "user0");
+        (0, vitest_1.expect)(serverUserMessage0).eql({
+            type: "user_msg",
+            session_id: "some_session_id",
+            user_uuid: "user0",
+            message_idx: 0 * conversation_1.MESSAGE_INDEX_FULL_INCREMENT,
+            message: "UserMessage0",
+        });
+        // Begin processing an agent response.
+        //
+        // Agent response has a tool call.  It is assigned 1 *
+        // MESSAGE_INDEX_FULL_INCREMENT
+        const { llmUserMessages, agentFirstChunk } = cm.startAgentResponse([
+            serverUserMessage0,
+        ]);
+        (0, vitest_1.expect)(agentFirstChunk.message_idx).eql(1 * conversation_1.MESSAGE_INDEX_FULL_INCREMENT);
+        (0, vitest_1.expect)(llmUserMessages).eql([
+            {
+                role: "user",
+                name: serverUserMessage0.user_uuid,
+                content: serverUserMessage0.message,
+            },
+        ]);
+        // A full response (with toolcall) is returned
+        const agentResponseWithToolCall = {
+            role: "assistant",
+            tool_calls: [
+                {
+                    id: "tool_call_0",
+                    type: "function",
+                    function: {
+                        name: "tool0",
+                        arguments: "",
+                    },
+                },
+                {
+                    id: "tool_call_1",
+                    type: "function",
+                    function: {
+                        name: "tool1",
+                        arguments: "arg1",
+                    },
+                },
+            ],
+            content: "AgentMessage2",
+        };
+        cm.processAgentResponse(agentResponseWithToolCall);
+        // The current Agent does not add the tool call results until the next
+        // completion has run.  Here we are simulating an error during that
+        // process, but the Agent still sends the tool call results to the event
+        // handler, which passes them in here.
+        // Tool call results arrive.  They should have indices:
+        // - 1*MESSAGE_INDEX_FULL_INCREMENT + 1*MESSAGE_INDEX_SUB_INCREMENT
+        // - 1*MESSAGE_INDEX_FULL_INCREMENT + 2*MESSAGE_INDEX_SUB_INCREMENT
+        const toolCallResults = [
+            {
+                role: "tool",
+                tool_call_id: "tool_call_0",
+                content: "tool_response_0",
+            },
+            {
+                role: "tool",
+                tool_call_id: "tool_call_1",
+                content: "tool_response_1",
+            },
+        ];
+        const toolCallMesasge0 = cm.processToolCallResult(toolCallResults[0]);
+        (0, vitest_1.expect)(toolCallMesasge0.message_idx).eql(1 * conversation_1.MESSAGE_INDEX_FULL_INCREMENT + 1 * conversation_1.MESSAGE_INDEX_SUB_INCREMENT);
+        const toolCallMesasge1 = cm.processToolCallResult(toolCallResults[1]);
+        (0, vitest_1.expect)(toolCallMesasge1.message_idx).eql(1 * conversation_1.MESSAGE_INDEX_FULL_INCREMENT + 2 * conversation_1.MESSAGE_INDEX_SUB_INCREMENT);
+        // The error is caught by OpenSession, which informs the
+        // ChatContextManager.
+        cm.revertAgentResponse("an error occured");
+        // We should now be able to run the original test (starting from index
+        // 2*MESSAGE_INDEX_FULL_INCREMENT).  None of our previous messages should
+        // hit the DB or the LLM context.
+        testSuccessfulAgentLoop(cm, 2 * conversation_1.MESSAGE_INDEX_FULL_INCREMENT);
+    });
+});

package/dist/agent/src/test/clientServerConnection.test.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const connection_1 = require("../chat/client/connection");
+const server_1 = require("../chat/server/server");
+const database_1 = require("../chat/data/database");
+const sdk_1 = require("@xalia/xmcp/sdk");
+const database_2 = require("../chat/data/database");
+const sessionRegistry_1 = require("../chat/server/sessionRegistry");
+// Mock uuid to have predictable client message IDs
+vitest_1.vi.mock("uuid", () => ({
+    v4: () => "mock-uuid-123",
+}));
+const logger = (0, sdk_1.getLogger)();
+(0, vitest_1.describe)("Client-Server WebSocket Integration", () => {
+    let server;
+    let db;
+    const serverPort = 5105; // Different port to avoid conflicts
+    // Test API key data
+    const testApiKey = "integration_test";
+    const testUserUuid = "test_user_0";
+    const testUserName = "default";
+    const testScopes = [];
+    // Mock environment variables for server
+    const mockEnv = {
+        SUPABASE_URL: database_2.SUPABASE_LOCAL_URL,
+        SUPABASE_KEY: database_2.SUPABASE_LOCAL_KEY,
+        LLM_URL: "http://localhost:8080", // not used in this test
+        XMCP_URL: "http://localhost:8081", // not used in this test
+    };
+    (0, vitest_1.beforeAll)(async () => {
+        // Set up environment variables
+        Object.assign(process.env, mockEnv);
+        // Initialize database connection
+        db = new database_1.Database(mockEnv.SUPABASE_URL, mockEnv.SUPABASE_KEY);
+        // Try to insert test data, but don't fail if there are database issues
+        try {
+            await cleanupTestData();
+            await insertTestApiKey();
+            logger.info("[Test] Test data setup completed successfully");
+        }
+        catch (error) {
+            logger.warn("[Test] Test data setup failed - will test with existing data:", error);
+        }
+        // Start the real server using runServer
+        server = await (0, server_1.runServer)(serverPort, mockEnv.SUPABASE_URL, mockEnv.SUPABASE_KEY, mockEnv.LLM_URL, mockEnv.XMCP_URL);
+        // Wait for server to be ready
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    });
+    async function cleanupTestData() {
+        try {
+            // Delete test API key first (foreign key constraint)
+            await db
+                .getClientForTesting()
+                .from("api_keys")
+                .delete()
+                .eq("api_key", testApiKey);
+            // Delete test user
+            await db
+                .getClientForTesting()
+                .from("users")
+                .delete()
+                .eq("uuid", testUserUuid);
+            logger.info("[Test] Cleaned up existing test data");
+        }
+        catch (error) {
+            logger.warn("[Test] Error during cleanup (expected if no data exists):", error);
+        }
+    }
+    async function insertTestApiKey() {
+        try {
+            // Use Database class methods which include timezone handling
+            await db.createUser(testUserUuid, "test@example.com", testUserName, "UTC");
+            logger.info("[Test] User created successfully");
+            await db.addApiKey(testUserUuid, testApiKey, testUserName, testScopes, true // is_default
+            );
+        }
+        catch (error) {
+            logger.error("[Test] Database method insert failed:", error);
+            throw error;
+        }
+    }
+    (0, vitest_1.afterAll)(async () => {
+        // Clean up test data
+        await cleanupTestData();
+        // Close server
+        server.close();
+    });
+    (0, vitest_1.describe)("Connection Setup and List Sessions", () => {
+        (0, vitest_1.it)("should establish connection with valid API key", async () => {
+            // Inject test agent profiles and sessions into the database
+            const agentProfile1 = await db.createAgentProfile(testUserUuid, undefined, "Test agent profile 1", {
+                model: undefined,
+                system_prompt: "You are a test agent",
+                mcp_settings: {},
+            });
+            const agentProfile2 = await db.createAgentProfile(testUserUuid, undefined, "Test agent profile 2", {
+                model: undefined,
+                system_prompt: "You are a test agent",
+                mcp_settings: {},
+            });
+            if (!agentProfile1 || !agentProfile2) {
+                throw new Error("Failed to create agent profiles");
+            }
+            const agentProfile1Id = agentProfile1.uuid;
+            const agentProfile2Id = agentProfile2.uuid;
+            const session1CreateData = (0, sessionRegistry_1.userSessionDataCreate)(testUserUuid, "Test Session 1", agentProfile1Id);
+            const session1Id = session1CreateData.session_uuid;
+            await db.sessionCreate(session1CreateData);
+            const session2CreateData = (0, sessionRegistry_1.userSessionDataCreate)(testUserUuid, "Test Session 2", agentProfile2Id);
+            const session2Id = session2CreateData.session_uuid;
+            await db.sessionCreate(session2CreateData);
+            // Log session creation for debugging
+            logger.info(`[Test] Created sessions: ${session1Id}, ${session2Id}`);
+            const client = new connection_1.Connection({
+                url: `ws://localhost:${String(serverPort)}`,
+                token: testApiKey,
+            });
+            // Wait for session_list response
+            const responsePromise = new Promise((resolve) => {
+                client.on("control_session_list", (msg) => {
+                    resolve(msg);
+                });
+            });
+            await client.connect();
+            (0, vitest_1.expect)(client.getState()).toBe("ready");
+            client.send({
+                type: "control_get_session_list",
+                client_message_id: "test-msg-id",
+            });
+            const response = await responsePromise;
+            (0, vitest_1.expect)(response.type).toBe("control_session_list");
+            (0, vitest_1.expect)(response.user_sessions).toBeDefined();
+            (0, vitest_1.expect)(response.user_sessions.length).toBe(2);
+            // Verify session details
+            const sessionIds = response.user_sessions.map((s) => s.session_uuid);
+            (0, vitest_1.expect)(sessionIds).toContain(session1Id);
+            (0, vitest_1.expect)(sessionIds).toContain(session2Id);
+            const session1Data = response.user_sessions.find((s) => s.session_uuid === session1Id);
+            (0, vitest_1.expect)(session1Data?.title).toBe("Test Session 1");
+            const session2Data = response.user_sessions.find((s) => s.session_uuid === session2Id);
+            (0, vitest_1.expect)(session2Data?.title).toBe("Test Session 2");
+            client.close();
+        }, 15000);
+    });
+    (0, vitest_1.describe)("Authentication Error Handling", () => {
+        (0, vitest_1.it)("should handle invalid API key gracefully", async () => {
+            const invalidApiKey = "invalid-test-key";
+            const client = new connection_1.Connection({
+                url: `ws://localhost:${String(serverPort)}`,
+                token: invalidApiKey,
+            });
+            await (0, vitest_1.expect)(client.connect()).rejects.toThrow();
+            (0, vitest_1.expect)(client.getState()).toBe("closed");
+            client.close();
+        }, 4000);
+    });
+});

package/dist/agent/src/test/compressingContextManager.test.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const compressingContextManager_1 = require("../agent/compressingContextManager");
+const MESSAGES = [
+    { role: "user", content: "msg200" },
+    { role: "assistant", content: "msg300" },
+    { role: "user", content: "msg400" },
+    {
+        role: "assistant",
+        content: "msg500",
+        tool_calls: [
+            {
+                id: "tool_call_0",
+                type: "function",
+                function: { name: "tool1", arguments: "" },
+            },
+        ],
+    },
+    {
+        role: "tool",
+        content: "msg501",
+        tool_call_id: "tool_call_0",
+    },
+    { role: "assistant", content: "msg502" },
+];
+describe("Compression context", () => {
+    it("context compression", async function () {
+        const ccm = new compressingContextManager_1.CompressingContextManager("sys_prompt", [], "", // llmUrl
+        "repeat", // llmModel
+        "" // llmApiKey
+        );
+        // Add first 2 messages
+        ccm.addMessages(MESSAGES.slice(0, 2));
+        ccm.commit();
+        // Start the compression
+        const compressionP = ccm.compress();
+        // Add more messages and update system prompt
+        ccm.addMessages(MESSAGES.slice(2));
+        ccm.setAgentPrompt("New system prompt");
+        // Wait for compression to complete, then get the new context
+        const summary = await compressionP;
+        const context = ccm.getLLMContext();
+        // Expect
+        //   - callback happened
+        //   - new context is as expected
+        const expectSummary = "Message number 0";
+        const expectContext = [
+            {
+                role: "system",
+                content: "New system prompt",
+            },
+            (0, compressingContextManager_1.createCheckpointMessage)(expectSummary),
+            MESSAGES[2], // 400
+            MESSAGES[3], // 500
+            MESSAGES[4], // 501
+            MESSAGES[5], // 502
+        ];
+        (0, vitest_1.expect)(summary).eql(expectSummary);
+        (0, vitest_1.expect)(context).eql(expectContext);
+        // Pending messages shoudl still be intact
+        const pending = ccm.getPending();
+        (0, vitest_1.expect)(pending).eql(MESSAGES.slice(2));
+    });
+});