@moltzap/client 2026.503.3 → 2026.504.0

package/dist/service.test.js

@@ -2,61 +2,69 @@ import * as path from "node:path";
 import * as os from "node:os";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { Effect, Either } from "effect";
-import { AppsAuthorizeDispatch, ConversationsGet, ErrorCodes, EventNames, MessagesSend, eventFrame, } from "@moltzap/protocol";
+import { AppsAuthorizeDispatch, ConversationsGet, ErrorCodes, ConversationArchivedNotificationDefinition, ConversationCreatedNotificationDefinition, ConversationUnarchivedNotificationDefinition, MessageReceivedNotificationDefinition, MessagesSend, notificationFrame, } from "@moltzap/protocol";
 import { sanitizeForSystemReminder } from "./service.js";
 import { FakeMoltZapService } from "./test-utils/fake-service.js";
+import { buildMessage, testAgentId, testConversationId, testMessageId, } from "./test-utils/index.js";
+import { AgentsLookupByName, ConversationsCreate } from "@moltzap/protocol";
 /** Run a service Effect to a Promise for test assertions. */
 const run = (e) => Effect.runPromise(e);
+const AGENT_ALICE_ID = testAgentId("agent-alice-id");
+const AGENT_SELF_ID = testAgentId("agent-self");
+const AGENT_GM_ID = testAgentId("agent-gm");
+const CONVERSATION_ALICE_ID = testConversationId("conv-alice");
+const CONVERSATION_ARCHIVED_ID = testConversationId("conv-archived");
+const DISPATCH_MESSAGE_ID = testMessageId("msg-dispatch");
 describe("MoltZapService.sendToAgent", () => {
     let service;
     beforeEach(() => {
         service = new FakeMoltZapService();
         // `setResponse` is typed: the wire name must be a `RpcMethodName` literal
-        // and the value must match `RpcMap[M]["result"]`. Both guard against the
+        // and the value must match `RpcResult<M>`. Both guard against the
         // contract-drift bug (A7) that motivated this fake.
-        service.setResponse("agents/lookupByName", {
+        service.setResponse(AgentsLookupByName, {
             agents: [
                 {
-                    id: "agent-alice-id",
+                    id: AGENT_ALICE_ID,
                     name: "alice",
                     status: "active",
                 },
             ],
         });
-        service.setResponse("conversations/create", {
+        service.setResponse(ConversationsCreate, {
             conversation: {
-                id: "conv-alice",
+                id: CONVERSATION_ALICE_ID,
                 type: "dm",
-                createdBy: "agent-self",
+                createdBy: AGENT_SELF_ID,
                 createdAt: "2026-04-16T00:00:00Z",
                 updatedAt: "2026-04-16T00:00:00Z",
             },
         });
-        service.setResponse("messages/send", {
-            message: {
+        service.setResponse(MessagesSend, {
+            message: buildMessage({
                 id: "msg-1",
                 conversationId: "conv-alice",
                 senderId: "agent-self",
                 parts: [{ type: "text", text: "placeholder" }],
                 createdAt: "2026-04-16T00:00:00Z",
-            },
+            }),
         });
     });
     it("resolves agent name, creates a DM, and sends the message on first call", async () => {
         await run(service.sendToAgent("alice", "hello"));
         expect(service.calls).toEqual([
-            { method: "agents/lookupByName", params: { names: ["alice"] } },
+            { method: AgentsLookupByName.name, params: { names: ["alice"] } },
             {
-                method: "conversations/create",
+                method: ConversationsCreate.name,
                 params: {
                     type: "dm",
-                    participants: [{ type: "agent", id: "agent-alice-id" }],
+                    participants: [{ type: "agent", id: AGENT_ALICE_ID }],
                 },
             },
             {
-                method: "messages/send",
+                method: MessagesSend.name,
                 params: {
-                    conversationId: "conv-alice",
+                    conversationId: CONVERSATION_ALICE_ID,
                     parts: [{ type: "text", text: "hello" }],
                 },
             },
@@ -68,36 +76,39 @@ describe("MoltZapService.sendToAgent", () => {
         await run(service.sendToAgent("alice", "second"));
         expect(service.calls).toEqual([
             {
-                method: "messages/send",
+                method: MessagesSend.name,
                 params: {
-                    conversationId: "conv-alice",
+                    conversationId: CONVERSATION_ALICE_ID,
                     parts: [{ type: "text", text: "second" }],
                 },
             },
         ]);
     });
     it("forwards replyTo to messages/send as replyToId", async () => {
-        await run(service.sendToAgent("alice", "reply text", { replyTo: "msg-123" }));
-        const sendCall = service.calls.find((c) => c.method === "messages/send");
+        const replyToId = testMessageId("msg-123");
+        await run(service.sendToAgent("alice", "reply text", { replyTo: replyToId }));
+        const sendCall = service.calls.find((c) => c.method === MessagesSend.name);
         expect(sendCall?.params).toEqual({
-            conversationId: "conv-alice",
+            conversationId: CONVERSATION_ALICE_ID,
             parts: [{ type: "text", text: "reply text" }],
-            replyToId: "msg-123",
+            replyToId,
         });
     });
     it("maintains separate cache entries per agent name", async () => {
-        service.setResponse("agents/lookupByName", {
-            agents: [{ id: "agent-alice-id", name: "alice", status: "active" }],
+        service.setResponse(AgentsLookupByName, {
+            agents: [{ id: AGENT_ALICE_ID, name: "alice", status: "active" }],
         });
         await run(service.sendToAgent("alice", "hello alice"));
-        service.setResponse("agents/lookupByName", {
-            agents: [{ id: "agent-bob-id", name: "bob", status: "active" }],
+        service.setResponse(AgentsLookupByName, {
+            agents: [
+                { id: testAgentId("agent-bob-id"), name: "bob", status: "active" },
+            ],
         });
-        service.setResponse("conversations/create", {
+        service.setResponse(ConversationsCreate, {
             conversation: {
-                id: "conv-bob",
+                id: testConversationId("conv-bob"),
                 type: "dm",
-                createdBy: "agent-self",
+                createdBy: AGENT_SELF_ID,
                 createdAt: "2026-04-16T00:00:00Z",
                 updatedAt: "2026-04-16T00:00:00Z",
             },
@@ -106,25 +117,25 @@ describe("MoltZapService.sendToAgent", () => {
         service.calls = [];
         await run(service.sendToAgent("alice", "alice again"));
         await run(service.sendToAgent("bob", "bob again"));
-        const sendCalls = service.calls.filter((c) => c.method === "messages/send");
+        const sendCalls = service.calls.filter((c) => c.method === MessagesSend.name);
         expect(sendCalls).toHaveLength(2);
-        expect(sendCalls[0].params.conversationId).toBe("conv-alice");
-        expect(sendCalls[1].params.conversationId).toBe("conv-bob");
+        expect(sendCalls[0].params.conversationId).toBe(CONVERSATION_ALICE_ID);
+        expect(sendCalls[1].params.conversationId).toBe(testConversationId("conv-bob"));
     });
     it("throws a clear error when no agent is found for the given name", async () => {
-        service.setResponse("agents/lookupByName", { agents: [] });
+        service.setResponse(AgentsLookupByName, { agents: [] });
         await expect(run(service.sendToAgent("nobody", "hi"))).rejects.toThrow(/Agent not found: nobody/);
     });
     it("propagates errors from agents/lookupByName", async () => {
-        service.deleteResponse("agents/lookupByName");
+        service.deleteResponse(AgentsLookupByName);
         await expect(run(service.sendToAgent("alice", "hi"))).rejects.toThrow(/no canned response for agents\/lookupByName/);
     });
     it("propagates errors from conversations/create", async () => {
-        service.deleteResponse("conversations/create");
+        service.deleteResponse(ConversationsCreate);
         await expect(run(service.sendToAgent("alice", "hi"))).rejects.toThrow(/no canned response for conversations\/create/);
     });
     it("propagates errors from messages/send", async () => {
-        service.deleteResponse("messages/send");
+        service.deleteResponse(MessagesSend);
         await expect(run(service.sendToAgent("alice", "hi"))).rejects.toThrow(/no canned response for messages\/send/);
     });
 });
@@ -154,7 +165,7 @@ describe("sanitizeForSystemReminder", () => {
 describe("MoltZapService.authorizeDispatch", () => {
     it("uses the long app-dispatch RPC timeout instead of the generic RPC timeout", async () => {
         const service = new FakeMoltZapService();
-        service.setResponse(AppsAuthorizeDispatch.name, {
+        service.setResponse(AppsAuthorizeDispatch, {
             admission: {
                 decision: "grant",
                 leaseId: "lease-1",
@@ -162,23 +173,23 @@ describe("MoltZapService.authorizeDispatch", () => {
             },
         });
         const result = await run(service.authorizeDispatch({
-            conversationId: "conv-1",
-            senderAgentId: "agent-gm",
+            conversationId: CONVERSATION_ALICE_ID,
+            senderAgentId: AGENT_GM_ID,
             attempt: 0,
             receivedAt: "2026-04-29T22:00:00.000Z",
             clock: {
-                domainId: "conv-1",
+                domainId: CONVERSATION_ALICE_ID,
                 epoch: 1,
-                vector: { "agent-gm": 1 },
+                vector: { [AGENT_GM_ID]: 1 },
             },
             pending: [],
-            message: {
-                id: "msg-1",
-                conversationId: "conv-1",
-                senderId: "agent-gm",
+            message: buildMessage({
+                id: DISPATCH_MESSAGE_ID,
+                conversationId: CONVERSATION_ALICE_ID,
+                senderId: AGENT_GM_ID,
                 parts: [{ type: "text", text: "Time to vote!" }],
                 createdAt: "2026-04-29T22:00:00.000Z",
-            },
+            }),
         }));
         expect(result).toEqual({
             _tag: "grant",
@@ -195,14 +206,14 @@ describe("MoltZapService.authorizeDispatch", () => {
 describe("MoltZapService.getContext — XML injection hardening", () => {
     /** Build a message that lands in `messages` via addMessage(). */
     function msg(overrides) {
-        return {
-            id: overrides.id ?? "msg-1",
-            conversationId: overrides.conversationId ?? "conv-other",
-            senderId: overrides.senderId ?? "agent-attacker",
-            parts: overrides.parts ?? [{ type: "text", text: "hello" }],
-            createdAt: overrides.createdAt ?? new Date().toISOString(),
+        return buildMessage({
+            id: "msg-1",
+            conversationId: "conv-other",
+            senderId: "agent-attacker",
+            parts: [{ type: "text", text: "hello" }],
+            createdAt: new Date().toISOString(),
             ...overrides,
-        };
+        });
     }
     it("escapes senderName with </system-reminder> injection attempt", () => {
         const service = new FakeMoltZapService();
@@ -274,13 +285,13 @@ describe("MoltZapService.getContext — XML injection hardening", () => {
 });
 describe("MoltZapService.peekContextEntries", () => {
     function addSimpleMessage(service, convId, seq, text = "hi") {
-        service.addMessage(convId, {
+        service.addMessage(convId, buildMessage({
             id: `m-${seq}`,
             conversationId: convId,
             senderId: "agent-bob",
             parts: [{ type: "text", text }],
             createdAt: new Date().toISOString(),
-        });
+        }));
     }
     it("returns structured entries without advancing markers", () => {
         const service = new FakeMoltZapService();
@@ -369,68 +380,68 @@ describe("MoltZapService.peekFullMessages", () => {
         const service = new FakeMoltZapService();
         service.setAgentNameDirect("agent-bob", "Bob");
         service.setAgentNameDirect("agent-alice", "Alice");
-        service.addMessage("conv-a", {
+        service.addMessage("conv-a", buildMessage({
             id: "m-1",
             conversationId: "conv-a",
             senderId: "agent-bob",
             parts: [{ type: "text", text: "first" }],
             createdAt: "2026-04-13T22:00:00Z",
-        });
-        service.addMessage("conv-b", {
+        }));
+        service.addMessage("conv-b", buildMessage({
             id: "m-2",
             conversationId: "conv-b",
             senderId: "agent-alice",
             parts: [{ type: "text", text: "second" }],
             createdAt: "2026-04-13T22:00:01Z",
-        });
-        service.addMessage("conv-a", {
+        }));
+        service.addMessage("conv-a", buildMessage({
             id: "m-3",
             conversationId: "conv-a",
             senderId: "agent-bob",
             parts: [{ type: "text", text: "third" }],
             createdAt: "2026-04-13T22:00:02Z",
-        });
+        }));
         const { messages } = service.peekFullMessages("conv-self");
         expect(messages).toHaveLength(3);
         expect(messages.map((m) => m.text)).toEqual(["first", "second", "third"]);
         expect(messages[0].conversationId).toBe("conv-a");
         expect(messages[0].senderName).toBe("Bob");
-        expect(messages[0].senderId).toBe("agent-bob");
+        expect(messages[0].senderId).toBe(testAgentId("agent-bob"));
         expect(messages[1].conversationId).toBe("conv-b");
         expect(messages[1].senderName).toBe("Alice");
-        expect(messages[1].senderId).toBe("agent-alice");
+        expect(messages[1].senderId).toBe(testAgentId("agent-alice"));
     });
     it("excludes messages from the current conversation", () => {
         const service = new FakeMoltZapService();
-        service.addMessage("conv-self", {
+        service.addMessage("conv-self", buildMessage({
             id: "m-1",
             conversationId: "conv-self",
             senderId: "agent-bob",
             parts: [{ type: "text", text: "own conv" }],
             createdAt: "2026-04-13T22:00:00Z",
-        });
+        }));
         const { messages } = service.peekFullMessages("conv-self");
         expect(messages).toHaveLength(0);
     });
     it("commit advances markers; subsequent peek returns only new messages", () => {
         const service = new FakeMoltZapService();
-        service.addMessage("conv-a", {
+        service.addMessage("conv-a", buildMessage({
             id: "m-1",
             conversationId: "conv-a",
             senderId: "agent-bob",
             parts: [{ type: "text", text: "old" }],
             createdAt: "2026-04-13T22:00:00Z",
-        });
+        }));
         const first = service.peekFullMessages("conv-self");
         first.commit();
         expect(first.messages).toHaveLength(1);
-        service.addMessage("conv-a", {
+        service.addMessage("conv-a", buildMessage({
             id: "m-2",
             conversationId: "conv-a",
             senderId: "agent-bob",
             parts: [{ type: "text", text: "new" }],
             createdAt: "2026-04-13T22:01:00Z",
-        });
+        }));
         const second = service.peekFullMessages("conv-self");
         expect(second.messages).toHaveLength(1);
         expect(second.messages[0].text).toBe("new");
@@ -439,14 +450,13 @@ describe("MoltZapService.peekFullMessages", () => {
         const service = new FakeMoltZapService();
         for (let c = 0; c < 10; c++) {
             for (let m = 0; m < 5; m++) {
-                service.addMessage(`conv-${c}`, {
+                service.addMessage(`conv-${c}`, buildMessage({
                     id: `m-${c}-${m}`,
                     conversationId: `conv-${c}`,
                     senderId: "agent-bob",
-                    seq: m + 1,
                     parts: [{ type: "text", text: `c${c}-m${m}` }],
                     createdAt: new Date(Date.now() + c * 10000 + m * 1000).toISOString(),
-                });
+                }));
             }
         }
         const { messages } = service.peekFullMessages("conv-self");
@@ -454,13 +464,13 @@ describe("MoltZapService.peekFullMessages", () => {
     });
     it("peek without commit is idempotent", () => {
         const service = new FakeMoltZapService();
-        service.addMessage("conv-a", {
+        service.addMessage("conv-a", buildMessage({
             id: "m-1",
             conversationId: "conv-a",
             senderId: "agent-bob",
             parts: [{ type: "text", text: "hi" }],
             createdAt: "2026-04-13T22:00:00Z",
-        });
+        }));
         const a = service.peekFullMessages("conv-self").messages;
         const b = service.peekFullMessages("conv-self").messages;
         expect(a).toHaveLength(1);
@@ -468,128 +478,86 @@ describe("MoltZapService.peekFullMessages", () => {
     });
     it("commit for one viewing conv does not affect another", () => {
         const service = new FakeMoltZapService();
-        service.addMessage("conv-a", {
+        service.addMessage("conv-a", buildMessage({
             id: "m-1",
             conversationId: "conv-a",
             senderId: "agent-bob",
             parts: [{ type: "text", text: "hi" }],
             createdAt: "2026-04-13T22:00:00Z",
-        });
+        }));
         service.peekFullMessages("viewer-1").commit();
         expect(service.peekFullMessages("viewer-2").messages).toHaveLength(1);
     });
     it("stores more than 20 messages per conversation without eviction", () => {
         const service = new FakeMoltZapService();
         for (let i = 1; i <= 30; i++) {
-            service.addMessage("conv-a", {
+            service.addMessage("conv-a", buildMessage({
                 id: `m-${i}`,
                 conversationId: "conv-a",
                 senderId: "agent-bob",
-                seq: i,
                 parts: [{ type: "text", text: `msg-${i}` }],
                 createdAt: new Date(Date.now() + i * 1000).toISOString(),
-            });
+            }));
         }
         const { messages } = service.peekFullMessages("conv-self");
         expect(messages).toHaveLength(30);
     });
 });
-describe("MoltZapService.on('permissionRequired')", () => {
-    it("fires handler when permissions/required event arrives", () => {
-        const service = new FakeMoltZapService();
-        const received = [];
-        service.on("permissionRequired", (data) => received.push(data));
-        const event = {
-            jsonrpc: "2.0",
-            type: "event",
-            event: EventNames.PermissionsRequired,
-            data: {
-                sessionId: "sess-1",
-                appId: "test-app",
-                resource: "contacts",
-                access: ["read"],
-                requestId: crypto.randomUUID(),
-                targetUserId: crypto.randomUUID(),
-            },
-        };
-        Reflect.get(service, "handleEvent").call(service, event);
-        expect(received).toHaveLength(1);
-        expect(received[0]).toMatchObject({
-            sessionId: "sess-1",
-            appId: "test-app",
-            resource: "contacts",
-            access: ["read"],
-        });
-    });
-    it("does not fire for unrelated events", () => {
-        const service = new FakeMoltZapService();
-        const received = [];
-        service.on("permissionRequired", (data) => received.push(data));
-        const event = {
-            jsonrpc: "2.0",
-            type: "event",
-            event: EventNames.PresenceChanged,
-            data: { agentId: "agent-1", status: "online" },
-        };
-        Reflect.get(service, "handleEvent").call(service, event);
-        expect(received).toHaveLength(0);
-    });
-});
 describe("MoltZapService conversation archive lifecycle", () => {
     it("purges local state, fires conversationArchived, and locally rejects sends", async () => {
         const service = new FakeMoltZapService();
-        service.setResponse(ConversationsGet.name, {
+        service.setResponse(ConversationsGet, {
             conversation: {
-                id: "conv-archived",
+                id: CONVERSATION_ARCHIVED_ID,
                 type: "group",
                 name: "Archived",
-                createdBy: "agent-self",
+                createdBy: AGENT_SELF_ID,
                 createdAt: "2026-05-01T00:00:00.000Z",
                 updatedAt: "2026-05-01T00:00:00.000Z",
             },
             participants: [],
         });
-        service.setResponse(MessagesSend.name, {
-            message: {
+        service.setResponse(MessagesSend, {
+            message: buildMessage({
                 id: "msg-unreachable",
                 conversationId: "conv-archived",
                 senderId: "agent-self",
                 parts: [{ type: "text", text: "unreachable" }],
                 createdAt: "2026-05-01T00:00:00.000Z",
-            },
+            }),
         });
-        service.emitEvent(eventFrame(EventNames.ConversationCreated, {
+        service.emitEvent(notificationFrame(ConversationCreatedNotificationDefinition, {
             conversation: {
-                id: "conv-archived",
+                id: CONVERSATION_ARCHIVED_ID,
                 type: "group",
                 name: "Archived",
-                createdBy: "agent-self",
+                createdBy: AGENT_SELF_ID,
                 createdAt: "2026-05-01T00:00:00.000Z",
                 updatedAt: "2026-05-01T00:00:00.000Z",
             },
         }));
-        service.addMessage("conv-archived", {
+        service.addMessage(CONVERSATION_ARCHIVED_ID, buildMessage({
             id: "msg-1",
             conversationId: "conv-archived",
             senderId: "agent-other",
             parts: [{ type: "text", text: "old" }],
             createdAt: "2026-05-01T00:00:00.000Z",
-        });
+        }));
         const archivedEvents = [];
         const unarchivedEvents = [];
         service.on("conversationArchived", (data) => archivedEvents.push(data));
         service.on("conversationUnarchived", (data) => unarchivedEvents.push(data));
-        const archivedEvent = eventFrame(EventNames.ConversationArchived, {
-            conversationId: "conv-archived",
+        const archivedEvent = notificationFrame(ConversationArchivedNotificationDefinition, {
+            conversationId: CONVERSATION_ARCHIVED_ID,
             archivedAt: "2026-05-01T00:01:00.000Z",
-            by: "agent-gm",
+            by: AGENT_GM_ID,
         });
         service.emitEvent(archivedEvent);
-        expect(service.isConversationArchived("conv-archived")).toBe(true);
-        expect(service.getConversation("conv-archived")).toBeUndefined();
-        expect(service.getHistory("conv-archived")).toEqual([]);
-        expect(archivedEvents).toEqual([archivedEvent.data]);
-        const lateSend = await run(Effect.either(service.send("conv-archived", "should not hit rpc")));
+        expect(service.isConversationArchived(CONVERSATION_ARCHIVED_ID)).toBe(true);
+        expect(service.getConversation(CONVERSATION_ARCHIVED_ID)).toBeUndefined();
+        expect(service.getHistory(CONVERSATION_ARCHIVED_ID)).toEqual([]);
+        expect(archivedEvents).toEqual([archivedEvent.params]);
+        const lateSend = await run(Effect.either(service.send(CONVERSATION_ARCHIVED_ID, "should not hit rpc")));
         expect(Either.isLeft(lateSend)).toBe(true);
         if (Either.isLeft(lateSend)) {
             expect(lateSend.left).toMatchObject({
@@ -598,34 +566,13 @@ describe("MoltZapService conversation archive lifecycle", () => {
             });
         }
         expect(service.calls.filter((c) => c.method === MessagesSend.name)).toEqual([]);
-        const unarchivedEvent = eventFrame(EventNames.ConversationUnarchived, {
-            conversationId: "conv-archived",
-            by: "agent-gm",
+        const unarchivedEvent = notificationFrame(ConversationUnarchivedNotificationDefinition, {
+            conversationId: CONVERSATION_ARCHIVED_ID,
+            by: AGENT_GM_ID,
         });
         service.emitEvent(unarchivedEvent);
-        expect(service.isConversationArchived("conv-archived")).toBe(false);
-        expect(unarchivedEvents).toEqual([unarchivedEvent.data]);
-    });
-});
-describe("MoltZapService.grantPermission", () => {
-    it("sends permissions/grant RPC", async () => {
-        const service = new FakeMoltZapService();
-        service.setResponse("permissions/grant", {});
-        await run(service.grantPermission({
-            sessionId: "sess-1",
-            agentId: "agent-2",
-            resource: "contacts",
-            access: ["read"],
-        }));
-        expect(service.calls).toContainEqual({
-            method: "permissions/grant",
-            params: {
-                sessionId: "sess-1",
-                agentId: "agent-2",
-                resource: "contacts",
-                access: ["read"],
-            },
-        });
+        expect(service.isConversationArchived(CONVERSATION_ARCHIVED_ID)).toBe(false);
+        expect(unarchivedEvents).toEqual([unarchivedEvent.params]);
     });
 });
 describe("MoltZapService.socketPath — agentId sanitization", () => {
@@ -725,22 +672,17 @@ describe("MoltZapService.fanout — message handlers", () => {
         service.on("message", (m) => {
             seen.push(m);
         });
-        const msg = {
+        const msg = buildMessage({
             id: "m-1",
             conversationId: "conv-1",
             senderId: "agent-other",
             parts: [{ type: "text", text: "hi" }],
             createdAt: "2026-04-16T00:00:00.000Z",
-        };
-        const event = {
-            jsonrpc: "2.0",
-            type: "event",
-            event: EventNames.MessageReceived,
-            data: { message: msg },
-        };
-        // handleEvent is private; reach into it the same way the existing
-        // permissions test does.
-        Reflect.get(service, "handleEvent").call(service, event);
+        });
+        const event = notificationFrame(MessageReceivedNotificationDefinition, {
+            message: msg,
+        });
+        service.emitEvent(event);
         // Second handler still fired despite first handler throwing.
         expect(seen).toEqual([msg]);
         expect(logger.error).toHaveBeenCalledOnce();