macro-agent 0.1.0 → 0.1.1

package/src/map/adapter/__tests__/acp-over-map-history.test.ts

@@ -1078,6 +1078,269 @@ describe("ACP-over-MAP history persistence", () => {
     expect(result.plan[0].content).toBe("Persistent task");
   });
 
+  // ─────────────────────────────────────────────────────────────────
+  // Fork history tests
+  // ─────────────────────────────────────────────────────────────────
+
+  /** Register a forked agent with fork_of metadata */
+  function registerForkedAgent(
+    agentId: string,
+    sessionId: string,
+    sourceAgentId: string,
+    createdAt?: number,
+  ): void {
+    eventStore.emit({
+      type: "spawn",
+      source: { agent_id: sourceAgentId },
+      payload: {
+        agent_id: agentId,
+        session_id: sessionId,
+        task: `[Fork of ${sourceAgentId}]`,
+        task_id: "task-fork",
+        cwd: "/test/cwd",
+      },
+    });
+    // Set fork_of metadata (mirrors what agent-manager.ts does)
+    eventStore.updateAgentMetadata(agentId as AgentId, {
+      metadata: { fork_of: sourceAgentId },
+    });
+    // Backdate created_at if specified (for timestamp filtering tests)
+    if (createdAt !== undefined) {
+      // Overwrite the agent row's created_at by re-emitting a lifecycle event
+      // at the desired time — but since we can't change created_at directly,
+      // we rely on the spawn event timestamp. For testing, we'll emit the
+      // spawn before recording turns to ensure correct ordering.
+    }
+    // Mark as running
+    eventStore.emit({
+      type: "lifecycle",
+      source: { agent_id: agentId },
+      payload: {
+        agent_id: agentId,
+        action: "started",
+      },
+    });
+  }
+
+  /** Record a turn directly in the event store (bypasses prompt flow) */
+  function recordTurn(
+    agentId: string,
+    conversationId: string,
+    role: "user" | "assistant",
+    content: unknown,
+  ): void {
+    const now = Date.now();
+    eventStore.emit({
+      type: "turn",
+      source: { agent_id: agentId },
+      payload: {
+        action: "recorded",
+        turn_id: `turn_${role}_${now}_${Math.random().toString(36).slice(2, 8)}`,
+        conversation_id: conversationId,
+        participant: role,
+        timestamp: now,
+        content_type: role === "user" ? "user_prompt" : "assistant_response",
+        content,
+        source_type: "acp",
+      },
+    });
+  }
+
+  it("should include source agent history for forked agents", async () => {
+    await setup();
+
+    const sourceAgentId = "agent-source" as AgentId;
+    const sourceSessionId = "session-source";
+    const forkedAgentId = "agent-forked" as AgentId;
+    const forkedSessionId = "session-forked";
+
+    // Register source agent and record turns
+    registerAgent(sourceAgentId, sourceSessionId);
+    recordTurn(sourceAgentId, sourceSessionId, "user", "Hello source");
+    recordTurn(sourceAgentId, sourceSessionId, "assistant", { parts: [{ type: "text", text: "Hi from source" }] });
+
+    // Register forked agent with fork_of metadata
+    registerForkedAgent(forkedAgentId, forkedSessionId, sourceAgentId);
+
+    // Initialize stream for forked agent
+    const streamId = "fork-history-stream";
+    await handler.processRequest(
+      forkedAgentId,
+      envelope(streamId, "initialize", {
+        protocolVersion: 1,
+        capabilities: {},
+        clientInfo: { name: "test", version: "1.0" },
+      }),
+    );
+
+    // Query history for forked agent
+    const historyResult = await handler.processRequest(
+      forkedAgentId,
+      envelope(streamId, "_macro/getHistory", { agentId: forkedAgentId }),
+    );
+
+    const turns = (historyResult.acp.result as { turns: { role: string; content: unknown }[] }).turns;
+
+    // Should include source agent's 2 turns
+    expect(turns).toHaveLength(2);
+    expect(turns[0].role).toBe("user");
+    expect(turns[0].content).toBe("Hello source");
+    expect(turns[1].role).toBe("assistant");
+  });
+
+  it("should combine source and forked agent turns in order", async () => {
+    await setup();
+
+    const sourceAgentId = "agent-src" as AgentId;
+    const sourceSessionId = "session-src";
+    const forkedAgentId = "agent-fork" as AgentId;
+    const forkedSessionId = "session-fork";
+
+    // Source agent conversation
+    registerAgent(sourceAgentId, sourceSessionId);
+    recordTurn(sourceAgentId, sourceSessionId, "user", "Question 1");
+    recordTurn(sourceAgentId, sourceSessionId, "assistant", { parts: [{ type: "text", text: "Answer 1" }] });
+
+    // Fork the agent
+    registerForkedAgent(forkedAgentId, forkedSessionId, sourceAgentId);
+
+    // Forked agent has its own turns
+    recordTurn(forkedAgentId, forkedSessionId, "user", "Question 2 (forked)");
+    recordTurn(forkedAgentId, forkedSessionId, "assistant", { parts: [{ type: "text", text: "Answer 2 (forked)" }] });
+
+    const streamId = "fork-combined-stream";
+    await handler.processRequest(
+      forkedAgentId,
+      envelope(streamId, "initialize", {
+        protocolVersion: 1,
+        capabilities: {},
+        clientInfo: { name: "test", version: "1.0" },
+      }),
+    );
+
+    const historyResult = await handler.processRequest(
+      forkedAgentId,
+      envelope(streamId, "_macro/getHistory", { agentId: forkedAgentId }),
+    );
+
+    const turns = (historyResult.acp.result as { turns: { role: string; content: unknown }[] }).turns;
+
+    // Source turns (2) + forked turns (2) = 4
+    expect(turns).toHaveLength(4);
+    expect(turns[0].content).toBe("Question 1");
+    expect(turns[2].content).toBe("Question 2 (forked)");
+  });
+
+  it("should not include source turns recorded after the fork", async () => {
+    await setup();
+
+    const sourceAgentId = "agent-pre" as AgentId;
+    const sourceSessionId = "session-pre";
+    const forkedAgentId = "agent-post" as AgentId;
+    const forkedSessionId = "session-post";
+
+    // Source agent: record a turn before the fork
+    registerAgent(sourceAgentId, sourceSessionId);
+    recordTurn(sourceAgentId, sourceSessionId, "user", "Before fork");
+    recordTurn(sourceAgentId, sourceSessionId, "assistant", { parts: [{ type: "text", text: "Pre-fork reply" }] });
+
+    // Small delay to ensure fork timestamp is after source turns
+    await new Promise((r) => setTimeout(r, 10));
+
+    // Fork the agent
+    registerForkedAgent(forkedAgentId, forkedSessionId, sourceAgentId);
+
+    // Small delay to ensure post-fork turn timestamp is after fork
+    await new Promise((r) => setTimeout(r, 10));
+
+    // Source agent continues after fork — these should NOT appear in forked history
+    recordTurn(sourceAgentId, sourceSessionId, "user", "After fork on source");
+    recordTurn(sourceAgentId, sourceSessionId, "assistant", { parts: [{ type: "text", text: "Post-fork source reply" }] });
+
+    const streamId = "fork-filter-stream";
+    await handler.processRequest(
+      forkedAgentId,
+      envelope(streamId, "initialize", {
+        protocolVersion: 1,
+        capabilities: {},
+        clientInfo: { name: "test", version: "1.0" },
+      }),
+    );
+
+    const historyResult = await handler.processRequest(
+      forkedAgentId,
+      envelope(streamId, "_macro/getHistory", { agentId: forkedAgentId }),
+    );
+
+    const turns = (historyResult.acp.result as { turns: { role: string; content: unknown }[] }).turns;
+
+    // Should only include the 2 pre-fork turns, not the 2 post-fork ones
+    expect(turns).toHaveLength(2);
+    expect(turns[0].content).toBe("Before fork");
+    expect(turns.find((t: { content: unknown }) => t.content === "After fork on source")).toBeUndefined();
+  });
+
+  it("should return empty history for forked agent when source has no turns", async () => {
+    await setup();
+
+    const sourceAgentId = "agent-empty-src" as AgentId;
+    const sourceSessionId = "session-empty-src";
+    const forkedAgentId = "agent-empty-fork" as AgentId;
+    const forkedSessionId = "session-empty-fork";
+
+    // Source agent exists but has no conversation turns
+    registerAgent(sourceAgentId, sourceSessionId);
+    registerForkedAgent(forkedAgentId, forkedSessionId, sourceAgentId);
+
+    const streamId = "fork-empty-stream";
+    await handler.processRequest(
+      forkedAgentId,
+      envelope(streamId, "initialize", {
+        protocolVersion: 1,
+        capabilities: {},
+        clientInfo: { name: "test", version: "1.0" },
+      }),
+    );
+
+    const historyResult = await handler.processRequest(
+      forkedAgentId,
+      envelope(streamId, "_macro/getHistory", { agentId: forkedAgentId }),
+    );
+
+    const turns = (historyResult.acp.result as { turns: unknown[] }).turns;
+    expect(turns).toEqual([]);
+  });
+
+  it("should not affect non-forked agent history queries", async () => {
+    await setup();
+
+    const agentId = "agent-normal" as AgentId;
+    const sessionId = "session-normal";
+
+    registerAgent(agentId, sessionId);
+    recordTurn(agentId, sessionId, "user", "Normal question");
+    recordTurn(agentId, sessionId, "assistant", { parts: [{ type: "text", text: "Normal reply" }] });
+
+    const streamId = "normal-history-stream";
+    await handler.processRequest(
+      agentId,
+      envelope(streamId, "initialize", {
+        protocolVersion: 1,
+        capabilities: {},
+        clientInfo: { name: "test", version: "1.0" },
+      }),
+    );
+
+    const historyResult = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getHistory", { agentId }),
+    );
+
+    const turns = (historyResult.acp.result as { turns: { role: string; content: unknown }[] }).turns;
+    expect(turns).toHaveLength(2);
+    expect(turns[0].content).toBe("Normal question");
+  });
+
   it("should include both plan and cwd together in getHistory response", async () => {
     await setup([
       {

package/src/map/adapter/__tests__/acp-over-map-persistence.e2e.test.ts

@@ -208,7 +208,7 @@ describe("ACP-over-MAP history persistence (E2E with file-backed store)", () =>
           title: "ListFiles",
           status: "completed",
           rawInput: { path: "/src" },
-          output: "index.ts\napp.ts",
+          rawOutput: "index.ts\napp.ts",
         },
       ]),
       eventStore: eventStore1,

package/src/map/adapter/__tests__/event-broadcast.test.ts

@@ -0,0 +1,420 @@
+/**
+ * Integration tests for multi-client event broadcast.
+ *
+ * Verifies that when events are emitted via emitEvent(), they are correctly
+ * delivered to subscribed participants through their WebSocket streams.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import {
+  createMAPAdapter,
+  MAPAdapterImpl,
+  type MAPAdapterServices,
+} from "../map-adapter.js";
+import type { MAPAdapter, MAPAdapterConfig, Stream } from "../interface.js";
+import type { ParticipantId, EventNotification } from "../types.js";
+import type { AgentId } from "../../../store/types/index.js";
+import type { MAPEventType } from "../subscription-manager.js";
+import { ulid } from "ulid";
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+/**
+ * Create a mock stream pair that captures messages written by the server.
+ * - `serverStream`: pass to adapter.acceptConnection()
+ * - `clientMessages`: array of messages the adapter has written to the client
+ * - `sendToServer`: simulate client sending a message to the server
+ */
+function createMockStreamPair(): {
+  serverStream: Stream;
+  clientMessages: unknown[];
+  sendToServer: (msg: unknown) => void;
+} {
+  const clientMessages: unknown[] = [];
+
+  let clientResolve: ((msg: unknown) => void) | null = null;
+  let serverResolve: ((msg: unknown) => void) | null = null;
+
+  // Server reads from this (client → server)
+  const serverReadable = new ReadableStream<unknown>({
+    start(controller) {
+      serverResolve = (msg) => {
+        controller.enqueue(msg);
+      };
+    },
+  });
+
+  // Server writes to this (server → client)
+  const serverWritable = new WritableStream<unknown>({
+    write(chunk) {
+      clientMessages.push(chunk);
+    },
+  });
+
+  return {
+    serverStream: { readable: serverReadable, writable: serverWritable },
+    clientMessages,
+    sendToServer: (msg) => serverResolve?.(msg),
+  };
+}
+
+/**
+ * Wait for async writes to flush (emitEvent fires sendToSession without await).
+ */
+async function flushAsync(ms = 50): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// =============================================================================
+// Tests
+// =============================================================================
+
+describe("Multi-client event broadcast", () => {
+  let adapter: MAPAdapter;
+  let config: MAPAdapterConfig;
+  let services: MAPAdapterServices;
+
+  beforeEach(() => {
+    config = {
+      name: "test-broadcast",
+      version: "1.0.0",
+      limits: {
+        maxConnections: 10,
+        maxSubscriptionsPerConnection: 5,
+      },
+    };
+
+    services = {
+      getAgent: vi.fn(),
+      listAgents: vi.fn().mockReturnValue([]),
+      sendMessage: vi.fn().mockResolvedValue({ delivered: [] }),
+      getAncestors: vi.fn().mockReturnValue([]),
+      getDescendants: vi.fn().mockReturnValue([]),
+    };
+
+    adapter = createMAPAdapter(config, services);
+  });
+
+  afterEach(async () => {
+    if (adapter.isRunning()) {
+      await adapter.stop();
+    }
+  });
+
+  it("broadcasts event to subscribed participant", async () => {
+    await adapter.start();
+
+    // Connect Client A with subscription
+    const pairA = createMockStreamPair();
+    const clientA = await adapter.acceptConnection(pairA.serverStream);
+    await adapter.createSubscription(clientA.id, {
+      eventTypes: [
+        "message_sent" as MAPEventType,
+        "message_delivered" as MAPEventType,
+        "agent_registered" as MAPEventType,
+      ],
+    });
+
+    // Connect Client B (no subscription)
+    const pairB = createMockStreamPair();
+    await adapter.acceptConnection(pairB.serverStream);
+
+    // Emit a message_delivered event (simulates ACP response broadcast)
+    adapter.emitEvent({
+      eventId: ulid(),
+      type: "message_delivered" as MAPEventType,
+      timestamp: Date.now(),
+      agentId: "agent-1" as AgentId,
+      data: {
+        from: "agent-1",
+        to: "p-client-b",
+        message: {
+          id: `acp-notif-${Date.now()}`,
+          from: "agent-1",
+          payload: { type: "session/update", data: { text: "hello" } },
+        },
+      },
+    } as EventNotification);
+
+    await flushAsync();
+
+    // Client A should have received the notification
+    expect(pairA.clientMessages.length).toBeGreaterThan(0);
+
+    const notification = pairA.clientMessages[0] as {
+      jsonrpc: string;
+      method: string;
+      params: {
+        subscriptionId: string;
+        sequenceNumber: number;
+        event: { type: string; data: unknown };
+      };
+    };
+    expect(notification.method).toBe("map/event");
+    expect(notification.params.event.type).toBe("message_delivered");
+    expect(notification.params.subscriptionId).toMatch(/^sub-/);
+
+    // Client B should NOT have received the notification (no subscription)
+    expect(pairB.clientMessages).toHaveLength(0);
+  });
+
+  it("broadcasts agent_registered event to subscribed participant", async () => {
+    await adapter.start();
+
+    const pairA = createMockStreamPair();
+    const clientA = await adapter.acceptConnection(pairA.serverStream);
+    await adapter.createSubscription(clientA.id, {
+      eventTypes: ["agent_registered" as MAPEventType],
+    });
+
+    // Emit agent_registered (simulates onAgentRegistered callback)
+    adapter.emitEvent({
+      eventId: ulid(),
+      type: "agent_registered" as MAPEventType,
+      timestamp: Date.now(),
+      agentId: "agent-new" as AgentId,
+      data: {
+        agentId: "agent-new",
+        name: "New Agent",
+        role: "assistant",
+      },
+    } as EventNotification);
+
+    await flushAsync();
+
+    expect(pairA.clientMessages.length).toBeGreaterThan(0);
+    const notification = pairA.clientMessages[0] as {
+      method: string;
+      params: { event: { type: string; data: { agentId: string } } };
+    };
+    expect(notification.method).toBe("map/event");
+    expect(notification.params.event.type).toBe("agent_registered");
+    expect(notification.params.event.data.agentId).toBe("agent-new");
+  });
+
+  it("broadcasts message_sent event to subscribed participant", async () => {
+    await adapter.start();
+
+    const pairA = createMockStreamPair();
+    const clientA = await adapter.acceptConnection(pairA.serverStream);
+    await adapter.createSubscription(clientA.id, {
+      eventTypes: ["message_sent" as MAPEventType],
+    });
+
+    // Emit message_sent (simulates client→agent ACP request broadcast)
+    adapter.emitEvent({
+      eventId: ulid(),
+      type: "message_sent" as MAPEventType,
+      timestamp: Date.now(),
+      agentId: "agent-1" as AgentId,
+      data: {
+        from: "p-client-b",
+        to: "agent-1",
+        message: {
+          id: `acp-req-${Date.now()}`,
+          from: "p-client-b",
+          to: "agent-1",
+          payload: {
+            type: "session/prompt",
+            data: { text: "hello agent" },
+          },
+        },
+      },
+    } as EventNotification);
+
+    await flushAsync();
+
+    expect(pairA.clientMessages.length).toBeGreaterThan(0);
+    const notification = pairA.clientMessages[0] as {
+      method: string;
+      params: { event: { type: string; data: { from: string; to: string } } };
+    };
+    expect(notification.method).toBe("map/event");
+    expect(notification.params.event.type).toBe("message_sent");
+    expect(notification.params.event.data.from).toBe("p-client-b");
+    expect(notification.params.event.data.to).toBe("agent-1");
+  });
+
+  it("both clients receive events when both are subscribed", async () => {
+    await adapter.start();
+
+    const pairA = createMockStreamPair();
+    const clientA = await adapter.acceptConnection(pairA.serverStream);
+    await adapter.createSubscription(clientA.id, {
+      eventTypes: ["message_delivered" as MAPEventType],
+    });
+
+    const pairB = createMockStreamPair();
+    const clientB = await adapter.acceptConnection(pairB.serverStream);
+    await adapter.createSubscription(clientB.id, {
+      eventTypes: ["message_delivered" as MAPEventType],
+    });
+
+    adapter.emitEvent({
+      eventId: ulid(),
+      type: "message_delivered" as MAPEventType,
+      timestamp: Date.now(),
+      agentId: "agent-1" as AgentId,
+      data: { from: "agent-1", to: "some-client", message: {} },
+    } as EventNotification);
+
+    await flushAsync();
+
+    // Both should receive
+    expect(pairA.clientMessages.length).toBeGreaterThan(0);
+    expect(pairB.clientMessages.length).toBeGreaterThan(0);
+
+    const notifA = pairA.clientMessages[0] as { method: string };
+    const notifB = pairB.clientMessages[0] as { method: string };
+    expect(notifA.method).toBe("map/event");
+    expect(notifB.method).toBe("map/event");
+  });
+
+  it("does NOT broadcast to participant with non-matching filter", async () => {
+    await adapter.start();
+
+    const pairA = createMockStreamPair();
+    const clientA = await adapter.acceptConnection(pairA.serverStream);
+    // Subscribe only to agent_registered
+    await adapter.createSubscription(clientA.id, {
+      eventTypes: ["agent_registered" as MAPEventType],
+    });
+
+    // Emit message_delivered — should NOT match
+    adapter.emitEvent({
+      eventId: ulid(),
+      type: "message_delivered" as MAPEventType,
+      timestamp: Date.now(),
+      agentId: "agent-1" as AgentId,
+      data: { from: "agent-1", to: "some-client", message: {} },
+    } as EventNotification);
+
+    await flushAsync();
+
+    expect(pairA.clientMessages).toHaveLength(0);
+  });
+
+  it("dot format event types match underscore subscriptions via normalization", async () => {
+    await adapter.start();
+
+    const pairA = createMockStreamPair();
+    const clientA = await adapter.acceptConnection(pairA.serverStream);
+    // Subscribe with underscore format (what SDK sends)
+    await adapter.createSubscription(clientA.id, {
+      eventTypes: ["agent_registered" as MAPEventType],
+    });
+
+    // Emit with DOT format — SHOULD match after normalization
+    adapter.emitEvent({
+      eventId: ulid(),
+      type: "agent.registered" as MAPEventType,
+      timestamp: Date.now(),
+      agentId: "agent-1" as AgentId,
+      data: { agentId: "agent-1" },
+    } as EventNotification);
+
+    await flushAsync();
+
+    // Should receive — normalization converts dots to underscores for matching
+    expect(pairA.clientMessages.length).toBeGreaterThan(0);
+    const notification = pairA.clientMessages[0] as { method: string };
+    expect(notification.method).toBe("map/event");
+  });
+
+  it("underscore format event types DO match underscore subscriptions", async () => {
+    await adapter.start();
+
+    const pairA = createMockStreamPair();
+    const clientA = await adapter.acceptConnection(pairA.serverStream);
+    await adapter.createSubscription(clientA.id, {
+      eventTypes: ["agent_registered" as MAPEventType],
+    });
+
+    // Emit with UNDERSCORE format — SHOULD match
+    adapter.emitEvent({
+      eventId: ulid(),
+      type: "agent_registered" as MAPEventType,
+      timestamp: Date.now(),
+      agentId: "agent-1" as AgentId,
+      data: { agentId: "agent-1" },
+    } as EventNotification);
+
+    await flushAsync();
+
+    expect(pairA.clientMessages.length).toBeGreaterThan(0);
+    const notification = pairA.clientMessages[0] as { method: string };
+    expect(notification.method).toBe("map/event");
+  });
+
+  it("sequence numbers increment per subscription", async () => {
+    await adapter.start();
+
+    const pairA = createMockStreamPair();
+    const clientA = await adapter.acceptConnection(pairA.serverStream);
+    await adapter.createSubscription(clientA.id, {
+      eventTypes: ["message_delivered" as MAPEventType],
+    });
+
+    // Emit three events
+    for (let i = 0; i < 3; i++) {
+      adapter.emitEvent({
+        eventId: ulid(),
+        type: "message_delivered" as MAPEventType,
+        timestamp: Date.now(),
+        agentId: "agent-1" as AgentId,
+        data: { index: i },
+      } as EventNotification);
+    }
+
+    await flushAsync();
+
+    expect(pairA.clientMessages).toHaveLength(3);
+
+    const seqNums = pairA.clientMessages.map(
+      (m) => (m as { params: { sequenceNumber: number } }).params.sequenceNumber,
+    );
+    expect(seqNums).toEqual([0, 1, 2]);
+  });
+
+  it("paused subscription does not receive events", async () => {
+    await adapter.start();
+
+    const pairA = createMockStreamPair();
+    const clientA = await adapter.acceptConnection(pairA.serverStream);
+    const subId = await adapter.createSubscription(clientA.id, {
+      eventTypes: ["message_delivered" as MAPEventType],
+    });
+
+    // Pause the subscription
+    await adapter.pauseSubscription(subId);
+
+    adapter.emitEvent({
+      eventId: ulid(),
+      type: "message_delivered" as MAPEventType,
+      timestamp: Date.now(),
+      agentId: "agent-1" as AgentId,
+      data: {},
+    } as EventNotification);
+
+    await flushAsync();
+
+    expect(pairA.clientMessages).toHaveLength(0);
+
+    // Resume and emit again
+    await adapter.resumeSubscription(subId);
+
+    adapter.emitEvent({
+      eventId: ulid(),
+      type: "message_delivered" as MAPEventType,
+      timestamp: Date.now(),
+      agentId: "agent-1" as AgentId,
+      data: {},
+    } as EventNotification);
+
+    await flushAsync();
+
+    expect(pairA.clientMessages).toHaveLength(1);
+  });
+});