macro-agent 0.1.6 → 0.1.8

package/src/map/__tests__/lifecycle-bridge.test.ts

@@ -12,11 +12,9 @@ import type { TaskBridge } from "../types.js";
 import type { Agent } from "../../store/types/index.js";
 
 function mockConnection(): LifecycleBridgeConnection & {
-  spawn: ReturnType<typeof vi.fn>;
   callExtension: ReturnType<typeof vi.fn>;
 } {
   return {
-    spawn: vi.fn().mockResolvedValue({}),
     callExtension: vi.fn().mockResolvedValue({}),
     get isConnected() {
       return true;
@@ -70,16 +68,61 @@ describe("LifecycleBridge", () => {
       agent: mockAgent({ id: "agent-1", name: "worker-1", role: "worker" }),
     });
 
-    expect(conn.spawn).toHaveBeenCalledWith(
+    expect(conn.callExtension).toHaveBeenCalledWith(
+      "map/agents/register",
       expect.objectContaining({
-        agentId: "agent-1",
         name: "worker-1",
         role: "worker",
-        scopes: [scope],
       }),
     );
   });
 
+  it("includes per-agent ACP capabilities for coordinators", () => {
+    const { callback } = createLifecycleBridge(
+      conn,
+      {} as AgentStore,
+      scope,
+    );
+
+    callback({
+      type: "spawned",
+      agent: mockAgent({ id: "coord-1", name: "coordinator-1", role: "coordinator" }),
+    });
+
+    expect(conn.callExtension).toHaveBeenCalledWith(
+      "map/agents/register",
+      expect.objectContaining({
+        name: "coordinator-1",
+        role: "coordinator",
+        capabilities: expect.objectContaining({
+          protocols: ["acp"],
+          acp: { version: "2024-10-07" },
+          messaging: { canReceive: true },
+        }),
+      }),
+    );
+  });
+
+  it("does not include ACP capabilities for workers", () => {
+    const { callback } = createLifecycleBridge(
+      conn,
+      {} as AgentStore,
+      scope,
+    );
+
+    callback({
+      type: "spawned",
+      agent: mockAgent({ id: "worker-1", name: "worker-1", role: "worker" }),
+    });
+
+    const call = conn.callExtension.mock.calls[0];
+    const params = call[1] as Record<string, unknown>;
+    const caps = params.capabilities as Record<string, unknown>;
+    expect(caps.protocols).toBeUndefined();
+    expect(caps.acp).toBeUndefined();
+    expect(caps.messaging).toEqual({ canReceive: true });
+  });
+
   it("unregisters agent from MAP hub on stop event", () => {
     const { callback } = createLifecycleBridge(
       conn,
@@ -98,12 +141,39 @@ describe("LifecycleBridge", () => {
     expect(conn.callExtension).toHaveBeenCalledWith(
       "map/agents/unregister",
       expect.objectContaining({
-        agentId: "agent-1",
         reason: "completed",
       }),
     );
   });
 
+  it("uses MAP-assigned ID for unregistration when available", async () => {
+    conn.callExtension.mockResolvedValueOnce({ agent: { id: "map-ulid-1" } });
+
+    const { callback } = createLifecycleBridge(
+      conn,
+      {} as AgentStore,
+      scope,
+    );
+
+    callback({ type: "spawned", agent: mockAgent({ id: "agent-1" }) });
+
+    // Wait for the .then() that stores mapId
+    await new Promise(r => setTimeout(r, 10));
+
+    callback({
+      type: "stopped",
+      agent: mockAgent({ id: "agent-1" }),
+      reason: "completed",
+    });
+
+    expect(conn.callExtension).toHaveBeenLastCalledWith(
+      "map/agents/unregister",
+      expect.objectContaining({
+        agentId: "map-ulid-1",
+      }),
+    );
+  });
+
   it("does nothing when disconnected", () => {
     const disconnected = {
       ...conn,
@@ -119,7 +189,7 @@ describe("LifecycleBridge", () => {
 
     callback({ type: "spawned", agent: mockAgent() });
 
-    expect(conn.spawn).not.toHaveBeenCalled();
+    expect(conn.callExtension).not.toHaveBeenCalled();
   });
 
   it("bridges task creation on spawn when agent has task_id", () => {
@@ -178,19 +248,15 @@ describe("LifecycleBridge", () => {
 
     await cleanup();
 
-    expect(conn.callExtension).toHaveBeenCalledTimes(2);
-    expect(conn.callExtension).toHaveBeenCalledWith(
-      "map/agents/unregister",
-      expect.objectContaining({ agentId: "a1" }),
-    );
-    expect(conn.callExtension).toHaveBeenCalledWith(
-      "map/agents/unregister",
-      expect.objectContaining({ agentId: "a2" }),
+    // 2 register calls + 2 unregister calls
+    const unregisterCalls = conn.callExtension.mock.calls.filter(
+      (c: any[]) => c[0] === "map/agents/unregister",
     );
+    expect(unregisterCalls).toHaveLength(2);
   });
 
   it("silently handles MAP call failures", () => {
-    conn.spawn.mockRejectedValue(new Error("network error"));
+    conn.callExtension.mockRejectedValue(new Error("network error"));
 
     const { callback } = createLifecycleBridge(
       conn,
@@ -216,7 +282,8 @@ describe("LifecycleBridge", () => {
       agent: mockAgent({ id: "agent-99", name: undefined }),
     });
 
-    expect(conn.spawn).toHaveBeenCalledWith(
+    expect(conn.callExtension).toHaveBeenCalledWith(
+      "map/agents/register",
       expect.objectContaining({ name: "agent-99" }),
     );
   });

package/src/map/lifecycle-bridge.ts

@@ -13,13 +13,6 @@ import type { TaskBridge } from "./types.js";
 
 /** Minimal interface for the MAP connection methods we need */
 export interface LifecycleBridgeConnection {
-  spawn(options: {
-    agentId?: string | undefined;
-    name?: string | undefined;
-    role?: string | undefined;
-    scopes?: string[];
-    metadata?: Record<string, unknown>;
-  }): Promise<unknown>;
   callExtension(method: string, params?: unknown): Promise<unknown>;
   get isConnected(): boolean;
 }
@@ -28,6 +21,8 @@ interface RegisteredAgent {
   id: string;
   name: string;
   role: string;
+  /** MAP-assigned agent ID (ULID) from the hub, used for unregistration */
+  mapId?: string;
 }
 
 /**
@@ -55,19 +50,37 @@ export function createLifecycleBridge(
         const entry: RegisteredAgent = { id: agent.id, name, role };
         registered.set(agent.id, entry);
 
-        // Register agent with MAP hub
+        // Build per-agent capabilities.
+        // Coordinators (head managers) support ACP for interactive chat.
+        const capabilities: Record<string, unknown> = {
+          messaging: { canReceive: true },
+        };
+        if (role === "coordinator") {
+          capabilities.protocols = ["acp"];
+          capabilities.acp = { version: "2024-10-07" };
+        }
+
+        // Register agent with MAP hub (use map/agents/register to preserve
+        // per-agent capabilities; map/agents/spawn drops them)
         connection
-          .spawn({
-            agentId: agent.id,
+          .callExtension("map/agents/register", {
             name,
             role,
-            scopes: [scope],
+            capabilities,
             metadata: {
+              localAgentId: agent.id,
               parent: (agent as any).parent_id ?? undefined,
               team: (agent as any).team ?? undefined,
               cwd: (agent as any).cwd ?? undefined,
             },
           })
+          .then((result: any) => {
+            // Track the MAP-assigned agent ID for unregistration
+            const mapId = result?.agent?.id ?? result?.id;
+            if (mapId) {
+              entry.mapId = mapId;
+            }
+          })
           .catch(() => {
             // Silent — MAP hub may be temporarily unavailable
           });
@@ -88,12 +101,14 @@ export function createLifecycleBridge(
 
       case "stopped": {
         const agent = event.agent;
+        const entry = registered.get(agent.id);
         registered.delete(agent.id);
 
-        // Unregister agent from MAP hub
+        // Unregister agent from MAP hub (use MAP-assigned ID if available)
+        const unregId = entry?.mapId ?? agent.id;
         connection
           .callExtension("map/agents/unregister", {
-            agentId: agent.id,
+            agentId: unregId,
             reason: event.reason ?? "stopped",
           })
           .catch(() => {
@@ -123,11 +138,11 @@ export function createLifecycleBridge(
       registered.clear();
       return;
     }
-    // Unregister all tracked agents
-    const promises = Array.from(registered.keys()).map((agentId) =>
+    // Unregister all tracked agents (use MAP-assigned IDs)
+    const promises = Array.from(registered.values()).map((entry) =>
       connection
         .callExtension("map/agents/unregister", {
-          agentId,
+          agentId: entry.mapId ?? entry.id,
           reason: "sidecar_shutdown",
         })
         .catch(() => {}),

package/src/map/server.ts

@@ -290,14 +290,26 @@ export function createMAPServerInstance(
           const message = data?.message;
           if (!message) return;
 
+          // Check if this is an ACP envelope — these should always be handled
+          // by the bridge, even if the target agent can't be resolved to a
+          // specific local agent (the bridge creates a head manager on demand).
+          const payload = message?.payload;
+          const isAcp = payload && typeof payload === 'object' &&
+            'acp' in payload && 'acpContext' in payload;
+
           const toField = message.to;
           const mapTargetId = data?.agentId ??
             (typeof toField === "string" ? toField : toField?.agent ?? toField?.id);
           if (!mapTargetId) return;
 
           const localAgentId = mapIdToLocalId.get(mapTargetId) ?? mapTargetId;
-          const localAgent = deps.agentManager.get(localAgentId);
-          if (!localAgent) return;
+
+          // For ACP envelopes, always forward to bridge (it creates sessions on demand).
+          // For non-ACP messages, require a local agent to exist.
+          if (!isAcp) {
+            const localAgent = deps.agentManager.get(localAgentId);
+            if (!localAgent) return;
+          }
 
           // Defer ACP processing to next tick so map/send response goes out first
           setImmediate(() => {

package/src/map/sidecar.ts

@@ -64,6 +64,12 @@ export function createMAPSidecar(
     if (config.token) {
       parsed.searchParams.set("token", config.token);
     }
+    // Include swarm_id for stable identity across reconnections.
+    // When set, the hub reuses the pre-registered swarm record instead
+    // of auto-generating a new one on each connection.
+    if (config.swarmId) {
+      parsed.searchParams.set("swarm_id", config.swarmId);
+    }
     return parsed.toString();
   }
 
@@ -109,8 +115,6 @@ export function createMAPSidecar(
         capabilities: {
           messaging: { canSend: true, canReceive: true },
           mail: { canCreate: true, canJoin: true, canViewHistory: true },
-          protocols: ['acp'],
-          acp: { version: '2024-10-07' },
           trajectory: { canReport: true, canServeContent: false },
           tasks: {
             canCreate: true,

package/src/map/types.ts

@@ -35,6 +35,9 @@ export interface MAPSidecarConfig {
   /** Agent name for MAP registration (default: "macro-agent-sidecar") */
   agentName?: string;
 
+  /** Swarm ID for stable identity across reconnections */
+  swarmId?: string;
+
   /** Trajectory sync level */
   trajectorySyncLevel?: "off" | "lifecycle" | "metrics" | "full";