macro-agent 0.0.6 → 0.0.8

package/src/map/adapter/map-adapter.ts

@@ -38,11 +38,18 @@ import type {
   SubscriptionId,
   SubscriptionFilter,
   EventNotification,
+  MAPEventType,
 } from "./types.js";
-import type { Address, SendOptions, ScopeId } from "../types.js";
+import { isAgentAddress, type Address, type SendOptions, type ScopeId } from "../types.js";
 import type { AgentId } from "../../store/types/index.js";
-import { createConnectionManager, type ConnectionManager } from "./connection-manager.js";
-import { createSubscriptionManager, type SubscriptionManager } from "./subscription-manager.js";
+import {
+  createConnectionManager,
+  type ConnectionManager,
+} from "./connection-manager.js";
+import {
+  createSubscriptionManager,
+  type SubscriptionManager,
+} from "./subscription-manager.js";
 import {
   RPCHandler,
   createRPCHandler,
@@ -54,7 +61,13 @@ import {
   type JsonRpcMessage,
 } from "./rpc-handler.js";
 import { EXTENSION_CAPABILITIES } from "./extensions/index.js";
-import type { FederationHandler, FederationCapabilities, ConnectedPeer, MAPPeerConfig } from "../federation/types.js";
+import type {
+  FederationHandler,
+  FederationCapabilities,
+  ConnectedPeer,
+  MAPPeerConfig,
+} from "../federation/types.js";
+import { ACPOverMAPHandler, type ACPEnvelope } from "./acp-over-map.js";
 
 // =============================================================================
 // Connection Session
@@ -97,7 +110,7 @@ export interface MAPAdapterServices {
     from: AgentId,
     to: Address,
     content: string,
-    options?: SendOptions
+    options?: SendOptions,
   ) => Promise<{ delivered: AgentId[] }>;
 
   /**
@@ -114,6 +127,26 @@ export interface MAPAdapterServices {
    * Optional federation handler for cross-system communication.
    */
   federationHandler?: FederationHandler;
+
+  /**
+   * Full AgentManager reference for ACP-over-MAP support.
+   */
+  agentManager?: import("../../agent/agent-manager.js").AgentManager;
+
+  /**
+   * Full EventStore reference for ACP-over-MAP support.
+   */
+  eventStore?: import("../../store/event-store.js").EventStore;
+
+  /**
+   * Full TaskManager reference for ACP-over-MAP support.
+   */
+  taskManager?: import("../../task/task-manager.js").TaskManager;
+
+  /**
+   * Default working directory for ACP sessions.
+   */
+  defaultCwd?: string;
 }
 
 /**
@@ -161,10 +194,16 @@ export class MAPAdapterImpl implements MAPAdapter {
   private readonly scopes: Map<ScopeId, ScopeState> = new Map();
   private readonly eventHandlers: Set<AdapterEventHandler> = new Set();
   private readonly services: MAPAdapterServices;
+  private readonly acpOverMapHandler: ACPOverMAPHandler | null = null;
+  /** Sequence numbers per subscription for proper event ordering */
+  private readonly subscriptionSequences: Map<SubscriptionId, number> = new Map();
 
   private running = false;
 
