fix: keep node presence fresh

src/agents/clawdis-tools.sessions.test.ts

@@ -7,11 +7,7 @@ vi.mock("../gateway/call.js", () => ({
 
 vi.mock("../config/config.js", () => ({
   loadConfig: () => ({
-    session: {
-      mainKey: "main",
-      scope: "per-sender",
-      agentToAgent: { maxPingPongTurns: 2 },
-    },
+    session: { mainKey: "main", scope: "per-sender" },
   }),
   resolveGatewayPort: () => 18789,
 }));
@@ -131,28 +127,18 @@ describe("sessions tools", () => {
     let agentCallCount = 0;
     let _historyCallCount = 0;
     let sendCallCount = 0;
-    let lastWaitedRunId: string | undefined;
-    const replyByRunId = new Map<string, string>();
-    const requesterKey = "discord:group:req";
+    let waitRunId: string | undefined;
+    let nextHistoryIsWaitReply = false;
     callGatewayMock.mockImplementation(async (opts: unknown) => {
       const request = opts as { method?: string; params?: unknown };
       calls.push(request);
       if (request.method === "agent") {
         agentCallCount += 1;
         const runId = `run-${agentCallCount}`;
-        const params = request.params as
-          | { message?: string; sessionKey?: string }
-          | undefined;
-        const message = params?.message ?? "";
-        let reply = "REPLY_SKIP";
-        if (message === "ping" || message === "wait") {
-          reply = "done";
-        } else if (message === "Agent-to-agent announce step.") {
-          reply = "ANNOUNCE_SKIP";
-        } else if (params?.sessionKey === requesterKey) {
-          reply = "pong";
+        const params = request.params as { message?: string } | undefined;
+        if (params?.message === "wait") {
+          waitRunId = runId;
         }
-        replyByRunId.set(runId, reply);
         return {
           runId,
           status: "accepted",
@@ -161,13 +147,15 @@ describe("sessions tools", () => {
       }
       if (request.method === "agent.wait") {
         const params = request.params as { runId?: string } | undefined;
-        lastWaitedRunId = params?.runId;
+        if (params?.runId && params.runId === waitRunId) {
+          nextHistoryIsWaitReply = true;
+        }
         return { runId: params?.runId ?? "run-1", status: "ok" };
       }
       if (request.method === "chat.history") {
         _historyCallCount += 1;
-        const text =
-          (lastWaitedRunId && replyByRunId.get(lastWaitedRunId)) ?? "";
+        const text = nextHistoryIsWaitReply ? "done" : "ANNOUNCE_SKIP";
+        nextHistoryIsWaitReply = false;
         return {
           messages: [
             {
@@ -190,10 +178,9 @@ describe("sessions tools", () => {
       return {};
     });
 
-    const tool = createClawdisTools({
-      agentSessionKey: requesterKey,
-      agentSurface: "discord",
-    }).find((candidate) => candidate.name === "sessions_send");
+    const tool = createClawdisTools().find(
+      (candidate) => candidate.name === "sessions_send",
+    );
     expect(tool).toBeDefined();
     if (!tool) throw new Error("missing sessions_send tool");
 
@@ -204,7 +191,6 @@ describe("sessions tools", () => {
     });
     expect(fire.details).toMatchObject({ status: "accepted", runId: "run-1" });
     await new Promise((resolve) => setTimeout(resolve, 0));
-    await new Promise((resolve) => setTimeout(resolve, 0));
 
     const waitPromise = tool.execute("call6", {
       sessionKey: "main",
@@ -218,14 +204,13 @@ describe("sessions tools", () => {
     });
     expect(typeof (waited.details as { runId?: string }).runId).toBe("string");
     await new Promise((resolve) => setTimeout(resolve, 0));
-    await new Promise((resolve) => setTimeout(resolve, 0));
 
     const agentCalls = calls.filter((call) => call.method === "agent");
     const waitCalls = calls.filter((call) => call.method === "agent.wait");
     const historyOnlyCalls = calls.filter(
       (call) => call.method === "chat.history",
     );
-    expect(agentCalls).toHaveLength(8);
+    expect(agentCalls).toHaveLength(4);
     for (const call of agentCalls) {
       expect(call.params).toMatchObject({ lane: "nested" });
     }
@@ -246,21 +231,11 @@ describe("sessions tools", () => {
             ?.extraSystemPrompt === "string" &&
           (
             call.params as { extraSystemPrompt?: string }
-          )?.extraSystemPrompt?.includes("Agent-to-agent reply step"),
+          )?.extraSystemPrompt?.includes("Agent-to-agent post step"),
       ),
     ).toBe(true);
-    expect(
-      agentCalls.some(
-        (call) =>
-          typeof (call.params as { extraSystemPrompt?: string })
-            ?.extraSystemPrompt === "string" &&
-          (
-            call.params as { extraSystemPrompt?: string }
-          )?.extraSystemPrompt?.includes("Agent-to-agent announce step"),
-      ),
-    ).toBe(true);
-    expect(waitCalls).toHaveLength(8);
-    expect(historyOnlyCalls).toHaveLength(8);
+    expect(waitCalls).toHaveLength(3);
+    expect(historyOnlyCalls).toHaveLength(3);
     expect(
       waitCalls.some(
         (call) =>
@@ -269,110 +244,4 @@ describe("sessions tools", () => {
     ).toBe(true);
     expect(sendCallCount).toBe(0);
   });
-
-  it("sessions_send runs ping-pong then announces", async () => {
-    callGatewayMock.mockReset();
-    const calls: Array<{ method?: string; params?: unknown }> = [];
-    let agentCallCount = 0;
-    let lastWaitedRunId: string | undefined;
-    const replyByRunId = new Map<string, string>();
-    const requesterKey = "discord:group:req";
-    const targetKey = "discord:group:target";
-    let sendParams: { to?: string; provider?: string; message?: string } = {};
-    callGatewayMock.mockImplementation(async (opts: unknown) => {
-      const request = opts as { method?: string; params?: unknown };
-      calls.push(request);
-      if (request.method === "agent") {
-        agentCallCount += 1;
-        const runId = `run-${agentCallCount}`;
-        const params = request.params as
-          | {
-              message?: string;
-              sessionKey?: string;
-              extraSystemPrompt?: string;
-            }
-          | undefined;
-        let reply = "initial";
-        if (params?.extraSystemPrompt?.includes("Agent-to-agent reply step")) {
-          reply = params.sessionKey === requesterKey ? "pong-1" : "pong-2";
-        }
-        if (
-          params?.extraSystemPrompt?.includes("Agent-to-agent announce step")
-        ) {
-          reply = "announce now";
-        }
-        replyByRunId.set(runId, reply);
-        return {
-          runId,
-          status: "accepted",
-          acceptedAt: 2000 + agentCallCount,
-        };
-      }
-      if (request.method === "agent.wait") {
-        const params = request.params as { runId?: string } | undefined;
-        lastWaitedRunId = params?.runId;
-        return { runId: params?.runId ?? "run-1", status: "ok" };
-      }
-      if (request.method === "chat.history") {
-        const text =
-          (lastWaitedRunId && replyByRunId.get(lastWaitedRunId)) ?? "";
-        return {
-          messages: [
-            {
-              role: "assistant",
-              content: [{ type: "text", text }],
-              timestamp: 20,
-            },
-          ],
-        };
-      }
-      if (request.method === "send") {
-        const params = request.params as
-          | { to?: string; provider?: string; message?: string }
-          | undefined;
-        sendParams = {
-          to: params?.to,
-          provider: params?.provider,
-          message: params?.message,
-        };
-        return { messageId: "m-announce" };
-      }
-      return {};
-    });
-
-    const tool = createClawdisTools({
-      agentSessionKey: requesterKey,
-      agentSurface: "discord",
-    }).find((candidate) => candidate.name === "sessions_send");
-    expect(tool).toBeDefined();
-    if (!tool) throw new Error("missing sessions_send tool");
-
-    const waited = await tool.execute("call7", {
-      sessionKey: targetKey,
-      message: "ping",
-      timeoutSeconds: 1,
-    });
-    expect(waited.details).toMatchObject({
-      status: "ok",
-      reply: "initial",
-    });
-    await new Promise((resolve) => setTimeout(resolve, 0));
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    const replySteps = calls.filter(
-      (call) =>
-        call.method === "agent" &&
-        typeof (call.params as { extraSystemPrompt?: string })
-          ?.extraSystemPrompt === "string" &&
-        (
-          call.params as { extraSystemPrompt?: string }
-        )?.extraSystemPrompt?.includes("Agent-to-agent reply step"),
-    );
-    expect(replySteps).toHaveLength(2);
-    expect(sendParams).toMatchObject({
-      to: "channel:target",
-      provider: "discord",
-      message: "announce now",
-    });
-  });
 });