macro-agent 0.1.0 → 0.1.2

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

@@ -0,0 +1,355 @@
+/**
+ * ACP-over-MAP _macro/getModels Tests
+ *
+ * Verifies that the _macro/getModels extension method correctly returns
+ * model information from the agent's session via the ACP-over-MAP handler.
+ */
+
+import { describe, it, expect, afterEach, vi } from "vitest";
+import { ACPOverMAPHandler } from "../acp-over-map.js";
+import type { ACPEnvelope } from "../acp-over-map.js";
+import { createEventStore, type EventStore } from "../../../store/event-store.js";
+import type { AgentManager } from "../../../agent/agent-manager.js";
+import type { TaskManager } from "../../../task/task-manager.js";
+import type { Agent, Task } from "../../../store/types/index.js";
+import type { AgentId } from "../../../store/types/index.js";
+
+// ─────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────
+
+function createMockAgent(overrides: Partial<Agent> = {}): Agent {
+  return {
+    id: "agent-1" as AgentId,
+    session_id: "session-1",
+    state: "running",
+    task: "Test task",
+    task_id: "task-1",
+    parent: null,
+    lineage: [],
+    config: {},
+    cwd: "/test/cwd",
+    plan: [],
+    created_at: Date.now(),
+    started_at: Date.now(),
+    ...overrides,
+  };
+}
+
+function createMockTask(overrides: Partial<Task> = {}): Task {
+  return {
+    id: "task-1",
+    description: "Test task",
+    status: "in_progress",
+    created_by: "agent-1",
+    created_at: Date.now(),
+    ...overrides,
+  };
+}
+
+function createMockAgentManager(
+  sessionOverride?: unknown,
+): AgentManager {
+  const mockAgent = createMockAgent();
+
+  return {
+    spawn: vi.fn().mockResolvedValue({
+      id: "agent-new",
+      session_id: "session-new",
+      agent: createMockAgent({ id: "agent-new" as AgentId, session_id: "session-new" }),
+      session: {},
+    }),
+    get: vi.fn().mockReturnValue(mockAgent),
+    list: vi.fn().mockReturnValue([mockAgent]),
+    listHeadManagers: vi.fn().mockReturnValue([mockAgent]),
+    getChildren: vi.fn().mockReturnValue([]),
+    getHierarchy: vi.fn().mockReturnValue({
+      root: { agent: mockAgent, children: [] },
+      depth: 1,
+      totalAgents: 1,
+    }),
+    getOrCreateHeadManager: vi.fn().mockResolvedValue({
+      id: "agent-1",
+      session_id: "session-1",
+      agent: mockAgent,
+      session: {},
+    }),
+    hasActiveSession: vi.fn().mockReturnValue(true),
+    resume: vi.fn().mockResolvedValue({
+      id: "agent-1",
+      session_id: "session-1",
+      agent: mockAgent,
+      session: {},
+    }),
+    terminate: vi.fn().mockResolvedValue(undefined),
+    prompt: vi.fn().mockReturnValue({
+      [Symbol.asyncIterator]: async function* () {},
+    }),
+    getSession: vi.fn().mockReturnValue(sessionOverride ?? null),
+    onLifecycleEvent: vi.fn().mockReturnValue(() => {}),
+    close: vi.fn().mockResolvedValue(undefined),
+    respondToPermission: vi.fn().mockReturnValue(true),
+    cancelPermission: vi.fn().mockReturnValue(true),
+  } as unknown as AgentManager;
+}
+
+function createMockTaskManager(): TaskManager {
+  return {
+    get: vi.fn().mockReturnValue(createMockTask()),
+    list: vi.fn().mockReturnValue([createMockTask()]),
+    create: vi.fn().mockReturnValue(createMockTask()),
+  } as unknown as TaskManager;
+}
+
+/** Build an ACP envelope for processRequest */
+function envelope(
+  streamId: string,
+  method: string,
+  params?: unknown,
+  sessionId?: string,
+): ACPEnvelope {
+  return {
+    acp: {
+      jsonrpc: "2.0",
+      id: `${streamId}-${method}-${Date.now()}`,
+      method,
+      params,
+    },
+    acpContext: {
+      streamId,
+      sessionId,
+      direction: "client-to-agent",
+    },
+  };
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Tests
+// ─────────────────────────────────────────────────────────────────
+
+describe("ACP-over-MAP _macro/getModels", () => {
+  let eventStore: EventStore;
+  let handler: ACPOverMAPHandler;
+
+  afterEach(async () => {
+    await eventStore.close();
+  });
+
+  async function setup(sessionOverride?: unknown) {
+    eventStore = await createEventStore({ inMemory: true });
+    const agentManager = createMockAgentManager(sessionOverride);
+    const taskManager = createMockTaskManager();
+
+    handler = new ACPOverMAPHandler({
+      agentManager,
+      eventStore,
+      taskManager,
+      defaultCwd: "/test/cwd",
+    });
+
+    return { agentManager, taskManager };
+  }
+
+  /** Register an agent in the EventStore so session mapper can resolve it */
+  function registerAgent(agentId: string, sessionId: string): void {
+    eventStore.emit({
+      type: "spawn",
+      source: { agent_id: agentId },
+      payload: {
+        agent_id: agentId,
+        session_id: sessionId,
+        task: "Test task",
+        task_id: "task-1",
+        cwd: "/test/cwd",
+      },
+    });
+    eventStore.emit({
+      type: "lifecycle",
+      source: { agent_id: agentId },
+      payload: {
+        agent_id: agentId,
+        action: "started",
+      },
+    });
+  }
+
+  /** Initialize a stream and create a session, returning the sessionId */
+  async function initAndCreateSession(
+    streamId: string,
+    targetAgentId: AgentId = "agent-1" as AgentId,
+  ): Promise<string> {
+    await handler.processRequest(
+      targetAgentId,
+      envelope(streamId, "initialize", {
+        protocolVersion: 1,
+        capabilities: {},
+        clientInfo: { name: "test", version: "1.0" },
+      }),
+    );
+
+    const sessionResult = await handler.processRequest(
+      targetAgentId,
+      envelope(streamId, "session/new", {
+        cwd: "/test",
+        mcpServers: [],
+      }),
+    );
+
+    const sessionId = (sessionResult.acp.result as { sessionId?: string })?.sessionId;
+    if (!sessionId) throw new Error("session/new did not return sessionId");
+
+    registerAgent(targetAgentId, sessionId);
+
+    return sessionId;
+  }
+
+  it("should return empty models when session is not found", async () => {
+    // getSession returns null — no session available
+    await setup(null);
+
+    const streamId = "test-stream-1";
+    const agentId = "agent-1" as AgentId;
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    const result = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getModels", { sessionId }),
+    );
+
+    expect(result.acp.error).toBeUndefined();
+    const data = result.acp.result as {
+      currentModelId: string | null;
+      availableModels: Array<{ modelId: string; name: string }>;
+    };
+    expect(data.currentModelId).toBeNull();
+    expect(data.availableModels).toEqual([]);
+  });
+
+  it("should return models from session.models when available", async () => {
+    // Mock session with models array (like Claude Code returns)
+    const mockSession = {
+      id: "acp-session-123",
+      models: ["default", "sonnet"],
+    };
+    await setup(mockSession);
+
+    const streamId = "test-stream-2";
+    const agentId = "agent-1" as AgentId;
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    const result = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getModels", { sessionId }),
+    );
+
+    expect(result.acp.error).toBeUndefined();
+    const data = result.acp.result as {
+      currentModelId: string | null;
+      availableModels: Array<{ modelId: string; name: string }>;
+    };
+    expect(data.currentModelId).toBe("default");
+    expect(data.availableModels).toEqual([
+      { modelId: "default", name: "default" },
+      { modelId: "sonnet", name: "sonnet" },
+    ]);
+  });
+
+  it("should return models from clientHandler when available", async () => {
+    // Mock session with clientHandler.getSessionModelInfo
+    const mockSession = {
+      id: "acp-session-456",
+      models: ["fallback-model"],
+      clientHandler: {
+        getSessionModelInfo: (_id: string) => ({
+          currentModelId: "opus",
+          availableModels: [
+            { modelId: "opus", name: "Claude Opus 4" },
+            { modelId: "sonnet", name: "Claude Sonnet 4.5" },
+          ],
+        }),
+      },
+    };
+    await setup(mockSession);
+
+    const streamId = "test-stream-3";
+    const agentId = "agent-1" as AgentId;
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    const result = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getModels", { sessionId }),
+    );
+
+    expect(result.acp.error).toBeUndefined();
+    const data = result.acp.result as {
+      currentModelId: string | null;
+      availableModels: Array<{ modelId: string; name: string }>;
+    };
+    // clientHandler should take priority over session.models
+    expect(data.currentModelId).toBe("opus");
+    expect(data.availableModels).toEqual([
+      { modelId: "opus", name: "Claude Opus 4" },
+      { modelId: "sonnet", name: "Claude Sonnet 4.5" },
+    ]);
+  });
+
+  it("should fall back to session.models when clientHandler returns empty", async () => {
+    // clientHandler returns empty, should fall back to session.models
+    const mockSession = {
+      id: "acp-session-789",
+      models: ["haiku"],
+      clientHandler: {
+        getSessionModelInfo: () => ({
+          currentModelId: null,
+          availableModels: [],
+        }),
+      },
+    };
+    await setup(mockSession);
+
+    const streamId = "test-stream-4";
+    const agentId = "agent-1" as AgentId;
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    const result = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getModels", { sessionId }),
+    );
+
+    expect(result.acp.error).toBeUndefined();
+    const data = result.acp.result as {
+      currentModelId: string | null;
+      availableModels: Array<{ modelId: string; name: string }>;
+    };
+    expect(data.currentModelId).toBe("haiku");
+    expect(data.availableModels).toEqual([
+      { modelId: "haiku", name: "haiku" },
+    ]);
+  });
+
+  it("should return empty when session has no models and no clientHandler", async () => {
+    // Session exists but has no models
+    const mockSession = {
+      id: "acp-session-empty",
+      models: [],
+    };
+    await setup(mockSession);
+
+    const streamId = "test-stream-5";
+    const agentId = "agent-1" as AgentId;
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    const result = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getModels", { sessionId }),
+    );
+
+    expect(result.acp.error).toBeUndefined();
+    const data = result.acp.result as {
+      currentModelId: string | null;
+      availableModels: Array<{ modelId: string; name: string }>;
+    };
+    expect(data.currentModelId).toBeNull();
+    expect(data.availableModels).toEqual([]);
+  });
+});

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,