@multi-agent-protocol/sdk 0.0.5 → 0.0.7

package/dist/index.cjs

@@ -1,9 +1,89 @@
 'use strict';
 
+var agenticMesh = require('agentic-mesh');
 var ulid = require('ulid');
 var events = require('events');
 var zod = require('zod');
 
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/stream/agentic-mesh.ts
+var agentic_mesh_exports = {};
+__export(agentic_mesh_exports, {
+  agenticMeshStream: () => agenticMeshStream
+});
+async function agenticMeshStream(config) {
+  if (!config.transport.active) {
+    await config.transport.start();
+  }
+  const connected = await config.transport.connect(config.peer);
+  if (!connected) {
+    throw new Error(`Failed to connect to peer: ${config.peer.peerId}`);
+  }
+  const streamId = `map-${config.localPeerId}-${Date.now()}`;
+  const tunnelStream = new agenticMesh.TunnelStream({
+    transport: config.transport,
+    peerId: config.peer.peerId,
+    streamId
+  });
+  await tunnelStream.open();
+  return tunnelStreamToMapStream(tunnelStream);
+}
+function tunnelStreamToMapStream(tunnel) {
+  let readingAborted = false;
+  const readable = new ReadableStream({
+    async start(controller) {
+      try {
+        for await (const frame of tunnel) {
+          if (readingAborted) break;
+          controller.enqueue(frame);
+        }
+        if (!readingAborted) {
+          controller.close();
+        }
+      } catch (error) {
+        if (!readingAborted) {
+          controller.error(error);
+        }
+      }
+    },
+    cancel() {
+      readingAborted = true;
+      tunnel.close().catch(() => {
+      });
+    }
+  });
+  const writable = new WritableStream({
+    async write(message) {
+      if (!tunnel.isOpen) {
+        throw new Error("Stream is not open");
+      }
+      await tunnel.write(message);
+    },
+    async close() {
+      await tunnel.close();
+    },
+    abort() {
+      readingAborted = true;
+      tunnel.close().catch(() => {
+      });
+    }
+  });
+  return { readable, writable };
+}
+var init_agentic_mesh = __esm({
+  "src/stream/agentic-mesh.ts"() {
+  }
+});
+
 // src/types/index.ts
 function isOrphanedAgent(agent) {
   return agent.ownerId === null;
@@ -89,6 +169,7 @@ var SESSION_METHODS = {
   SESSION_CLOSE: "map/session/close"
 };
 var AUTH_METHODS = {
+  AUTHENTICATE: "map/authenticate",
   AUTH_REFRESH: "map/auth/refresh"
 };
 var PERMISSION_METHODS = {
@@ -102,7 +183,9 @@ var NOTIFICATION_METHODS = {
   EVENT: "map/event",
   MESSAGE: "map/message",
   /** Client acknowledges received events (for backpressure) */
-  SUBSCRIBE_ACK: "map/subscribe.ack"
+  SUBSCRIBE_ACK: "map/subscribe.ack",
+  /** Server notifies client that auth is about to expire */
+  AUTH_EXPIRING: "map/auth/expiring"
 };
 var MAP_METHODS = {
   ...CORE_METHODS,
@@ -137,7 +220,10 @@ var AUTH_ERROR_CODES = {
   AUTH_REQUIRED: 1e3,
   AUTH_FAILED: 1001,
   TOKEN_EXPIRED: 1002,
-  PERMISSION_DENIED: 1003
+  PERMISSION_DENIED: 1003,
+  INSUFFICIENT_SCOPE: 1004,
+  METHOD_NOT_SUPPORTED: 1005,
+  INVALID_CREDENTIALS: 1006
 };
 var ROUTING_ERROR_CODES = {
   ADDRESS_NOT_FOUND: 2e3,
@@ -211,7 +297,8 @@ var CAPABILITY_REQUIREMENTS = {
   [SESSION_METHODS.SESSION_LIST]: [],
   [SESSION_METHODS.SESSION_LOAD]: [],
   [SESSION_METHODS.SESSION_CLOSE]: [],
-  // Auth
+  // Auth (no capability required - anyone can authenticate)
+  [AUTH_METHODS.AUTHENTICATE]: [],
   [AUTH_METHODS.AUTH_REFRESH]: [],
   // Permissions (system-only, no capability check - enforced by participant type)
   [PERMISSION_METHODS.PERMISSIONS_UPDATE]: [],
@@ -382,6 +469,27 @@ var MAPRequestError = class _MAPRequestError extends Error {
       { category: "auth" }
     );
   }
+  static insufficientScope(required) {
+    return new _MAPRequestError(
+      AUTH_ERROR_CODES.INSUFFICIENT_SCOPE,
+      required ? `Insufficient scope: ${required}` : "Insufficient scope",
+      { category: "auth" }
+    );
+  }
+  static methodNotSupported(method) {
+    return new _MAPRequestError(
+      AUTH_ERROR_CODES.METHOD_NOT_SUPPORTED,
+      `Authentication method not supported: ${method}`,
+      { category: "auth" }
+    );
+  }
+  static invalidCredentials(details) {
+    return new _MAPRequestError(
+      AUTH_ERROR_CODES.INVALID_CREDENTIALS,
+      details ?? "Invalid credentials",
+      { category: "auth" }
+    );
+  }
   // ==========================================================================
   // Routing Errors (2xxx)
   // ==========================================================================
@@ -563,6 +671,7 @@ var MAPTimeoutError = class extends Error {
 };
 
 // src/stream/index.ts
+init_agentic_mesh();
 function ndJsonStream(readable, writable) {
   const encoder = new TextEncoder();
   const decoder = new TextDecoder();
@@ -2394,6 +2503,33 @@ var ACPStreamConnection = class extends events.EventEmitter {
     });
   }
   // ===========================================================================
+  // Extension Methods
+  // ===========================================================================
+  /**
+   * Call an ACP extension method on the target agent.
+   *
+   * Extension methods are prefixed with "_" (e.g., "_macro/spawnAgent").
+   * The agent must support the extension for this to succeed.
+   *
+   * @param method - The extension method name (e.g., "_macro/spawnAgent")
+   * @param params - Parameters to pass to the extension method
+   * @returns The result from the extension method
+   *
+   * @example
+   * ```typescript
+   * const result = await acp.callExtension("_macro/spawnAgent", {
+   *   task: "Implement feature X",
+   *   cwd: "/project"
+   * });
+   * ```
+   */
+  async callExtension(method, params) {
+    if (!this.#initialized) {
+      throw new Error("Must call initialize() before callExtension()");
+    }
+    return this.#sendRequest(method, params);
+  }
+  // ===========================================================================
   // Lifecycle
   // ===========================================================================
   /**
@@ -2435,6 +2571,8 @@ var ClientConnection = class _ClientConnection {
   #connected = false;
   #lastConnectOptions;
   #isReconnecting = false;
+  #lastResumeToken;
+  #onTokenExpiring;
   constructor(stream, options = {}) {
     this.#connection = new BaseConnection(stream, options);
     this.#options = options;
@@ -2500,11 +2638,70 @@ var ClientConnection = class _ClientConnection {
     await client.connect({ auth: options?.auth });
     return client;
   }
+  /**
+   * Connect to a MAP server via agentic-mesh transport.
+   *
+   * Handles:
+   * - Dynamic import of agentic-mesh (optional peer dependency)
+   * - Stream creation over encrypted mesh tunnel
+   * - Auto-configuration of createStream for reconnection
+   * - Initial MAP protocol connect handshake
+   *
+   * Requires `agentic-mesh` to be installed as a peer dependency.
+   *
+   * @param options - Mesh connection options
+   * @returns Connected ClientConnection instance
+   *
+   * @example
+   * ```typescript
+   * import { createNebulaTransport } from 'agentic-mesh';
+   *
+   * const transport = createNebulaTransport({
+   *   configPath: '/etc/nebula/config.yml',
+   * });
+   *
+   * const client = await ClientConnection.connectMesh({
+   *   transport,
+   *   peer: { peerId: 'server', address: '10.0.0.1', port: 4242 },
+   *   localPeerId: 'my-client',
+   *   name: 'MeshClient',
+   *   reconnection: true
+   * });
+   *
+   * const agents = await client.listAgents();
+   * ```
+   */
+  static async connectMesh(options) {
+    const { agenticMeshStream: agenticMeshStream2 } = await Promise.resolve().then(() => (init_agentic_mesh(), agentic_mesh_exports));
+    const streamConfig = {
+      transport: options.transport,
+      peer: options.peer,
+      localPeerId: options.localPeerId,
+      timeout: options.timeout
+    };
+    const stream = await agenticMeshStream2(streamConfig);
+    const createStream = async () => agenticMeshStream2(streamConfig);
+    const reconnection = options.reconnection === true ? { enabled: true } : typeof options.reconnection === "object" ? options.reconnection : void 0;
+    const client = new _ClientConnection(stream, {
+      name: options.name,
+      capabilities: options.capabilities,
+      createStream,
+      reconnection
+    });
+    await client.connect({ auth: options.auth });
+    return client;
+  }
   // ===========================================================================
   // Connection Lifecycle
   // ===========================================================================
   /**
    * Connect to the MAP system
+   *
+   * @param options - Connection options
+   * @param options.sessionId - Specific session ID to use
+   * @param options.resumeToken - Token to resume a previously disconnected session
+   * @param options.auth - Authentication credentials
+   * @param options.onTokenExpiring - Callback invoked before token expires for proactive refresh
    */
   async connect(options) {
     const params = {
@@ -2520,10 +2717,134 @@ var ClientConnection = class _ClientConnection {
     this.#sessionId = result.sessionId;
     this.#serverCapabilities = result.capabilities;
     this.#connected = true;
+    if (result.resumeToken) {
+      this.#lastResumeToken = result.resumeToken;
+    }
+    if (options?.onTokenExpiring) {
+      this.#onTokenExpiring = options.onTokenExpiring;
+      this.#setupTokenExpiryMonitoring(result);
+    }
     this.#connection._transitionTo("connected");
     this.#lastConnectOptions = options;
     return result;
   }
+  /**
+   * Get the resume token for this session.
+   * Can be used to reconnect and restore session state after disconnection.
+   *
+   * @returns The resume token, or undefined if not available
+   */
+  getResumeToken() {
+    return this.#lastResumeToken;
+  }
+  /**
+   * Reconnect to the server, optionally using a resume token to restore session.
+   *
+   * @param resumeToken - Token to resume previous session. If not provided, uses the last known token.
+   * @returns Connect response result
+   *
+   * @example
+   * ```typescript
+   * // Save token before disconnect
+   * const token = await client.disconnect();
+   *
+   * // Later, reconnect with the token
+   * const result = await client.reconnect(token);
+   * console.log('Reconnected:', result.reconnected);
+   * ```
+   */
+  async reconnect(resumeToken) {
+    const tokenToUse = resumeToken ?? this.#lastResumeToken;
+    return this.connect({
+      ...this.#lastConnectOptions,
+      resumeToken: tokenToUse
+    });
+  }
+  /**
+   * Set up monitoring for token expiration
+   */
+  #setupTokenExpiryMonitoring(connectResult) {
+    const principal = connectResult.principal;
+    if (!principal?.expiresAt || !this.#onTokenExpiring) {
+      return;
+    }
+    const expiresAt = principal.expiresAt;
+    const now = Date.now();
+    const warningTime = expiresAt - 6e4;
+    const delay = warningTime - now;
+    if (delay > 0) {
+      setTimeout(async () => {
+        if (!this.#connected || !this.#onTokenExpiring) return;
+        try {
+          const newCredentials = await this.#onTokenExpiring(expiresAt);
+          if (newCredentials) {
+            const refreshResult = await this.refreshAuth({
+              method: newCredentials.method,
+              credential: newCredentials.credential
+            });
+            if (refreshResult.success && refreshResult.principal?.expiresAt) {
+              this.#setupTokenExpiryMonitoring({
+                ...connectResult,
+                principal: refreshResult.principal
+              });
+            }
+          }
+        } catch {
+        }
+      }, delay);
+    }
+  }
+  /**
+   * Authenticate with the server after connection.
+   *
+   * Use this when the server returns `authRequired` in the connect response,
+   * indicating that authentication is needed before accessing protected resources.
+   *
+   * @param auth - Authentication credentials
+   * @returns Authentication result with principal if successful
+   *
+   * @example
+   * ```typescript
+   * const connectResult = await client.connect();
+   *
+   * if (connectResult.authRequired) {
+   *   const authResult = await client.authenticate({
+   *     method: 'api-key',
+   *     credential: process.env.API_KEY,
+   *   });
+   *
+   *   if (authResult.success) {
+   *     console.log('Authenticated as:', authResult.principal?.id);
+   *   }
+   * }
+   * ```
+   */
+  async authenticate(auth) {
+    const params = {
+      method: auth.method,
+      credential: auth.credential
+    };
+    const result = await this.#connection.sendRequest(AUTH_METHODS.AUTHENTICATE, params);
+    if (result.success && result.sessionId) {
+      this.#sessionId = result.sessionId;
+    }
+    return result;
+  }
+  /**
+   * Refresh authentication credentials.
+   *
+   * Use this to update credentials before they expire for long-lived connections.
+   *
+   * @param auth - New authentication credentials
+   * @returns Updated principal information
+   */
+  async refreshAuth(auth) {
+    const params = {
+      method: auth.method,
+      credential: auth.credential
+    };
+    return this.#connection.sendRequest(AUTH_METHODS.AUTH_REFRESH, params);
+  }
   /**
    * Disconnect from the MAP system
    * @param reason - Optional reason for disconnecting
@@ -2538,6 +2859,9 @@ var ClientConnection = class _ClientConnection {
         reason ? { reason } : void 0
       );
       resumeToken = result.resumeToken;
+      if (resumeToken) {
+        this.#lastResumeToken = resumeToken;
+      }
     } finally {
       for (const stream of this.#acpStreams.values()) {
         await stream.close();
@@ -3231,6 +3555,66 @@ var AgentConnection = class _AgentConnection {
     await agent.connect({ auth: options?.auth });
     return agent;
   }
+  /**
+   * Connect and register an agent via agentic-mesh transport.
+   *
+   * Handles:
+   * - Dynamic import of agentic-mesh (optional peer dependency)
+   * - Stream creation over encrypted mesh tunnel
+   * - Auto-configuration of createStream for reconnection
+   * - Initial MAP protocol connect handshake
+   * - Agent registration
+   *
+   * Requires `agentic-mesh` to be installed as a peer dependency.
+   *
+   * @param options - Mesh connection and agent options
+   * @returns Connected and registered AgentConnection instance
+   *
+   * @example
+   * ```typescript
+   * import { createNebulaTransport } from 'agentic-mesh';
+   *
+   * const transport = createNebulaTransport({
+   *   configPath: '/etc/nebula/config.yml',
+   * });
+   *
+   * const agent = await AgentConnection.connectMesh({
+   *   transport,
+   *   peer: { peerId: 'server', address: '10.0.0.1', port: 4242 },
+   *   localPeerId: 'my-agent',
+   *   name: 'MeshWorker',
+   *   role: 'processor',
+   *   reconnection: true
+   * });
+   *
+   * agent.onMessage(handleMessage);
+   * await agent.busy();
+   * ```
+   */
+  static async connectMesh(options) {
+    const { agenticMeshStream: agenticMeshStream2 } = await Promise.resolve().then(() => (init_agentic_mesh(), agentic_mesh_exports));
+    const streamConfig = {
+      transport: options.transport,
+      peer: options.peer,
+      localPeerId: options.localPeerId,
+      timeout: options.timeout
+    };
+    const stream = await agenticMeshStream2(streamConfig);
+    const createStream = async () => agenticMeshStream2(streamConfig);
+    const reconnection = options.reconnection === true ? { enabled: true } : typeof options.reconnection === "object" ? options.reconnection : void 0;
+    const agent = new _AgentConnection(stream, {
+      name: options.name,
+      role: options.role,
+      capabilities: options.capabilities,
+      visibility: options.visibility,
+      parent: options.parent,
+      scopes: options.scopes,
+      createStream,
+      reconnection
+    });
+    await agent.connect({ auth: options.auth });
+    return agent;
+  }
   // ===========================================================================
   // Connection Lifecycle
   // ===========================================================================
@@ -3267,6 +3651,62 @@ var AgentConnection = class _AgentConnection {
     this.#connection._transitionTo("connected");
     return { connection: connectResult, agent: registerResult.agent };
   }
+  /**
+   * Authenticate with the server after connection.
+   *
+   * Use this when the server returns `authRequired` in the connect response,
+   * indicating that authentication is needed before registering or accessing
+   * protected resources.
+   *
+   * @param auth - Authentication credentials
+   * @returns Authentication result with principal if successful
+   *
+   * @example
+   * ```typescript
+   * const agent = new AgentConnection(stream, { name: 'MyAgent' });
+   *
+   * // First connect to get auth requirements
+   * const connectResult = await agent.connectOnly();
+   *
+   * if (connectResult.authRequired) {
+   *   const authResult = await agent.authenticate({
+   *     method: 'api-key',
+   *     token: process.env.AGENT_API_KEY,
+   *   });
+   *
+   *   if (authResult.success) {
+   *     // Now register the agent
+   *     await agent.register({ name: 'MyAgent', role: 'worker' });
+   *   }
+   * }
+   * ```
+   */
+  async authenticate(auth) {
+    const params = {
+      method: auth.method,
+      credential: auth.token
+    };
+    const result = await this.#connection.sendRequest(AUTH_METHODS.AUTHENTICATE, params);
+    if (result.success && result.sessionId) {
+      this.#sessionId = result.sessionId;
+    }
+    return result;
+  }
+  /**
+   * Refresh authentication credentials.
+   *
+   * Use this to update credentials before they expire for long-lived connections.
+   *
+   * @param auth - New authentication credentials
+   * @returns Updated principal information
+   */
+  async refreshAuth(auth) {
+    const params = {
+      method: auth.method,
+      credential: auth.token
+    };
+    return this.#connection.sendRequest(AUTH_METHODS.AUTH_REFRESH, params);
+  }
   /**
    * Disconnect from the MAP system
    * @param reason - Optional reason for disconnecting
@@ -4558,7 +4998,7 @@ var EventSchema = zod.z.object({
 var SubscriptionFilterSchema = zod.z.object({
   eventTypes: zod.z.array(EventTypeSchema).optional(),
   scopes: zod.z.array(ScopeIdSchema).optional(),
-  agents: zod.z.array(AgentIdSchema).optional(),
+  fromAgents: zod.z.array(AgentIdSchema).optional(),
   includeChildren: zod.z.boolean().optional(),
   _meta: MetaSchema
 }).strict();
@@ -5297,6 +5737,334 @@ function toAgent(agentId) {
 function toScope(scopeId) {
   return formatAddress("scope", scopeId);
 }
+var MAPMeshPeer = class _MAPMeshPeer {
+  #meshPeer;
+  #config;
+  #gitService;
+  constructor(meshPeer, config) {
+    this.#meshPeer = meshPeer;
+    this.#config = config;
+    this.#gitService = meshPeer.git ? new GitSyncServiceImpl(meshPeer.git, config.git?.repoPath ?? process.cwd()) : null;
+  }
+  // ===========================================================================
+  // Static Factory
+  // ===========================================================================
+  /**
+   * Create a new MAPMeshPeer.
+   *
+   * Requires `agentic-mesh` to be installed as a peer dependency.
+   *
+   * @param config - Peer configuration
+   * @returns Promise resolving to the created peer (not yet started)
+   */
+  static async create(config) {
+    const meshPeer = agenticMesh.createMeshPeer({
+      peerId: config.peerId,
+      peerName: config.peerName,
+      transport: config.transport,
+      git: config.git,
+      peers: config.peers,
+      map: config.map
+    });
+    return new _MAPMeshPeer(meshPeer, config);
+  }
+  // ===========================================================================
+  // Properties
+  // ===========================================================================
+  /** Unique peer identifier */
+  get peerId() {
+    return this.#meshPeer.peerId;
+  }
+  /** Display name for this peer */
+  get peerName() {
+    return this.#meshPeer.peerName;
+  }
+  /** Whether the peer is currently running */
+  get isRunning() {
+    return this.#meshPeer.isRunning;
+  }
+  /** List of connected peer IDs */
+  get connectedPeers() {
+    return this.#meshPeer.connectedPeers;
+  }
+  /** Git sync service (null if git not enabled) */
+  get git() {
+    return this.#gitService;
+  }
+  // ===========================================================================
+  // Lifecycle
+  // ===========================================================================
+  /**
+   * Start the mesh peer.
+   *
+   * This starts the transport, MAP server, and git service (if enabled),
+   * then connects to any initial peers specified in the config.
+   */
+  async start() {
+    await this.#meshPeer.start(this.#config.transport);
+  }
+  /**
+   * Stop the mesh peer.
+   *
+   * This disconnects from all peers, unregisters all agents,
+   * stops the git service, MAP server, and transport.
+   */
+  async stop() {
+    await this.#meshPeer.stop();
+  }
+  // ===========================================================================
+  // Peer Connections
+  // ===========================================================================
+  /**
+   * Connect to a remote peer.
+   *
+   * After connecting, agents on both peers will be discoverable
+   * and messages can be routed between them.
+   *
+   * @param endpoint - Peer endpoint to connect to
+   */
+  async connectToPeer(endpoint) {
+    await this.#meshPeer.connectToPeer(endpoint);
+  }
+  /**
+   * Disconnect from a peer.
+   *
+   * @param peerId - ID of peer to disconnect from
+   * @param reason - Optional reason for disconnecting
+   */
+  async disconnectFromPeer(peerId, reason) {
+    await this.#meshPeer.disconnectFromPeer(peerId, reason);
+  }
+  /**
+   * Check if connected to a specific peer.
+   *
+   * @param peerId - Peer ID to check
+   * @returns true if connected
+   */
+  isConnectedTo(peerId) {
+    return this.connectedPeers.includes(peerId);
+  }
+  // ===========================================================================
+  // Agent Management
+  // ===========================================================================
+  /**
+   * Create and register a local agent on this peer's MapServer.
+   *
+   * @param config - Agent configuration
+   * @returns The created agent
+   */
+  async createAgent(config) {
+    const agentConn = await this.#meshPeer.createAgent(config);
+    return new LocalAgentImpl(agentConn);
+  }
+  /**
+   * Get a local agent by ID.
+   *
+   * @param agentId - Agent ID to look up
+   * @returns The agent, or undefined if not found
+   */
+  getAgent(agentId) {
+    const conn = this.#meshPeer.getAgentConnection(agentId);
+    return conn ? new LocalAgentImpl(conn) : void 0;
+  }
+  /**
+   * Get all local agents on this peer.
+   */
+  getLocalAgents() {
+    return this.#meshPeer.getLocalAgents();
+  }
+  /**
+   * Get all known agents (local and discovered from connected peers).
+   */
+  getAllAgents() {
+    return this.#meshPeer.getAllAgents();
+  }
+  // ===========================================================================
+  // Scope Management
+  // ===========================================================================
+  /**
+   * Create a scope on this peer's MapServer.
+   *
+   * @param config - Scope configuration
+   * @returns The created scope
+   */
+  createScope(config) {
+    return this.#meshPeer.createScope(config);
+  }
+  /**
+   * Get a scope by ID.
+   *
+   * @param scopeId - Scope ID to look up
+   * @returns The scope, or undefined if not found
+   */
+  getScope(scopeId) {
+    return this.#meshPeer.getScope(scopeId);
+  }
+  /**
+   * List all scopes on this peer.
+   */
+  listScopes() {
+    return this.#meshPeer.listScopes();
+  }
+  // ===========================================================================
+  // Messaging
+  // ===========================================================================
+  /**
+   * Send a message from an agent to an address.
+   *
+   * Messages are routed to local agents or forwarded to connected peers.
+   *
+   * @param from - Sending agent ID
+   * @param to - Destination address
+   * @param payload - Message payload
+   * @param meta - Optional message metadata
+   * @returns Send result with delivery status
+   */
+  async send(from, to, payload, meta) {
+    return this.#meshPeer.send(from, to, payload, meta);
+  }
+  // ===========================================================================
+  // Events
+  // ===========================================================================
+  /**
+   * Subscribe to events from this peer's MapServer.
+   *
+   * @param filter - Optional filter for event types
+   * @returns Event subscription
+   */
+  subscribe(filter) {
+    return this.#meshPeer.subscribe(this.peerId, filter);
+  }
+  /**
+   * Register a handler for peer connection events.
+   *
+   * @param handler - Function called when a peer connects
+   * @returns Unsubscribe function
+   */
+  onPeerConnected(handler) {
+    this.#meshPeer.on("peer:connected", handler);
+    return () => this.#meshPeer.off("peer:connected", handler);
+  }
+  /**
+   * Register a handler for peer disconnection events.
+   *
+   * @param handler - Function called when a peer disconnects
+   * @returns Unsubscribe function
+   */
+  onPeerDisconnected(handler) {
+    this.#meshPeer.on("peer:disconnected", handler);
+    return () => this.#meshPeer.off("peer:disconnected", handler);
+  }
+  /**
+   * Register a handler for agent registration events.
+   *
+   * @param handler - Function called when an agent registers
+   * @returns Unsubscribe function
+   */
+  onAgentRegistered(handler) {
+    this.#meshPeer.on("agent:registered", handler);
+    return () => this.#meshPeer.off("agent:registered", handler);
+  }
+  /**
+   * Register a handler for agent unregistration events.
+   *
+   * @param handler - Function called when an agent unregisters
+   * @returns Unsubscribe function
+   */
+  onAgentUnregistered(handler) {
+    this.#meshPeer.on("agent:unregistered", handler);
+    return () => this.#meshPeer.off("agent:unregistered", handler);
+  }
+  /**
+   * Register a handler for error events.
+   *
+   * @param handler - Function called when an error occurs
+   * @returns Unsubscribe function
+   */
+  onError(handler) {
+    this.#meshPeer.on("error", handler);
+    return () => this.#meshPeer.off("error", handler);
+  }
+};
+var LocalAgentImpl = class {
+  #conn;
+  constructor(conn) {
+    this.#conn = conn;
+  }
+  get agentId() {
+    return this.#conn.agentId;
+  }
+  get name() {
+    return this.#conn.name;
+  }
+  get role() {
+    return this.#conn.role;
+  }
+  get state() {
+    return this.#conn.state;
+  }
+  async busy() {
+    await this.#conn.updateState("busy");
+  }
+  async idle() {
+    await this.#conn.updateState("idle");
+  }
+  async updateState(state) {
+    await this.#conn.updateState(state);
+  }
+  async updateMetadata(metadata) {
+    await this.#conn.updateMetadata(metadata);
+  }
+  async send(to, payload, meta) {
+    return this.#conn.send(to, payload, meta);
+  }
+  onMessage(handler) {
+    const wrappedHandler = (message) => handler(message);
+    this.#conn.on("message", wrappedHandler);
+    return () => {
+      this.#conn.off("message", wrappedHandler);
+    };
+  }
+  async unregister(reason) {
+    await this.#conn.unregister(reason);
+  }
+};
+var GitSyncServiceImpl = class {
+  #service;
+  #defaultRepoPath;
+  #defaultClient = null;
+  constructor(service, defaultRepoPath) {
+    this.#service = service;
+    this.#defaultRepoPath = defaultRepoPath;
+  }
+  get isRunning() {
+    return true;
+  }
+  get httpPort() {
+    return this.#service.httpPort;
+  }
+  createSyncClient(repoPath) {
+    return this.#service.createSyncClient(repoPath);
+  }
+  #getDefaultClient() {
+    if (!this.#defaultClient) {
+      this.#defaultClient = this.#service.createSyncClient(this.#defaultRepoPath);
+    }
+    return this.#defaultClient;
+  }
+  async sync(peerId, options) {
+    return this.#getDefaultClient().sync(peerId, options);
+  }
+  async pull(peerId, branch, options) {
+    return this.#getDefaultClient().pull(peerId, branch, options);
+  }
+  async push(peerId, branch, options) {
+    return this.#getDefaultClient().push(peerId, branch, options);
+  }
+  async clone(peerId, destPath, options) {
+    return this.#getDefaultClient().clone(peerId, destPath, options);
+  }
+};
 
 // src/acp/adapter.ts
 var ACPAgentAdapter = class {
@@ -5687,6 +6455,7 @@ exports.LIFECYCLE_METHODS = LIFECYCLE_METHODS;
 exports.MAPConnectionError = MAPConnectionError;
 exports.MAPErrorDataSchema = MAPErrorDataSchema;
 exports.MAPErrorSchema = MAPErrorSchema;
+exports.MAPMeshPeer = MAPMeshPeer;
 exports.MAPNotificationSchema = MAPNotificationSchema;
 exports.MAPRequestError = MAPRequestError;
 exports.MAPRequestSchema = MAPRequestSchema;
@@ -5736,6 +6505,7 @@ exports.SubscriptionIdSchema = SubscriptionIdSchema;
 exports.SystemAddressSchema = SystemAddressSchema;
 exports.TimestampSchema = TimestampSchema;
 exports.TransportTypeSchema = TransportTypeSchema;
+exports.agenticMeshStream = agenticMeshStream;
 exports.buildAgentsGetResponse = buildAgentsGetResponse;
 exports.buildAgentsListResponse = buildAgentsListResponse;
 exports.buildAgentsRegisterResponse = buildAgentsRegisterResponse;