macro-agent 0.1.1 → 0.1.3

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

@@ -1,926 +0,0 @@
-/**
- * Tests for MAPAdapter
- */
-
-import { describe, it, expect, beforeEach, vi, afterEach } 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 { Address, ScopeId } from "../../types.js";
-
-/**
- * Create a mock stream pair for testing.
- */
-function createMockStreamPair(): {
-  clientStream: Stream;
-  serverStream: Stream;
-  clientMessages: unknown[];
-  serverMessages: unknown[];
-  sendToServer: (msg: unknown) => void;
-  sendToClient: (msg: unknown) => void;
-} {
-  const clientMessages: unknown[] = [];
-  const serverMessages: unknown[] = [];
-
-  let clientResolve: ((msg: unknown) => void) | null = null;
-  let serverResolve: ((msg: unknown) => void) | null = null;
-
-  const clientReadable = new ReadableStream<unknown>({
-    start(controller) {
-      clientResolve = (msg) => {
-        clientMessages.push(msg);
-        controller.enqueue(msg);
-      };
-    },
-  });
-
-  const serverReadable = new ReadableStream<unknown>({
-    start(controller) {
-      serverResolve = (msg) => {
-        serverMessages.push(msg);
-        controller.enqueue(msg);
-      };
-    },
-  });
-
-  const clientWritable = new WritableStream<unknown>({
-    write(chunk) {
-      // Client writes go to server
-      serverResolve?.(chunk);
-    },
-  });
-
-  const serverWritable = new WritableStream<unknown>({
-    write(chunk) {
-      // Server writes go to client
-      clientResolve?.(chunk);
-    },
-  });
-
-  return {
-    clientStream: { readable: clientReadable, writable: clientWritable },
-    serverStream: { readable: serverReadable, writable: serverWritable },
-    clientMessages,
-    serverMessages,
-    sendToServer: (msg) => serverResolve?.(msg),
-    sendToClient: (msg) => clientResolve?.(msg),
-  };
-}
-
-/**
- * Create a simple mock stream for basic testing.
- */
-function createSimpleMockStream(): Stream {
-  const messages: unknown[] = [];
-  let resolveRead: ((value: { done: boolean; value?: unknown }) => void) | null = null;
-  let readPromise: Promise<{ done: boolean; value?: unknown }> | null = null;
-
-  const readable = new ReadableStream<unknown>({
-    pull(controller) {
-      return new Promise((resolve) => {
-        resolveRead = (result) => {
-          if (!result.done && result.value !== undefined) {
-            controller.enqueue(result.value);
-          }
-          resolve();
-        };
-      });
-    },
-  });
-
-  const writable = new WritableStream<unknown>({
-    write(chunk) {
-      messages.push(chunk);
-    },
-  });
-
-  return { readable, writable };
-}
-
-describe("MAPAdapter", () => {
-  let adapter: MAPAdapter;
-  let config: MAPAdapterConfig;
-  let services: MAPAdapterServices;
-
-  beforeEach(() => {
-    config = {
-      name: "test-adapter",
-      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();
-    }
-  });
-
-  describe("lifecycle", () => {
-    it("starts and stops", async () => {
-      expect(adapter.isRunning()).toBe(false);
-
-      await adapter.start();
-      expect(adapter.isRunning()).toBe(true);
-
-      await adapter.stop();
-      expect(adapter.isRunning()).toBe(false);
-    });
-
-    it("start is idempotent", async () => {
-      await adapter.start();
-      await adapter.start(); // Should not throw
-      expect(adapter.isRunning()).toBe(true);
-    });
-
-    it("stop is idempotent", async () => {
-      await adapter.start();
-      await adapter.stop();
-      await adapter.stop(); // Should not throw
-      expect(adapter.isRunning()).toBe(false);
-    });
-
-    it("rejects connections when not running", async () => {
-      const stream = createSimpleMockStream();
-
-      await expect(adapter.acceptConnection(stream)).rejects.toThrow(
-        "Adapter not running"
-      );
-    });
-  });
-
-  describe("connection management", () => {
-    beforeEach(async () => {
-      await adapter.start();
-    });
-
-    it("accepts connections and returns participant", async () => {
-      const stream = createSimpleMockStream();
-
-      const participant = await adapter.acceptConnection(stream);
-
-      expect(participant.id).toMatch(/^p-/);
-      expect(participant.type).toBe("client");
-      expect(participant.capabilities).toBeDefined();
-    });
-
-    it("tracks connected participants", async () => {
-      const stream1 = createSimpleMockStream();
-      const stream2 = createSimpleMockStream();
-
-      const p1 = await adapter.acceptConnection(stream1);
-      const p2 = await adapter.acceptConnection(stream2);
-
-      const participants = adapter.getParticipants();
-      expect(participants).toHaveLength(2);
-      expect(participants.map((p) => p.id)).toContain(p1.id);
-      expect(participants.map((p) => p.id)).toContain(p2.id);
-    });
-
-    it("retrieves participant by ID", async () => {
-      const stream = createSimpleMockStream();
-      const participant = await adapter.acceptConnection(stream);
-
-      const retrieved = adapter.getParticipant(participant.id);
-      expect(retrieved).toBeDefined();
-      expect(retrieved?.id).toBe(participant.id);
-    });
-
-    it("disconnects participant", async () => {
-      const stream = createSimpleMockStream();
-      const participant = await adapter.acceptConnection(stream);
-
-      expect(adapter.getParticipant(participant.id)).toBeDefined();
-
-      await adapter.disconnectParticipant(participant.id, "test");
-
-      expect(adapter.getParticipant(participant.id)).toBeUndefined();
-    });
-
-    it("emits participant events", async () => {
-      const events: Array<{ type: string }> = [];
-      adapter.onEvent((e) => events.push(e));
-
-      const stream = createSimpleMockStream();
-      const participant = await adapter.acceptConnection(stream);
-
-      expect(events.some((e) => e.type === "participant.connected")).toBe(true);
-
-      await adapter.disconnectParticipant(participant.id);
-
-      expect(events.some((e) => e.type === "participant.disconnected")).toBe(true);
-    });
-  });
-
-  describe("authentication", () => {
-    it("calls authenticate handler when credentials provided", async () => {
-      const authenticateFn = vi.fn().mockResolvedValue({
-        allowed: true,
-        capabilities: {
-          canQuery: true,
-          canSubscribe: true,
-          canMessage: true,
-          canSpawn: true,
-        },
-      });
-
-      const authAdapter = createMAPAdapter({
-        authenticate: authenticateFn,
-      });
-      await authAdapter.start();
-
-      const stream = createSimpleMockStream();
-      const participant = await authAdapter.acceptConnection(stream);
-
-      // Simulate map/connect RPC call with credentials
-      // The handleConnect is called internally - we verify via the mock
-      expect(participant.capabilities).toBeDefined();
-
-      await authAdapter.stop();
-    });
-
-    it("rejects authentication when handler returns allowed=false", async () => {
-      const authenticateFn = vi.fn().mockResolvedValue({
-        allowed: false,
-        error: "Invalid token",
-      });
-
-      const authAdapter = createMAPAdapter({
-        authenticate: authenticateFn,
-      });
-      await authAdapter.start();
-
-      // Create adapter instance to test handleConnect directly
-      const stream = createSimpleMockStream();
-      await authAdapter.acceptConnection(stream);
-
-      // The actual rejection happens during handleConnect RPC call
-      // which requires a full RPC roundtrip - verify handler is configured
-      expect(authenticateFn).not.toHaveBeenCalled(); // Not called until RPC
-
-      await authAdapter.stop();
-    });
-
-    it("uses default client capabilities when no auth handler", async () => {
-      const noAuthAdapter = createMAPAdapter({
-        defaultClientCapabilities: {
-          canQuery: true,
-          canSubscribe: false,
-          canMessage: false,
-        },
-      });
-      await noAuthAdapter.start();
-
-      const stream = createSimpleMockStream();
-      const participant = await noAuthAdapter.acceptConnection(stream);
-
-      // Initial connection uses anonymous capabilities
-      expect(participant.capabilities.canQuery).toBe(true);
-
-      await noAuthAdapter.stop();
-    });
-
-    it("uses default agent capabilities for agent type", async () => {
-      const agentAdapter = createMAPAdapter({
-        defaultAgentCapabilities: {
-          canQuery: true,
-          canSubscribe: true,
-          canMessage: true,
-          canSpawn: true,
-          canStop: true,
-        },
-      });
-      await agentAdapter.start();
-
-      const stream = createSimpleMockStream();
-      await agentAdapter.acceptConnection(stream);
-
-      // Verify configuration is stored
-      expect(agentAdapter.config.defaultAgentCapabilities?.canSpawn).toBe(true);
-
-      await agentAdapter.stop();
-    });
-  });
-
-  describe("subscriptions", () => {
-    let participantId: ParticipantId;
-
-    beforeEach(async () => {
-      await adapter.start();
-      const stream = createSimpleMockStream();
-      const participant = await adapter.acceptConnection(stream);
-      participantId = participant.id;
-    });
-
-    it("creates subscription", async () => {
-      const subscriptionId = await adapter.createSubscription(participantId, {
-        eventTypes: ["agent.registered"],
-      });
-
-      expect(subscriptionId).toMatch(/^sub-/);
-    });
-
-    it("lists subscriptions for participant", async () => {
-      const sub1 = await adapter.createSubscription(participantId);
-      const sub2 = await adapter.createSubscription(participantId);
-
-      const subscriptions = adapter.getSubscriptions(participantId);
-
-      expect(subscriptions).toHaveLength(2);
-      expect(subscriptions).toContain(sub1);
-      expect(subscriptions).toContain(sub2);
-    });
-
-    it("removes subscription", async () => {
-      const subscriptionId = await adapter.createSubscription(participantId);
-      expect(adapter.getSubscriptions(participantId)).toHaveLength(1);
-
-      await adapter.removeSubscription(subscriptionId);
-
-      expect(adapter.getSubscriptions(participantId)).toHaveLength(0);
-    });
-
-    it("pauses and resumes subscription", async () => {
-      const subscriptionId = await adapter.createSubscription(participantId);
-
-      await adapter.pauseSubscription(subscriptionId);
-      // Paused subscription would not receive events (tested via emitEvent)
-
-      await adapter.resumeSubscription(subscriptionId);
-      // Resumed subscription would receive events again
-    });
-
-    it("cleans up subscriptions on disconnect", async () => {
-      await adapter.createSubscription(participantId);
-      await adapter.createSubscription(participantId);
-
-      expect(adapter.getSubscriptions(participantId)).toHaveLength(2);
-
-      await adapter.disconnectParticipant(participantId);
-
-      expect(adapter.getSubscriptions(participantId)).toHaveLength(0);
-    });
-
-    it("emits subscription events", async () => {
-      const events: Array<{ type: string }> = [];
-      adapter.onEvent((e) => events.push(e));
-
-      const subscriptionId = await adapter.createSubscription(participantId);
-
-      expect(events.some((e) => e.type === "subscription.created")).toBe(true);
-
-      await adapter.removeSubscription(subscriptionId);
-
-      expect(events.some((e) => e.type === "subscription.removed")).toBe(true);
-    });
-  });
-
-  describe("queries", () => {
-    let participantId: ParticipantId;
-
-    beforeEach(async () => {
-      await adapter.start();
-      const stream = createSimpleMockStream();
-      const participant = await adapter.acceptConnection(stream);
-      participantId = participant.id;
-    });
-
-    it("lists agents via service", () => {
-      const mockAgents = [
-        { id: "agent-1" as AgentId, state: "running", createdAt: Date.now() },
-        { id: "agent-2" as AgentId, state: "running", createdAt: Date.now() },
-      ];
-      (services.listAgents as ReturnType<typeof vi.fn>).mockReturnValue(mockAgents);
-
-      const agents = adapter.listAgents(participantId);
-
-      expect(agents).toHaveLength(2);
-      expect(services.listAgents).toHaveBeenCalled();
-    });
-
-    it("gets agent via service", () => {
-      const mockAgent = {
-        id: "agent-1" as AgentId,
-        name: "Test Agent",
-        state: "running",
-        createdAt: Date.now(),
-      };
-      (services.getAgent as ReturnType<typeof vi.fn>).mockReturnValue(mockAgent);
-
-      const agent = adapter.getAgent(participantId, "agent-1" as AgentId);
-
-      expect(agent).toBeDefined();
-      expect(agent?.id).toBe("agent-1");
-      expect(services.getAgent).toHaveBeenCalledWith("agent-1");
-    });
-
-    it("returns empty for unknown participant", () => {
-      const agents = adapter.listAgents("unknown" as ParticipantId);
-      expect(agents).toEqual([]);
-    });
-  });
-
-  describe("scopes", () => {
-    let participantId: ParticipantId;
-
-    beforeEach(async () => {
-      // Enable scope management capability
-      config.defaultClientCapabilities = {
-        canQuery: true,
-        canSubscribe: true,
-        canMessage: true,
-        canManageScopes: true,
-      };
-      adapter = createMAPAdapter(config, services);
-
-      await adapter.start();
-      const stream = createSimpleMockStream();
-      const participant = await adapter.acceptConnection(stream);
-      participantId = participant.id;
-    });
-
-    it("creates scope via internal method", () => {
-      const impl = adapter as MAPAdapterImpl;
-      const scopeId = impl.createScope("test-scope", { key: "value" });
-
-      expect(scopeId).toMatch(/^scope-/);
-
-      const scope = adapter.getScope(participantId, scopeId);
-      expect(scope?.name).toBe("test-scope");
-      expect(scope?.metadata).toEqual({ key: "value" });
-    });
-
-    it("lists scopes", () => {
-      const impl = adapter as MAPAdapterImpl;
-      impl.createScope("scope-1");
-      impl.createScope("scope-2");
-
-      const scopes = adapter.listScopes(participantId);
-
-      expect(scopes).toHaveLength(2);
-    });
-
-    it("joins and leaves scope", () => {
-      const impl = adapter as MAPAdapterImpl;
-      const scopeId = impl.createScope("test-scope");
-      const agentId = "agent-1" as AgentId;
-
-      impl.joinScope(scopeId, agentId);
-
-      let scope = adapter.getScope(participantId, scopeId);
-      expect(scope?.members).toContain(agentId);
-
-      impl.leaveScope(scopeId, agentId);
-
-      scope = adapter.getScope(participantId, scopeId);
-      expect(scope?.members).not.toContain(agentId);
-    });
-
-    it("deletes scope", () => {
-      const impl = adapter as MAPAdapterImpl;
-      const scopeId = impl.createScope("test-scope");
-
-      expect(adapter.getScope(participantId, scopeId)).toBeDefined();
-
-      impl.deleteScope(scopeId);
-
-      expect(adapter.getScope(participantId, scopeId)).toBeUndefined();
-    });
-  });
-
-  describe("extensions", () => {
-    beforeEach(async () => {
-      await adapter.start();
-    });
-
-    it("registers extension method", () => {
-      const handler = vi.fn();
-
-      adapter.registerExtension("_macro/test/method", handler);
-
-      expect(adapter.hasExtension("_macro/test/method")).toBe(true);
-      expect(adapter.getExtensions()).toContain("_macro/test/method");
-    });
-
-    it("rejects invalid extension method name", () => {
-      expect(() => adapter.registerExtension("invalid/method", vi.fn())).toThrow(
-        'must start with "_macro/"'
-      );
-    });
-
-    it("unregisters extension method", () => {
-      adapter.registerExtension("_macro/test/method", vi.fn());
-      expect(adapter.hasExtension("_macro/test/method")).toBe(true);
-
-      adapter.unregisterExtension("_macro/test/method");
-
-      expect(adapter.hasExtension("_macro/test/method")).toBe(false);
-    });
-  });
-
-  describe("event emission", () => {
-    let participantId: ParticipantId;
-
-    beforeEach(async () => {
-      await adapter.start();
-      const stream = createSimpleMockStream();
-      const participant = await adapter.acceptConnection(stream);
-      participantId = participant.id;
-    });
-
-    it("matches events to subscriptions", async () => {
-      await adapter.createSubscription(participantId, {
-        eventTypes: ["agent.registered"],
-      });
-
-      const event: EventNotification = {
-        eventId: "evt-1",
-        type: "agent.registered",
-        timestamp: Date.now(),
-        data: { agentId: "agent-1" },
-        agentId: "agent-1" as AgentId,
-      };
-
-      // This should not throw - event is emitted to matching subscribers
-      adapter.emitEvent(event);
-    });
-
-    it("emits agent_registered events to underscore-format subscriptions", async () => {
-      // SDK clients subscribe with underscore format (e.g., "agent_registered")
-      await adapter.createSubscription(participantId, {
-        eventTypes: ["agent_registered"],
-      });
-
-      const event: EventNotification = {
-        eventId: "evt-reg-1",
-        type: "agent_registered",
-        timestamp: Date.now(),
-        data: {
-          agentId: "agent-new",
-          name: "Spawned Worker",
-          role: "worker",
-          parent: "agent-parent",
-        },
-        agentId: "agent-new" as AgentId,
-      };
-
-      // Should not throw - underscore event matches underscore subscription
-      adapter.emitEvent(event);
-    });
-
-    it("emits agent_state_changed events with data payload", async () => {
-      await adapter.createSubscription(participantId, {
-        eventTypes: ["agent_state_changed"],
-      });
-
-      const event: EventNotification = {
-        eventId: "evt-state-1",
-        type: "agent_state_changed",
-        timestamp: Date.now(),
-        agentId: "agent-1" as AgentId,
-        data: {
-          agentId: "agent-1",
-          current: "stopped",
-          previous: "running",
-          reason: "cancelled",
-        },
-      };
-
-      adapter.emitEvent(event);
-    });
-
-    it("emits agent_unregistered events with data payload", async () => {
-      await adapter.createSubscription(participantId, {
-        eventTypes: ["agent_unregistered"],
-      });
-
-      const event: EventNotification = {
-        eventId: "evt-unreg-1",
-        type: "agent_unregistered",
-        timestamp: Date.now(),
-        agentId: "agent-1" as AgentId,
-        data: {
-          agentId: "agent-1",
-          reason: "cancelled",
-        },
-      };
-
-      adapter.emitEvent(event);
-    });
-
-    it("logs agent lifecycle events in event log for replay", async () => {
-      const impl = adapter as MAPAdapterImpl;
-
-      // Emit agent_registered
-      impl.emitEvent({
-        eventId: "evt-1",
-        type: "agent_registered",
-        timestamp: 1000,
-        agentId: "agent-1" as AgentId,
-        data: { agentId: "agent-1", name: "Worker" },
-      });
-
-      // Emit agent_state_changed
-      impl.emitEvent({
-        eventId: "evt-2",
-        type: "agent_state_changed",
-        timestamp: 2000,
-        agentId: "agent-1" as AgentId,
-        data: { agentId: "agent-1", current: "stopped", previous: "running" },
-      });
-
-      // Emit agent_unregistered
-      impl.emitEvent({
-        eventId: "evt-3",
-        type: "agent_unregistered",
-        timestamp: 3000,
-        agentId: "agent-1" as AgentId,
-        data: { agentId: "agent-1", reason: "cancelled" },
-      });
-
-      // Query the event log - all three events should be stored
-      const eventLog = (impl as unknown as { eventLog: { query: (p: unknown) => { events: unknown[]; hasMore: boolean } } }).eventLog;
-      const result = eventLog.query({ limit: 100 });
-      expect(result.events.length).toBeGreaterThanOrEqual(3);
-    });
-  });
-
-  describe("messaging", () => {
-    let participantId: ParticipantId;
-
-    beforeEach(async () => {
-      await adapter.start();
-      const stream = createSimpleMockStream();
-      const participant = await adapter.acceptConnection(stream);
-      participantId = participant.id;
-    });
-
-    it("sends message via service", async () => {
-      (services.sendMessage as ReturnType<typeof vi.fn>).mockResolvedValue({
-        delivered: ["agent-1"] as AgentId[],
-      });
-
-      const result = await adapter.sendMessage(
-        participantId,
-        { agent: "agent-1" as AgentId } as Address,
-        { content: "Hello" },
-        { priority: "normal" }
-      );
-
-      expect(result.messageId).toMatch(/^msg-/);
-      expect(result.delivered).toEqual(["agent-1"]);
-      expect(services.sendMessage).toHaveBeenCalled();
-    });
-
-    it("throws for participant without messaging capability", async () => {
-      // Create adapter without message capability
-      config.defaultClientCapabilities = {
-        canQuery: true,
-        canSubscribe: true,
-        canMessage: false, // Disabled
-      };
-      adapter = createMAPAdapter(config, services);
-      await adapter.start();
-
-      const stream = createSimpleMockStream();
-      const participant = await adapter.acceptConnection(stream);
-
-      await expect(
-        adapter.sendMessage(
-          participant.id,
-          { agent: "agent-1" as AgentId } as Address,
-          { content: "Hello" }
-        )
-      ).rejects.toThrow("Messaging not allowed");
-    });
-  });
-
-  describe("configuration", () => {
-    it("uses default config values", () => {
-      const defaultAdapter = createMAPAdapter();
-
-      expect(defaultAdapter.config.name).toBe("macro-agent");
-      expect(defaultAdapter.config.version).toBe("1.0.0");
-    });
-
-    it("uses provided config values", () => {
-      const customAdapter = createMAPAdapter({
-        name: "custom-adapter",
-        version: "2.0.0",
-      });
-
-      expect(customAdapter.config.name).toBe("custom-adapter");
-      expect(customAdapter.config.version).toBe("2.0.0");
-    });
-  });
-
-  describe("onEvent", () => {
-    it("returns unsubscribe function", async () => {
-      await adapter.start();
-
-      const events: Array<{ type: string }> = [];
-      const unsubscribe = adapter.onEvent((e) => events.push(e));
-
-      const stream = createSimpleMockStream();
-      await adapter.acceptConnection(stream);
-      expect(events.length).toBeGreaterThan(0);
-
-      const countBefore = events.length;
-      unsubscribe();
-
-      await adapter.acceptConnection(createSimpleMockStream());
-      expect(events.length).toBe(countBefore); // No new events
-    });
-  });
-
-  describe("federation", () => {
-    const mockFederationHandler = {
-      connect: vi.fn(),
-      disconnect: vi.fn(),
-      listPeers: vi.fn(),
-      getCapabilities: vi.fn(),
-      getPeer: vi.fn(),
-      isConnected: vi.fn(),
-      sendMessage: vi.fn(),
-      sendRequest: vi.fn(),
-      on: vi.fn(() => () => {}),
-      getConfig: vi.fn(() => ({ enabled: true, systemId: "local-system" })),
-      getLocalCapabilities: vi.fn(),
-    };
-
-    beforeEach(() => {
-      vi.clearAllMocks();
-      services.federationHandler = mockFederationHandler;
-      config.defaultClientCapabilities = {
-        canQuery: true,
-        canSubscribe: true,
-        canMessage: true,
-        canManageFederation: true,
-      };
-      adapter = createMAPAdapter(config, services);
-    });
-
-    describe("handleFederationList", () => {
-      it("returns empty list when no peers connected", async () => {
-        mockFederationHandler.listPeers.mockReturnValue([]);
-
-        await adapter.start();
-        const stream = createSimpleMockStream();
-        const participant = await adapter.acceptConnection(stream);
-
-        // Test via direct call since we can't easily test RPC handlers
-        const peers = services.federationHandler!.listPeers();
-        expect(peers).toEqual([]);
-      });
-
-      it("returns connected peers", async () => {
-        mockFederationHandler.listPeers.mockReturnValue([
-          { systemId: "peer-1", status: "connected", connectedAt: 1000 },
-          { systemId: "peer-2", status: "connected", connectedAt: 2000 },
-        ]);
-
-        const peers = services.federationHandler!.listPeers();
-        expect(peers).toHaveLength(2);
-        expect(peers[0].systemId).toBe("peer-1");
-      });
-    });
-
-    describe("handleFederationConnect", () => {
-      it("connects to peer and returns capabilities", async () => {
-        const mockCapabilities = {
-          systemId: "peer-system",
-          messaging: { canSend: true, canReceive: true },
-          lifecycle: { canSpawn: false, canStop: false },
-          query: { canListAgents: true, canGetAgent: true, canQueryHierarchy: true },
-          extensions: ["_macro/task/*"],
-        };
-        mockFederationHandler.connect.mockResolvedValue(mockCapabilities);
-
-        await adapter.start();
-
-        const result = await mockFederationHandler.connect({
-          systemId: "peer-system",
-          endpoint: "ws://peer:8080",
-        });
-
-        expect(result).toEqual(mockCapabilities);
-        expect(mockFederationHandler.connect).toHaveBeenCalledWith({
-          systemId: "peer-system",
-          endpoint: "ws://peer:8080",
-        });
-      });
-    });
-
-    describe("handleFederationDisconnect", () => {
-      it("disconnects from peer", async () => {
-        mockFederationHandler.disconnect.mockResolvedValue(undefined);
-
-        await adapter.start();
-
-        await mockFederationHandler.disconnect("peer-system");
-
-        expect(mockFederationHandler.disconnect).toHaveBeenCalledWith("peer-system");
-      });
-    });
-
-    describe("handleFederationCapabilities", () => {
-      it("returns capabilities for connected peer", async () => {
-        const mockCapabilities = {
-          systemId: "peer-system",
-          messaging: { canSend: true, canReceive: true },
-          lifecycle: { canSpawn: false, canStop: false },
-          query: { canListAgents: true, canGetAgent: true, canQueryHierarchy: true },
-          extensions: [],
-        };
-        mockFederationHandler.getCapabilities.mockReturnValue(mockCapabilities);
-
-        await adapter.start();
-
-        const caps = mockFederationHandler.getCapabilities("peer-system");
-        expect(caps).toEqual(mockCapabilities);
-      });
-
-      it("returns undefined for unknown peer", async () => {
-        mockFederationHandler.getCapabilities.mockReturnValue(undefined);
-
-        await adapter.start();
-
-        const caps = mockFederationHandler.getCapabilities("unknown");
-        expect(caps).toBeUndefined();
-      });
-    });
-
-    describe("capability enforcement", () => {
-      it("requires canManageFederation for connect", async () => {
-        // Create adapter with restricted capabilities
-        config.defaultClientCapabilities = {
-          canQuery: true,
-          canSubscribe: true,
-          canMessage: true,
-          canManageFederation: false, // No federation management
-        };
-        const restrictedAdapter = createMAPAdapter(config, services);
-        await restrictedAdapter.start();
-
-        const stream = createSimpleMockStream();
-        const participant = await restrictedAdapter.acceptConnection(stream);
-
-        // Participant should not have canManageFederation
-        expect(participant.capabilities.canManageFederation).toBe(false);
-      });
-
-      it("requires canManageFederation for disconnect", async () => {
-        config.defaultClientCapabilities = {
-          canQuery: true,
-          canSubscribe: true,
-          canMessage: true,
-          canManageFederation: false,
-        };
-        const restrictedAdapter = createMAPAdapter(config, services);
-        await restrictedAdapter.start();
-
-        const stream = createSimpleMockStream();
-        const participant = await restrictedAdapter.acceptConnection(stream);
-
-        expect(participant.capabilities.canManageFederation).toBe(false);
-      });
-
-      it("allows canQuery for federation list and capabilities", async () => {
-        config.defaultClientCapabilities = {
-          canQuery: true,
-          canSubscribe: false,
-          canMessage: false,
-          canManageFederation: false,
-        };
-        const queryOnlyAdapter = createMAPAdapter(config, services);
-        await queryOnlyAdapter.start();
-
-        const stream = createSimpleMockStream();
-        const participant = await queryOnlyAdapter.acceptConnection(stream);
-
-        // Should have canQuery for read operations
-        expect(participant.capabilities.canQuery).toBe(true);
-        // But not canManageFederation for write operations
-        expect(participant.capabilities.canManageFederation).toBe(false);
-      });
-    });
-  });
-});