macro-agent 0.0.17 → 0.1.1

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

@@ -65,6 +65,7 @@ import {
   type ScopeId,
 } from "../types.js";
 import type { AgentId } from "../../store/types/index.js";
+import type { AgentStopReason } from "../../agent/types.js";
 import {
   createConnectionManager,
   type ConnectionManager,
@@ -92,6 +93,7 @@ import type {
 } from "../federation/types.js";
 import { ACPOverMAPHandler, type ACPEnvelope } from "./acp-over-map.js";
 import { createMailHandlers } from "./mail-handler-adapter.js";
+import { EventLog, dotToUnderscore } from "./event-log.js";
 
 // =============================================================================
 // Connection Session
@@ -227,7 +229,8 @@ export class MAPAdapterImpl implements MAPAdapter {
   /** Sequence numbers per subscription for proper event ordering */
   private readonly subscriptionSequences: Map<SubscriptionId, number> =
     new Map();
-
+  /** In-memory event log for map/replay support */
+  private readonly eventLog: EventLog;
   private running = false;
 
   constructor(
@@ -248,10 +251,95 @@ export class MAPAdapterImpl implements MAPAdapter {
         eventStore: services.eventStore,
         taskManager: services.taskManager,
         defaultCwd: services.defaultCwd,
+        // Note: agent_registered events are now emitted by the lifecycle
+        // listener below, which covers ALL spawn paths (ACP, MCP, etc.)
       });
       console.error("[MAPAdapter] ACP-over-MAP handler initialized");
     }
 
+    // Listen for agent lifecycle events so spawns/stops happening in THIS
+    // process (main server) emit MAP events to subscribers immediately.
+    if (services.agentManager) {
+      services.agentManager.onLifecycleEvent((event) => {
+        if (event.type === "spawned" && event.agent) {
+          const agentId = event.agent.id as AgentId;
+          this.emitEvent({
+            eventId: ulid(),
+            type: "agent_registered" as MAPEventType,
+            timestamp: Date.now(),
+            agentId,
+            data: {
+              agentId: event.agent.id,
+              name: event.agent.name ?? "",
+              role: event.agent.role ?? "worker",
+              state: event.agent.state ?? "spawning",
+              parent: event.agent.parent ?? undefined,
+              metadata: event.agent.metadata ?? {},
+            },
+          });
+        } else if (event.type === "stopped" && event.agent) {
+          const agentId = event.agent.id as AgentId;
+          this.emitEvent({
+            eventId: ulid(),
+            type: "agent_state_changed" as MAPEventType,
+            timestamp: Date.now(),
+            agentId,
+            data: {
+              agentId: event.agent.id,
+              current: "stopped",
+              previous: "running",
+              reason: event.reason,
+            },
+          });
+          this.emitEvent({
+            eventId: ulid(),
+            type: "agent_unregistered" as MAPEventType,
+            timestamp: Date.now(),
+            agentId,
+            data: {
+              agentId: event.agent.id,
+              reason: event.reason,
+            },
+          });
+        }
+      });
+    }
+
+    // Listen for EventStore task changes to emit MAP task events.
+    // Task mutations from MCP bridge handlers run in-process, so
+    // onTaskChange fires immediately when tasks are created/updated.
+    if (services.eventStore) {
+      services.eventStore.onTaskChange((taskId, task) => {
+        if (!task) return;
+        // Map task status to MAP event type
+        const eventTypeMap: Record<string, string> = {
+          pending: "task_created",
+          assigned: "task_assigned",
+          in_progress: "task_assigned",
+          completed: "task_completed",
+          failed: "task_failed",
+          // OpenTasks statuses (defensive — normally mapped before reaching here)
+          closed: "task_completed",
+          open: "task_created",
+        };
+        const mapEventType = eventTypeMap[task.status];
+        if (mapEventType) {
+          this.emitEvent({
+            eventId: ulid(),
+            type: mapEventType as MAPEventType,
+            timestamp: Date.now(),
+            agentId: (task.assigned_agent ?? undefined) as AgentId | undefined,
+            data: {
+              taskId,
+              description: task.description,
+              status: task.status,
+              assignee: task.assigned_agent,
+            },
+          });
+        }
+      });
+    }
+
     // Initialize connection manager
     this.connections = createConnectionManager({
       limits: config.limits,
@@ -267,6 +355,11 @@ export class MAPAdapterImpl implements MAPAdapter {
       getDescendants: services.getDescendants,
     });
 
+    // Initialize event log for replay support
+    this.eventLog = new EventLog({
+      maxSize: config.limits?.maxReplayBufferSize ?? 10_000,
+    });
+
     // Forward connection events
     this.connections.onEvent((event) => {
       if (event.type === "participant.connected") {
@@ -541,6 +634,17 @@ export class MAPAdapterImpl implements MAPAdapter {
   // ===========================================================================
 
   emitEvent(event: EventNotification): void {
+    // Log event for replay support
+    this.eventLog.append({
+      eventId: event.eventId,
+      timestamp: event.timestamp,
+      type: event.type,
+      data: event.data,
+      causedBy: event.causedBy,
+      agentId: event.agentId,
+      scopeId: event.scopeId,
+    });
+
     // Match event against subscriptions
     const { subscriptions: matchingSubs } = this.subscriptions.match(event);
 
@@ -702,6 +806,9 @@ export class MAPAdapterImpl implements MAPAdapter {
       "map/unsubscribe": async (params) =>
         this.handleUnsubscribe(participantId, params),
 
+      // Replay
+      "map/replay": async (params) => this.handleReplay(participantId, params),
+
       // Messaging
       "map/send": async (params, ctx) =>
         this.handleSend(participantId, params, ctx),
@@ -712,6 +819,10 @@ export class MAPAdapterImpl implements MAPAdapter {
       "map/agents/get": async (params) =>
         this.handleGetAgent(participantId, params),
 
+      // Agent lifecycle
+      "map/agents/stop": async (params) =>
+        this.handleStopAgent(participantId, params),
+
       // Scope queries
       "map/scopes/list": async () => this.handleListScopes(participantId),
       "map/scopes/get": async (params) =>
@@ -761,9 +872,11 @@ export class MAPAdapterImpl implements MAPAdapter {
       keyof ConnectedParticipant["capabilities"]
     > = {
       "map/subscribe": "canSubscribe",
+      "map/replay": "canSubscribe",
       "map/send": "canMessage",
       "map/agents/list": "canQuery",
       "map/agents/get": "canQuery",
+      "map/agents/stop": "canStop",
       "map/scopes/list": "canQuery",
       "map/scopes/get": "canQuery",
       "map/scopes/create": "canManageScopes",
@@ -808,16 +921,27 @@ export class MAPAdapterImpl implements MAPAdapter {
           break;
         }
 
-        const result = await session.rpcHandler.process(value, {
-          participantId: session.participantId,
-          capabilities: participant.capabilities,
-          signal: session.abortController.signal,
+        // Process messages concurrently (same pattern as toad reference).
+        // The message loop must not block on any handler, otherwise
+        // session/cancel can't be delivered while session/prompt is running.
+        // The stream writer queues writes safely, so concurrent responses
+        // don't interleave.
+        const processAndRespond = async () => {
+          const result = await session.rpcHandler.process(value, {
+            participantId: session.participantId,
+            capabilities: participant.capabilities,
+            signal: session.abortController.signal,
+          });
+
+          if (result.type === "response") {
+            await this.sendToSession(session, result.response);
+          }
+        };
+        processAndRespond().catch((err) => {
+          if (!session.abortController.signal.aborted) {
+            console.error(`[MAPAdapter] Error processing message:`, err);
+          }
         });
-
-        // Send response if needed
-        if (result.type === "response") {
-          await this.sendToSession(session, result.response);
-        }
       }
     } catch (error) {
       if (!session.abortController.signal.aborted) {
@@ -871,12 +995,20 @@ export class MAPAdapterImpl implements MAPAdapter {
     const connectParams = params as
       | {
           type?: ParticipantType;
+          participantType?: ParticipantType;
           name?: string;
           credentials?: AuthCredentials;
+          capabilities?: {
+            observation?: { canObserve?: boolean; canQuery?: boolean };
+            messaging?: { canSend?: boolean; canReceive?: boolean; canBroadcast?: boolean };
+            lifecycle?: { canSpawn?: boolean; canRegister?: boolean; canUnregister?: boolean; canSteer?: boolean; canStop?: boolean };
+            scopes?: { canCreateScopes?: boolean; canManageScopes?: boolean };
+            management?: { canManageTasks?: boolean; canManageLifecycle?: boolean };
+          };
         }
       | undefined;
 
-    const requestedType = connectParams?.type ?? participant.type;
+    const requestedType = connectParams?.type ?? connectParams?.participantType ?? participant.type;
     const credentials = connectParams?.credentials;
 
     // Handle authentication if handler is configured and credentials provided
@@ -905,15 +1037,41 @@ export class MAPAdapterImpl implements MAPAdapter {
       };
     }
 
-    // No auth handler or no credentials - use default capabilities for the type
+    // Start with default capabilities for the requested type
+    const baseCapabilities = this.getDefaultCapabilities(requestedType);
+
+    // Merge client-requested capabilities (SDK nested format → flat format).
+    // Clients can request additional capabilities; the server grants them
+    // by merging with the type defaults.
+    if (connectParams?.capabilities) {
+      const req = connectParams.capabilities;
+      const requested: Partial<ParticipantCapabilities> = {};
+      if (req.observation?.canQuery !== undefined) requested.canQuery = req.observation.canQuery;
+      if (req.observation?.canObserve !== undefined) requested.canSubscribe = req.observation.canObserve;
+      if (req.messaging?.canSend !== undefined) requested.canMessage = req.messaging.canSend;
+      if (req.lifecycle?.canSpawn !== undefined) requested.canSpawn = req.lifecycle.canSpawn;
+      if (req.lifecycle?.canStop !== undefined) requested.canStop = req.lifecycle.canStop;
+      if (req.scopes?.canManageScopes !== undefined) requested.canManageScopes = req.scopes.canManageScopes;
+      if (req.management?.canManageTasks !== undefined) requested.canManageTasks = req.management.canManageTasks;
+      if (req.management?.canManageLifecycle !== undefined) requested.canManageLifecycle = req.management.canManageLifecycle;
+      const mergedCapabilities = { ...baseCapabilities, ...requested };
+      this.connections.updateCapabilities(participantId, mergedCapabilities);
+
+      const updatedParticipant = this.connections.getParticipant(participantId);
+      return {
+        participantId: participant.id,
+        capabilities: updatedParticipant?.capabilities ?? mergedCapabilities,
+      };
+    }
+
+    // No client-requested capabilities — apply type defaults if type changed
     if (requestedType !== participant.type) {
-      const defaultCapabilities = this.getDefaultCapabilities(requestedType);
-      this.connections.updateCapabilities(participantId, defaultCapabilities);
+      this.connections.updateCapabilities(participantId, baseCapabilities);
 
       const updatedParticipant = this.connections.getParticipant(participantId);
       return {
         participantId: participant.id,
-        capabilities: updatedParticipant?.capabilities ?? defaultCapabilities,
+        capabilities: updatedParticipant?.capabilities ?? baseCapabilities,
       };
     }
 
@@ -941,6 +1099,7 @@ export class MAPAdapterImpl implements MAPAdapter {
             canManageScopes: true,
             canManageTasks: true,
             canManageFederation: true,
+            canManageLifecycle: true,
           }
         );
       case "gateway":
@@ -953,6 +1112,7 @@ export class MAPAdapterImpl implements MAPAdapter {
           canManageScopes: false,
           canManageTasks: false,
           canManageFederation: true,
+          canManageLifecycle: false,
         };
       case "client":
       default:
@@ -965,6 +1125,7 @@ export class MAPAdapterImpl implements MAPAdapter {
             canStop: false,
             canManageScopes: false,
             canManageTasks: false,
+            canManageLifecycle: false,
           }
         );
     }
@@ -1015,6 +1176,69 @@ export class MAPAdapterImpl implements MAPAdapter {
     return { success: true };
   }
 
+  private async handleReplay(
+    _participantId: ParticipantId,
+    params: unknown,
+  ): Promise<{
+    events: Array<{
+      eventId: string;
+      timestamp: number;
+      causedBy?: string[];
+      event: { id: string; type: string; timestamp: number; data: unknown };
+    }>;
+    hasMore: boolean;
+  }> {
+    const { afterEventId, fromTimestamp, toTimestamp, filter, limit } =
+      (params ?? {}) as {
+        afterEventId?: string;
+        fromTimestamp?: number;
+        toTimestamp?: number;
+        filter?: {
+          eventTypes?: string[];
+          fromAgents?: string[];
+          agents?: string[];
+          scopes?: string[];
+        };
+        limit?: number;
+      };
+
+    // Translate SDK filter field names to internal format
+    // SDK uses 'fromAgents', macro-agent uses 'agents'
+    const internalFilter = filter
+      ? {
+          eventTypes: filter.eventTypes,
+          agents: (filter.fromAgents ?? filter.agents) as string[] | undefined,
+          scopes: filter.scopes,
+        }
+      : undefined;
+
+    const result = this.eventLog.query({
+      afterEventId,
+      fromTimestamp,
+      toTimestamp,
+      filter: internalFilter,
+      limit,
+    });
+
+    // Transform events to SDK response format
+    const events = result.events.map((e) => ({
+      eventId: e.eventId,
+      timestamp: e.timestamp,
+      ...(e.causedBy && { causedBy: e.causedBy }),
+      event: {
+        id: e.eventId,
+        type: dotToUnderscore(e.type),
+        timestamp: e.timestamp,
+        data: e.data,
+      },
+    }));
+
+    return {
+      events,
+      hasMore: result.hasMore,
+    };
+  }
+
   private async handleSend(
     participantId: ParticipantId,
     params: unknown,
@@ -1104,6 +1328,27 @@ export class MAPAdapterImpl implements MAPAdapter {
       );
     }
 
+    // Emit client→agent ACP request as a message_sent event so other
+    // TUI clients can observe user prompts and other ACP operations.
+    // Include from/to at top level of data for extractACPFromMessageEvent()
+    // which reads data.from/data.to for targetAgent resolution.
+    this.emitEvent({
+      eventId: ulid(),
+      type: "message_sent" as MAPEventType,
+      timestamp: Date.now(),
+      agentId: targetAgentId,
+      data: {
+        from: participantId,
+        to: targetAgentId,
+        message: {
+          id: `acp-req-${Date.now()}`,
+          from: participantId,
+          to: targetAgentId,
+          payload: envelope,
+        },
+      },
+    });
+
     // Create notification emitter to stream session updates
     const emitNotification = (notification: ACPEnvelope) => {
       this.emitEvent({
@@ -1112,6 +1357,8 @@ export class MAPAdapterImpl implements MAPAdapter {
         timestamp: Date.now(),
         agentId: targetAgentId,
         data: {
+          from: targetAgentId,
+          to: participantId,
           message: {
             id: `acp-notif-${Date.now()}`,
             from: targetAgentId,
@@ -1126,32 +1373,77 @@ export class MAPAdapterImpl implements MAPAdapter {
       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()}`,
+    // Helper to emit the final ACP response to the participant via subscription
+    const emitResponse = (responseEnvelope: ACPEnvelope) => {
+      const participant = this.connections.getParticipant(participantId);
+      if (participant) {
+        this.emitEvent({
+          eventId: ulid(),
+          type: "message_delivered" as MAPEventType,
+          timestamp: Date.now(),
+          agentId: targetAgentId,
+          data: {
             from: targetAgentId,
-            payload: responseEnvelope,
+            to: participantId,
+            message: {
+              id: `acp-resp-${Date.now()}`,
+              from: targetAgentId,
+              payload: responseEnvelope,
+            },
           },
-        },
-      });
+        });
+      }
+    };
+
+    // session/prompt can run for minutes — process it asynchronously so the
+    // map/send RPC returns immediately.  The ACP response will arrive via
+    // subscription (message_delivered event) when the prompt finishes.
+    // Other ACP methods (initialize, session/new, session/load, etc.) are
+    // fast and can be awaited normally.
+    const isLongRunning = acp.method === "session/prompt";
+
+    if (isLongRunning) {
+      this.acpOverMapHandler
+        .processRequest(targetAgentId, acpEnvelope, emitNotification)
+        .then((responseEnvelope) => {
+          console.error(
+            `[ACP-over-MAP] Async prompt completed - method=${acp.method}`,
+          );
+          emitResponse(responseEnvelope);
+        })
+        .catch((error) => {
+          console.error(`[ACP-over-MAP] Async prompt error:`, error);
+          // Emit error response so the client's ACP pending request resolves
+          emitResponse({
+            acp: {
+              jsonrpc: "2.0",
+              id: acp.id,
+              error: {
+                code: -32603,
+                message:
+                  error instanceof Error ? error.message : String(error),
+              },
+            },
+            acpContext: {
+              streamId: acpContext.streamId,
+              sessionId: acpContext.sessionId ?? null,
+              direction: "agent-to-client",
+            },
+          } as ACPEnvelope);
+        });
+    } else {
+      const responseEnvelope =
+        await this.acpOverMapHandler.processRequest(
+          targetAgentId,
+          acpEnvelope,
+          emitNotification,
+        );
+
+      console.error(
+        `[ACP-over-MAP] Request processed - method=${acp.method}`,
+      );
+      emitResponse(responseEnvelope);
     }
 
     return {
@@ -1181,6 +1473,49 @@ export class MAPAdapterImpl implements MAPAdapter {
     return { agent: agent ?? null };
   }
 
+  private async handleStopAgent(
+    _participantId: ParticipantId,
+    params: unknown,
+  ): Promise<{ stopping: boolean; agent?: AgentInfo }> {
+    const { agentId, reason, force } =
+      (params as {
+        agentId?: AgentId;
+        reason?: string;
+        force?: boolean;
+      }) ?? {};
+
+    if (!agentId) {
+      throw RPCError.invalidParams("agentId required");
+    }
+
+    if (!this.services.agentManager) {
+      throw RPCError.internalError("Agent manager not available");
+    }
+
+    // Abort any active ACP streams for this agent
+    if (this.acpOverMapHandler) {
+      this.acpOverMapHandler.abortStreamsForAgent(agentId);
+    }
+
+    // Terminate the agent
+    try {
+      await this.services.agentManager.terminate(
+        agentId,
+        (reason ?? "cancelled") as AgentStopReason,
+      );
+    } catch (error) {
+      console.error(`[MAPAdapter] Error stopping agent ${agentId}:`, error);
+      throw RPCError.internalError(
+        `Failed to stop agent: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+
+    // Note: agent_state_changed and agent_unregistered events are now
+    // emitted by the lifecycle listener (covers all stop paths).
+
+    return { stopping: true };
+  }
+
   private async handleListScopes(
     participantId: ParticipantId,
   ): Promise<{ scopes: ScopeInfo[] }> {

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

@@ -400,8 +400,12 @@ export class SubscriptionManagerImpl implements SubscriptionManager {
     }
 
     // Event type filter (OR within array)
+    // Normalize between underscore format (SDK: "agent_registered") and
+    // dot format (internal: "agent.registered") so subscriptions match
+    // regardless of which convention the client uses.
     if (filter.eventTypes && filter.eventTypes.length > 0) {
-      if (!filter.eventTypes.includes(event.type as MAPEventType)) {
+      const normalizedEventType = event.type.replace(/\./g, "_");
+      if (!filter.eventTypes.some((ft) => ft.replace(/\./g, "_") === normalizedEventType)) {
         return false;
       }
     }

package/src/map/adapter/types.ts

@@ -88,6 +88,8 @@ export interface ParticipantCapabilities {
   canManageTasks?: boolean;
   /** Can manage federation connections (connect/disconnect peers) */
   canManageFederation?: boolean;
+  /** Can manage agent lifecycle (resume, spawn, fork, permissions) */
+  canManageLifecycle?: boolean;
 }
 
 /**