-  constructor(config: MAPAdapterConfig = {}, services: MAPAdapterServices = {}) {
+  constructor(
+    config: MAPAdapterConfig = {},
+    services: MAPAdapterServices = {},
+  ) {
     this.config = {
       name: config.name ?? "macro-agent",
       version: config.version ?? "1.0.0",
@@ -172,6 +211,17 @@ export class MAPAdapterImpl implements MAPAdapter {
     };
     this.services = services;
 
+    // Initialize ACP-over-MAP handler if services are available
+    if (services.agentManager && services.eventStore && services.taskManager) {
+      this.acpOverMapHandler = new ACPOverMAPHandler({
+        agentManager: services.agentManager,
+        eventStore: services.eventStore,
+        taskManager: services.taskManager,
+        defaultCwd: services.defaultCwd,
+      });
+      console.error("[MAPAdapter] ACP-over-MAP handler initialized");
+    }
+
     // Initialize connection manager
     this.connections = createConnectionManager({
       limits: config.limits,
@@ -264,7 +314,10 @@ export class MAPAdapterImpl implements MAPAdapter {
     return participant;
   }
 
-  async disconnectParticipant(id: ParticipantId, reason?: string): Promise<void> {
+  async disconnectParticipant(
+    id: ParticipantId,
+    reason?: string,
+  ): Promise<void> {
     const session = this.sessions.get(id);
     if (!session) {
       return;
@@ -308,7 +361,7 @@ export class MAPAdapterImpl implements MAPAdapter {
     participantId: ParticipantId,
     to: Address,
     payload: MessagePayload,
-    options?: SendOptions
+    options?: SendOptions,
   ): Promise<SendResult> {
     const participant = this.connections.getParticipant(participantId);
     if (!participant) {
@@ -329,8 +382,10 @@ export class MAPAdapterImpl implements MAPAdapter {
     const result = await this.services.sendMessage(
       senderId,
       to,
-      typeof payload.content === "string" ? payload.content : JSON.stringify(payload.content),
-      options
+      typeof payload.content === "string"
+        ? payload.content
+        : JSON.stringify(payload.content),
+      options,
     );
 
     return {
@@ -345,7 +400,7 @@ export class MAPAdapterImpl implements MAPAdapter {
 
   async createSubscription(
     participantId: ParticipantId,
-    filter?: SubscriptionFilter
+    filter?: SubscriptionFilter,
   ): Promise<SubscriptionId> {
     const participant = this.connections.getParticipant(participantId);
     if (!participant) {
@@ -361,6 +416,7 @@ export class MAPAdapterImpl implements MAPAdapter {
 
   async removeSubscription(subscriptionId: SubscriptionId): Promise<void> {
     this.subscriptions.unsubscribe(subscriptionId);
+    this.subscriptionSequences.delete(subscriptionId);
   }
 
   getSubscriptions(participantId: ParticipantId): SubscriptionId[] {
@@ -397,7 +453,10 @@ export class MAPAdapterImpl implements MAPAdapter {
     return agents.map((agent) => this.toAgentInfo(agent));
   }
 
-  getAgent(participantId: ParticipantId, agentId: AgentId): AgentInfo | undefined {
+  getAgent(
+    participantId: ParticipantId,
+    agentId: AgentId,
+  ): AgentInfo | undefined {
     const participant = this.connections.getParticipant(participantId);
     if (!participant) {
       return undefined;
@@ -425,10 +484,15 @@ export class MAPAdapterImpl implements MAPAdapter {
       return [];
     }
 
-    return Array.from(this.scopes.values()).map((scope) => this.toScopeInfo(scope));
+    return Array.from(this.scopes.values()).map((scope) =>
+      this.toScopeInfo(scope),
+    );
   }
 
-  getScope(participantId: ParticipantId, scopeId: ScopeId): ScopeInfo | undefined {
+  getScope(
+    participantId: ParticipantId,
+    scopeId: ScopeId,
+  ): ScopeInfo | undefined {
     const participant = this.connections.getParticipant(participantId);
     if (!participant) {
       return undefined;
@@ -448,13 +512,33 @@ export class MAPAdapterImpl implements MAPAdapter {
 
   emitEvent(event: EventNotification): void {
     // Match event against subscriptions
-    const { subscriptions: matchingSubs, participantIds } = this.subscriptions.match(event);
+    const { subscriptions: matchingSubs } =
+      this.subscriptions.match(event);
 
-    // Send to each matched participant
-    for (const participantId of participantIds) {
-      const session = this.sessions.get(participantId);
+    // Send to each matched subscription with proper SDK format
+    // SDK EventNotificationParams: { subscriptionId, sequenceNumber, eventId?, timestamp?, event, causedBy? }
+    for (const subscription of matchingSubs) {
+      const session = this.sessions.get(subscription.participantId);
       if (session) {
-        const notification = createNotification("map/event", event);
+        // Get and increment sequence number for this subscription
+        const currentSeq = this.subscriptionSequences.get(subscription.id) ?? 0;
+        this.subscriptionSequences.set(subscription.id, currentSeq + 1);
+
+        // Build params in SDK EventNotificationParams format
+        const params = {
+          subscriptionId: subscription.id,
+          sequenceNumber: currentSeq,
+          eventId: event.eventId,     // For deduplication
+          timestamp: event.timestamp, // Envelope timestamp
+          event: {                    // The actual event object
+            id: event.eventId,
+            type: event.type,
+            timestamp: event.timestamp,
+            data: event.data,
+          },
+          ...(event.causedBy && { causedBy: event.causedBy }),
+        };
+        const notification = createNotification("map/event", params);
         this.sendToSession(session, notification).catch((error) => {
           console.error("[MAPAdapter] Failed to send event:", error);
         });
@@ -578,32 +662,46 @@ export class MAPAdapterImpl implements MAPAdapter {
   private createRPCHandler(participantId: ParticipantId): RPCHandler {
     const handlers: HandlerRegistry = {
       // Connection
-      "map/connect": async (params) => this.handleConnect(participantId, params),
+      "map/connect": async (params) =>
+        this.handleConnect(participantId, params),
       "map/disconnect": async () => this.handleDisconnect(participantId),
 
       // Subscriptions
-      "map/subscribe": async (params) => this.handleSubscribe(participantId, params),
-      "map/unsubscribe": async (params) => this.handleUnsubscribe(participantId, params),
+      "map/subscribe": async (params) =>
+        this.handleSubscribe(participantId, params),
+      "map/unsubscribe": async (params) =>
+        this.handleUnsubscribe(participantId, params),
 
       // Messaging
-      "map/send": async (params, ctx) => this.handleSend(participantId, params, ctx),
+      "map/send": async (params, ctx) =>
+        this.handleSend(participantId, params, ctx),
 
       // Agent queries
-      "map/agents/list": async (params) => this.handleListAgents(participantId, params),
-      "map/agents/get": async (params) => this.handleGetAgent(participantId, params),
+      "map/agents/list": async (params) =>
+        this.handleListAgents(participantId, params),
+      "map/agents/get": async (params) =>
+        this.handleGetAgent(participantId, params),
 
       // Scope queries
       "map/scopes/list": async () => this.handleListScopes(participantId),
-      "map/scopes/get": async (params) => this.handleGetScope(participantId, params),
-      "map/scopes/create": async (params, ctx) => this.handleCreateScope(participantId, params, ctx),
-      "map/scopes/join": async (params) => this.handleJoinScope(participantId, params),
-      "map/scopes/leave": async (params) => this.handleLeaveScope(participantId, params),
+      "map/scopes/get": async (params) =>
+        this.handleGetScope(participantId, params),
+      "map/scopes/create": async (params, ctx) =>
+        this.handleCreateScope(participantId, params, ctx),
+      "map/scopes/join": async (params) =>
+        this.handleJoinScope(participantId, params),
+      "map/scopes/leave": async (params) =>
+        this.handleLeaveScope(participantId, params),
 
       // Federation methods
-      "map/federation/connect": async (params) => this.handleFederationConnect(participantId, params),
-      "map/federation/disconnect": async (params) => this.handleFederationDisconnect(participantId, params),
-      "map/federation/list": async () => this.handleFederationList(participantId),
-      "map/federation/capabilities": async (params) => this.handleFederationCapabilities(participantId, params),
+      "map/federation/connect": async (params) =>
+        this.handleFederationConnect(participantId, params),
+      "map/federation/disconnect": async (params) =>
+        this.handleFederationDisconnect(participantId, params),
+      "map/federation/list": async () =>
+        this.handleFederationList(participantId),
+      "map/federation/capabilities": async (params) =>
+        this.handleFederationCapabilities(participantId, params),
     };
 
     // Add extension method handlers
@@ -612,14 +710,18 @@ export class MAPAdapterImpl implements MAPAdapter {
         const extCtx: ExtensionContext = {
           participantId: ctx.participantId,
           capabilities: ctx.capabilities,
-          sessionId: this.sessions.get(ctx.participantId)?.participant.sessionId ?? "",
+          sessionId:
+            this.sessions.get(ctx.participantId)?.participant.sessionId ?? "",
         };
         return handler(extCtx, params);
       };
     }
 
     // Capability requirements for methods
-    const capabilityRequirements: Record<string, keyof ConnectedParticipant["capabilities"]> = {
+    const capabilityRequirements: Record<
+      string,
+      keyof ConnectedParticipant["capabilities"]
+    > = {
       "map/subscribe": "canSubscribe",
       "map/send": "canMessage",
       "map/agents/list": "canQuery",
@@ -638,7 +740,8 @@ export class MAPAdapterImpl implements MAPAdapter {
     for (const method of this.extensions.keys()) {
       const capability = EXTENSION_CAPABILITIES[method];
       if (capability) {
-        capabilityRequirements[method] = capability as keyof ConnectedParticipant["capabilities"];
+        capabilityRequirements[method] =
+          capability as keyof ConnectedParticipant["capabilities"];
       }
     }
 
@@ -660,7 +763,9 @@ export class MAPAdapterImpl implements MAPAdapter {
         }
 
         // Process the message
-        const participant = this.connections.getParticipant(session.participantId);
+        const participant = this.connections.getParticipant(
+          session.participantId,
+        );
         if (!participant) {
           break;
         }
@@ -685,15 +790,13 @@ export class MAPAdapterImpl implements MAPAdapter {
     }
   }
 
-  private async sendToSession(session: ConnectionSession, message: JsonRpcMessage): Promise<void> {
+  private async sendToSession(
+    session: ConnectionSession,
+    message: JsonRpcMessage,
+  ): Promise<void> {
     try {
-      // Reacquire writer lock
-      const writer = session.stream.writable.getWriter();
-      try {
-        await writer.write(message);
-      } finally {
-        writer.releaseLock();
-      }
+      // Use the existing writer from the session (acquired in acceptConnection)
+      await session.writer.write(message);
     } catch (error) {
       console.error("[MAPAdapter] Failed to send message:", error);
       throw error;
@@ -716,8 +819,11 @@ export class MAPAdapterImpl implements MAPAdapter {
 
   private async handleConnect(
     participantId: ParticipantId,
-    params: unknown
-  ): Promise<{ participantId: ParticipantId; capabilities: ConnectedParticipant["capabilities"] }> {
+    params: unknown,
+  ): Promise<{
+    participantId: ParticipantId;
+    capabilities: ConnectedParticipant["capabilities"];
+  }> {
     const participant = this.connections.getParticipant(participantId);
     if (!participant) {
       throw RPCError.notFound("participant", participantId);
@@ -732,25 +838,44 @@ export class MAPAdapterImpl implements MAPAdapter {
     };
   }
 
-  private async handleDisconnect(participantId: ParticipantId): Promise<{ success: boolean }> {
+  private async handleDisconnect(
+    participantId: ParticipantId,
+  ): Promise<{ success: boolean }> {
     await this.disconnectParticipant(participantId, "client_disconnect");
     return { success: true };
   }
 
   private async handleSubscribe(
     participantId: ParticipantId,
-    params: unknown
+    params: unknown,
   ): Promise<{ subscriptionId: SubscriptionId }> {
-    const filter = (params as { filter?: SubscriptionFilter })?.filter;
+    // Extract filter and translate SDK field names to internal format
+    // SDK uses 'fromAgents', macro-agent uses 'agents'
+    const rawFilter = (params as { filter?: Record<string, unknown> })?.filter;
+    let filter: SubscriptionFilter | undefined;
+
+    if (rawFilter) {
+      filter = {
+        eventTypes: rawFilter.eventTypes as MAPEventType[] | undefined,
+        agents: (rawFilter.fromAgents ?? rawFilter.agents) as
+          | AgentId[]
+          | undefined,
+        scopes: rawFilter.scopes as ScopeId[] | undefined,
+        subtree: rawFilter.subtree as AgentId | undefined,
+        lineage: rawFilter.lineage as AgentId | undefined,
+      };
+    }
+
     const subscriptionId = await this.createSubscription(participantId, filter);
     return { subscriptionId };
   }
 
   private async handleUnsubscribe(
     participantId: ParticipantId,
-    params: unknown
+    params: unknown,
   ): Promise<{ success: boolean }> {
-    const subscriptionId = (params as { subscriptionId: SubscriptionId })?.subscriptionId;
+    const subscriptionId = (params as { subscriptionId: SubscriptionId })
+      ?.subscriptionId;
     if (!subscriptionId) {
       throw RPCError.invalidParams("subscriptionId required");
     }
@@ -761,7 +886,7 @@ export class MAPAdapterImpl implements MAPAdapter {
   private async handleSend(
     participantId: ParticipantId,
     params: unknown,
-    ctx: HandlerContext
+    ctx: HandlerContext,
   ): Promise<SendResult> {
     const { to, payload, options } = params as {
       to: Address;
@@ -776,12 +901,120 @@ export class MAPAdapterImpl implements MAPAdapter {
       throw RPCError.invalidParams("payload required");
     }
 
+    // Check if this is an ACP-over-MAP message
+    // SDK sends ACP envelope directly as payload (not wrapped in content)
+    const rawPayload = payload as unknown as Record<string, unknown> | undefined;
+    if (rawPayload && typeof rawPayload === 'object' && 'acp' in rawPayload && 'acpContext' in rawPayload) {
+      // This is an ACP envelope - route through ACP-over-MAP handler
+      return this.handleACPOverMAP(participantId, to, rawPayload, ctx);
+    }
+
     return this.sendMessage(participantId, to, payload, options);
   }
 
+  /**
+   * Handle ACP-over-MAP messages.
+   * These are ACP protocol messages sent via MAP to an agent.
+   */
+  private async handleACPOverMAP(
+    participantId: ParticipantId,
+    to: Address,
+    envelope: Record<string, unknown>,
+    ctx: HandlerContext,
+  ): Promise<SendResult> {
+    if (!this.acpOverMapHandler) {
+      throw RPCError.internalError("ACP-over-MAP not available - missing services");
+    }
+
+    const acp = envelope.acp as {
+      jsonrpc: string;
+      id?: string | number;
+      method?: string;
+      params?: unknown;
+      result?: unknown;
+      error?: unknown;
+    };
+    const acpContext = envelope.acpContext as {
+      streamId: string;
+      sessionId?: string;
+      direction: string;
+    };
+
+    console.error(`[ACP-over-MAP] Received - method=${acp.method} to=${JSON.stringify(to)}`);
+
+    // For now, we only support messages to specific agents
+    if (!isAgentAddress(to)) {
+      throw RPCError.invalidParams("ACP-over-MAP requires agent target");
+    }
+
+    const targetAgentId = to.agent;
+
+    // Check if this is a request (has method) or response (has result/error)
+    if (!acp.method) {
+      // This is a response - route it normally
+      console.error(`[ACP-over-MAP] Routing response back`);
+      return this.sendMessage(participantId, to, { content: envelope }, undefined);
+    }
+
+    // Create notification emitter to stream session updates
+    const emitNotification = (notification: ACPEnvelope) => {
+      this.emitEvent({
+        eventId: ulid(),
+        type: "message_delivered" as MAPEventType,
+        timestamp: Date.now(),
+        agentId: targetAgentId,
+        data: {
+          message: {
+            id: `acp-notif-${Date.now()}`,
+            from: targetAgentId,
+            payload: notification,
+          },
+        },
+      });
+    };
+
+    // Process the ACP request through the handler
+    const acpEnvelope: ACPEnvelope = {
+      acp: acp as ACPEnvelope["acp"],
+      acpContext: acpContext as ACPEnvelope["acpContext"],
+    };
+    const responseEnvelope = await this.acpOverMapHandler.processRequest(
+      targetAgentId,
+      acpEnvelope,
+      emitNotification
+    );
+
+    console.error(`[ACP-over-MAP] Request processed - method=${acp.method}`);
+
+    // Emit response event to the participant's subscriptions
+    // SDK's stream.ts checks for "message_delivered" (underscore) not "message.delivered" (dot)
+    // Use underscore format for ACP-over-MAP compatibility
+    const participant = this.connections.getParticipant(participantId);
+    if (participant) {
+      this.emitEvent({
+        eventId: ulid(),
+        type: "message_delivered" as MAPEventType, // Cast needed - SDK expects underscore format
+        timestamp: Date.now(),
+        agentId: targetAgentId, // Must be at top level for subscription matching
+        data: {
+          message: {
+            id: `acp-resp-${Date.now()}`,
+            from: targetAgentId,
+            payload: responseEnvelope,
+          },
+        },
+      });
+    }
+
+    return {
+      messageId: `acp-${acp.id}`,
+      delivered: [targetAgentId],
+    };
+  }
+
   private async handleListAgents(
     participantId: ParticipantId,
-    params: unknown
+    params: unknown,
   ): Promise<{ agents: AgentInfo[] }> {
     const filter = (params as { filter?: AgentFilter })?.filter;
     const agents = this.listAgents(participantId, filter);
@@ -790,7 +1023,7 @@ export class MAPAdapterImpl implements MAPAdapter {
 
   private async handleGetAgent(
     participantId: ParticipantId,
-    params: unknown
+    params: unknown,
   ): Promise<{ agent: AgentInfo | null }> {
     const agentId = (params as { agentId: AgentId })?.agentId;
     if (!agentId) {
@@ -800,14 +1033,16 @@ export class MAPAdapterImpl implements MAPAdapter {
     return { agent: agent ?? null };
   }
 
-  private async handleListScopes(participantId: ParticipantId): Promise<{ scopes: ScopeInfo[] }> {
+  private async handleListScopes(
+    participantId: ParticipantId,
+  ): Promise<{ scopes: ScopeInfo[] }> {
     const scopes = this.listScopes(participantId);
     return { scopes };
   }
 
   private async handleGetScope(
     participantId: ParticipantId,
-    params: unknown
+    params: unknown,
   ): Promise<{ scope: ScopeInfo | null }> {
     const scopeId = (params as { scopeId: ScopeId })?.scopeId;
     if (!scopeId) {
@@ -820,18 +1055,22 @@ export class MAPAdapterImpl implements MAPAdapter {
   private async handleCreateScope(
     participantId: ParticipantId,
     params: unknown,
-    ctx: HandlerContext
+    ctx: HandlerContext,
   ): Promise<{ scopeId: ScopeId }> {
-    const { name, metadata } = (params as { name?: string; metadata?: Record<string, unknown> }) ?? {};
+    const { name, metadata } =
+      (params as { name?: string; metadata?: Record<string, unknown> }) ?? {};
     const scopeId = this.createScope(name, metadata);
     return { scopeId };
   }
 
   private async handleJoinScope(
     participantId: ParticipantId,
-    params: unknown
+    params: unknown,
   ): Promise<{ success: boolean }> {
-    const { scopeId, agentId } = params as { scopeId: ScopeId; agentId: AgentId };
+    const { scopeId, agentId } = params as {
+      scopeId: ScopeId;
+      agentId: AgentId;
+    };
     if (!scopeId) {
       throw RPCError.invalidParams("scopeId required");
     }
@@ -848,9 +1087,12 @@ export class MAPAdapterImpl implements MAPAdapter {
 
   private async handleLeaveScope(
     participantId: ParticipantId,
-    params: unknown
+    params: unknown,
   ): Promise<{ success: boolean }> {
-    const { scopeId, agentId } = params as { scopeId: ScopeId; agentId: AgentId };
+    const { scopeId, agentId } = params as {
+      scopeId: ScopeId;
+      agentId: AgentId;
+    };
     if (!scopeId) {
       throw RPCError.invalidParams("scopeId required");
     }
@@ -871,7 +1113,7 @@ export class MAPAdapterImpl implements MAPAdapter {
 
   private async handleFederationConnect(
     participantId: ParticipantId,
-    params: unknown
+    params: unknown,
   ): Promise<{ capabilities: FederationCapabilities }> {
     if (!this.services.federationHandler) {
       throw RPCError.internalError("Federation not available");
@@ -894,14 +1136,14 @@ export class MAPAdapterImpl implements MAPAdapter {
       return { capabilities };
     } catch (err) {
       throw RPCError.internalError(
-        err instanceof Error ? err.message : "Failed to connect"
+        err instanceof Error ? err.message : "Failed to connect",
       );
     }
   }
 
   private async handleFederationDisconnect(
     participantId: ParticipantId,
-    params: unknown
+    params: unknown,
   ): Promise<{ success: boolean }> {
     if (!this.services.federationHandler) {
       throw RPCError.internalError("Federation not available");
@@ -916,21 +1158,20 @@ export class MAPAdapterImpl implements MAPAdapter {
       await this.services.federationHandler.disconnect(systemId);
       return { success: true };
     } catch (err) {
-      if (
-        err instanceof Error &&
-        err.message.includes("Not connected")
-      ) {
+      if (err instanceof Error && err.message.includes("Not connected")) {
         throw RPCError.notFound("peer", systemId);
       }
       throw RPCError.internalError(
-        err instanceof Error ? err.message : "Failed to disconnect"
+        err instanceof Error ? err.message : "Failed to disconnect",
       );
     }
   }
 
   private async handleFederationList(
-    participantId: ParticipantId
-  ): Promise<{ peers: Array<{ systemId: string; status: string; connectedAt: number }> }> {
+    participantId: ParticipantId,
+  ): Promise<{
+    peers: Array<{ systemId: string; status: string; connectedAt: number }>;
+  }> {
     if (!this.services.federationHandler) {
       return { peers: [] };
     }
@@ -947,7 +1188,7 @@ export class MAPAdapterImpl implements MAPAdapter {
 
   private async handleFederationCapabilities(
     participantId: ParticipantId,
-    params: unknown
+    params: unknown,
   ): Promise<{ capabilities: FederationCapabilities | null }> {
     if (!this.services.federationHandler) {
       throw RPCError.internalError("Federation not available");
@@ -958,7 +1199,8 @@ export class MAPAdapterImpl implements MAPAdapter {
       throw RPCError.invalidParams("systemId is required");
     }
 
-    const capabilities = this.services.federationHandler.getCapabilities(systemId);
+    const capabilities =
+      this.services.federationHandler.getCapabilities(systemId);
     if (!capabilities) {
       throw RPCError.notFound("peer", systemId);
     }
@@ -980,6 +1222,13 @@ export class MAPAdapterImpl implements MAPAdapter {
       scopes: this.getAgentScopes(agent.id),
       metadata: agent.metadata,
       createdAt: agent.createdAt,
+      // All macro-agent agents support ACP (they're Claude Code sessions)
+      capabilities: {
+        protocols: ["acp"],
+        acp: {
+          features: ["streaming"],
+        },
+      },
     };
   }
 
@@ -1013,7 +1262,7 @@ export class MAPAdapterImpl implements MAPAdapter {
  */
 export function createMAPAdapter(
   config?: MAPAdapterConfig,
-  services?: MAPAdapterServices
+  services?: MAPAdapterServices,
 ): MAPAdapter {
   return new MAPAdapterImpl(config, services);
 }