@multi-agent-protocol/sdk 0.1.5 → 0.1.6

package/dist/{index-BVrYVfaf.d.cts → index-iu0EgJzG.d.cts}

@@ -5568,7 +5568,7 @@ interface AgentConnectOptions {
     metadata?: Record<string, unknown>;
     /** Authentication credentials */
     auth?: {
-        method: "bearer" | "api-key" | "mtls" | "none";
+        method: AuthMethod;
         token?: string;
     };
     /**
@@ -5662,6 +5662,27 @@ declare class AgentConnection {
      * ```
      */
     static connect(url: string, options?: AgentConnectOptions): Promise<AgentConnection>;
+    /**
+     * Create an AgentConnection over WebSocket without performing the MAP handshake.
+     *
+     * Use this when you need to control the connection flow — e.g., to handle
+     * server-driven auth negotiation before registration.
+     *
+     * @example
+     * ```typescript
+     * const agent = await AgentConnection.createConnection('ws://localhost:8080', {
+     *   name: 'Worker',
+     *   role: 'processor',
+     * });
+     *
+     * const result = await agent.connectOnly();
+     * if (result.authRequired) {
+     *   await agent.authenticate({ method: result.authRequired.methods[0], token: cred });
+     * }
+     * await agent.register();
+     * ```
+     */
+    static createConnection(url: string, options?: AgentConnectOptions): Promise<AgentConnection>;
     /**
      * Connect and register an agent via agentic-mesh transport.
      *
@@ -5707,13 +5728,52 @@ declare class AgentConnection {
         /** Token to resume a previously disconnected session */
         resumeToken?: string;
         auth?: {
-            method: "bearer" | "api-key" | "mtls" | "none";
+            method: AuthMethod;
             token?: string;
         };
     }): Promise<{
         connection: ConnectResponseResult;
         agent: Agent;
     }>;
+    /**
+     * Connect to the MAP system without registering an agent.
+     *
+     * Use this when the server may require authentication before registration.
+     * After connecting, check `authRequired` in the response and call
+     * `authenticate()` if needed, then `register()` to complete the handshake.
+     *
+     * @example
+     * ```typescript
+     * const result = await agent.connectOnly();
+     *
+     * if (result.authRequired) {
+     *   const method = result.authRequired.methods[0];
+     *   await agent.authenticate({ method, token: myCredential });
+     * }
+     *
+     * await agent.register();
+     * ```
+     */
+    connectOnly(options?: {
+        agentId?: AgentId;
+        resumeToken?: string;
+        auth?: {
+            method: AuthMethod;
+            token?: string;
+        };
+    }): Promise<ConnectResponseResult>;
+    /**
+     * Register as an agent after connecting.
+     *
+     * Call this after `connectOnly()` and optional `authenticate()` to complete
+     * the connection handshake. Uses the options provided during construction
+     * (name, role, scopes, etc.) unless overridden.
+     */
+    register(overrides?: {
+        agentId?: AgentId;
+        name?: string;
+        role?: string;
+    }): Promise<Agent>;
     /**
      * Authenticate with the server after connection.
      *
@@ -5726,26 +5786,21 @@ declare class AgentConnection {
      *
      * @example
      * ```typescript
-     * const agent = new AgentConnection(stream, { name: 'MyAgent' });
-     *
-     * // First connect to get auth requirements
-     * const connectResult = await agent.connectOnly();
+     * const result = await agent.connectOnly();
      *
-     * if (connectResult.authRequired) {
+     * if (result.authRequired) {
      *   const authResult = await agent.authenticate({
-     *     method: 'api-key',
-     *     token: process.env.AGENT_API_KEY,
+     *     method: result.authRequired.methods[0],
+     *     token: myCredential,
      *   });
-     *
      *   if (authResult.success) {
-     *     // Now register the agent
-     *     await agent.register({ name: 'MyAgent', role: 'worker' });
+     *     await agent.register();
      *   }
      * }
      * ```
      */
     authenticate(auth: {
-        method: "bearer" | "api-key" | "mtls" | "none";
+        method: AuthMethod;
         token?: string;
     }): Promise<AuthenticateResponseResult>;
     /**
@@ -5757,7 +5812,7 @@ declare class AgentConnection {
      * @returns Updated principal information
      */
     refreshAuth(auth: {
-        method: "bearer" | "api-key" | "mtls" | "none";
+        method: AuthMethod;
         token?: string;
     }): Promise<{
         success: boolean;

package/dist/{index-BVrYVfaf.d.ts → index-iu0EgJzG.d.ts}

@@ -5568,7 +5568,7 @@ interface AgentConnectOptions {
     metadata?: Record<string, unknown>;
     /** Authentication credentials */
     auth?: {
-        method: "bearer" | "api-key" | "mtls" | "none";
+        method: AuthMethod;
         token?: string;
     };
     /**
@@ -5662,6 +5662,27 @@ declare class AgentConnection {
      * ```
      */
     static connect(url: string, options?: AgentConnectOptions): Promise<AgentConnection>;
+    /**
+     * Create an AgentConnection over WebSocket without performing the MAP handshake.
+     *
+     * Use this when you need to control the connection flow — e.g., to handle
+     * server-driven auth negotiation before registration.
+     *
+     * @example
+     * ```typescript
+     * const agent = await AgentConnection.createConnection('ws://localhost:8080', {
+     *   name: 'Worker',
+     *   role: 'processor',
+     * });
+     *
+     * const result = await agent.connectOnly();
+     * if (result.authRequired) {
+     *   await agent.authenticate({ method: result.authRequired.methods[0], token: cred });
+     * }
+     * await agent.register();
+     * ```
+     */
+    static createConnection(url: string, options?: AgentConnectOptions): Promise<AgentConnection>;
     /**
      * Connect and register an agent via agentic-mesh transport.
      *
@@ -5707,13 +5728,52 @@ declare class AgentConnection {
         /** Token to resume a previously disconnected session */
         resumeToken?: string;
         auth?: {
-            method: "bearer" | "api-key" | "mtls" | "none";
+            method: AuthMethod;
             token?: string;
         };
     }): Promise<{
         connection: ConnectResponseResult;
         agent: Agent;
     }>;
+    /**
+     * Connect to the MAP system without registering an agent.
+     *
+     * Use this when the server may require authentication before registration.
+     * After connecting, check `authRequired` in the response and call
+     * `authenticate()` if needed, then `register()` to complete the handshake.
+     *
+     * @example
+     * ```typescript
+     * const result = await agent.connectOnly();
+     *
+     * if (result.authRequired) {
+     *   const method = result.authRequired.methods[0];
+     *   await agent.authenticate({ method, token: myCredential });
+     * }
+     *
+     * await agent.register();
+     * ```
+     */
+    connectOnly(options?: {
+        agentId?: AgentId;
+        resumeToken?: string;
+        auth?: {
+            method: AuthMethod;
+            token?: string;
+        };
+    }): Promise<ConnectResponseResult>;
+    /**
+     * Register as an agent after connecting.
+     *
+     * Call this after `connectOnly()` and optional `authenticate()` to complete
+     * the connection handshake. Uses the options provided during construction
+     * (name, role, scopes, etc.) unless overridden.
+     */
+    register(overrides?: {
+        agentId?: AgentId;
+        name?: string;
+        role?: string;
+    }): Promise<Agent>;
     /**
      * Authenticate with the server after connection.
      *
@@ -5726,26 +5786,21 @@ declare class AgentConnection {
      *
      * @example
      * ```typescript
-     * const agent = new AgentConnection(stream, { name: 'MyAgent' });
-     *
-     * // First connect to get auth requirements
-     * const connectResult = await agent.connectOnly();
+     * const result = await agent.connectOnly();
      *
-     * if (connectResult.authRequired) {
+     * if (result.authRequired) {
      *   const authResult = await agent.authenticate({
-     *     method: 'api-key',
-     *     token: process.env.AGENT_API_KEY,
+     *     method: result.authRequired.methods[0],
+     *     token: myCredential,
      *   });
-     *
      *   if (authResult.success) {
-     *     // Now register the agent
-     *     await agent.register({ name: 'MyAgent', role: 'worker' });
+     *     await agent.register();
      *   }
      * }
      * ```
      */
     authenticate(auth: {
-        method: "bearer" | "api-key" | "mtls" | "none";
+        method: AuthMethod;
         token?: string;
     }): Promise<AuthenticateResponseResult>;
     /**
@@ -5757,7 +5812,7 @@ declare class AgentConnection {
      * @returns Updated principal information
      */
     refreshAuth(auth: {
-        method: "bearer" | "api-key" | "mtls" | "none";
+        method: AuthMethod;
         token?: string;
     }): Promise<{
         success: boolean;

package/dist/index.cjs

@@ -3946,6 +3946,52 @@ var AgentConnection = class _AgentConnection {
     await agent.connect({ auth: options?.auth });
     return agent;
   }
+  /**
+   * Create an AgentConnection over WebSocket without performing the MAP handshake.
+   *
+   * Use this when you need to control the connection flow — e.g., to handle
+   * server-driven auth negotiation before registration.
+   *
+   * @example
+   * ```typescript
+   * const agent = await AgentConnection.createConnection('ws://localhost:8080', {
+   *   name: 'Worker',
+   *   role: 'processor',
+   * });
+   *
+   * const result = await agent.connectOnly();
+   * if (result.authRequired) {
+   *   await agent.authenticate({ method: result.authRequired.methods[0], token: cred });
+   * }
+   * await agent.register();
+   * ```
+   */
+  static async createConnection(url, options) {
+    const parsedUrl = new URL(url);
+    if (!["ws:", "wss:"].includes(parsedUrl.protocol)) {
+      throw new Error(`Unsupported protocol: ${parsedUrl.protocol}. Use ws: or wss:`);
+    }
+    const timeout = options?.connectTimeout ?? 1e4;
+    const ws = new WebSocket(url);
+    await waitForOpen(ws, timeout);
+    const stream = websocketStream(ws);
+    const createStream = async () => {
+      const newWs = new WebSocket(url);
+      await waitForOpen(newWs, timeout);
+      return websocketStream(newWs);
+    };
+    const reconnection = options?.reconnection === true ? { enabled: true } : typeof options?.reconnection === "object" ? options.reconnection : void 0;
+    return new _AgentConnection(stream, {
+      name: options?.name,
+      role: options?.role,
+      capabilities: options?.capabilities,
+      visibility: options?.visibility,
+      parent: options?.parent,
+      scopes: options?.scopes,
+      createStream,
+      reconnection
+    });
+  }
   /**
    * Connect and register an agent via agentic-mesh transport.
    *
@@ -4042,6 +4088,65 @@ var AgentConnection = class _AgentConnection {
     this.#connection._transitionTo("connected");
     return { connection: connectResult, agent: registerResult.agent };
   }
+  /**
+   * Connect to the MAP system without registering an agent.
+   *
+   * Use this when the server may require authentication before registration.
+   * After connecting, check `authRequired` in the response and call
+   * `authenticate()` if needed, then `register()` to complete the handshake.
+   *
+   * @example
+   * ```typescript
+   * const result = await agent.connectOnly();
+   *
+   * if (result.authRequired) {
+   *   const method = result.authRequired.methods[0];
+   *   await agent.authenticate({ method, token: myCredential });
+   * }
+   *
+   * await agent.register();
+   * ```
+   */
+  async connectOnly(options) {
+    const connectParams = {
+      protocolVersion: PROTOCOL_VERSION,
+      participantType: "agent",
+      participantId: options?.agentId,
+      name: this.#options.name,
+      capabilities: this.#options.capabilities,
+      resumeToken: options?.resumeToken,
+      auth: options?.auth
+    };
+    const connectResult = await this.#connection.sendRequest(CORE_METHODS.CONNECT, connectParams);
+    this.#sessionId = connectResult.sessionId;
+    this.#serverCapabilities = connectResult.capabilities;
+    this.#connected = true;
+    this.#lastConnectOptions = options;
+    return connectResult;
+  }
+  /**
+   * Register as an agent after connecting.
+   *
+   * Call this after `connectOnly()` and optional `authenticate()` to complete
+   * the connection handshake. Uses the options provided during construction
+   * (name, role, scopes, etc.) unless overridden.
+   */
+  async register(overrides) {
+    const registerParams = {
+      agentId: overrides?.agentId ?? this.#lastConnectOptions?.agentId,
+      name: overrides?.name ?? this.#options.name,
+      role: overrides?.role ?? this.#options.role,
+      parent: this.#options.parent,
+      scopes: this.#options.scopes,
+      visibility: this.#options.visibility,
+      capabilities: this.#options.capabilities
+    };
+    const registerResult = await this.#connection.sendRequest(LIFECYCLE_METHODS.AGENTS_REGISTER, registerParams);
+    this.#agentId = registerResult.agent.id;
+    this.#currentState = registerResult.agent.state;
+    this.#connection._transitionTo("connected");
+    return registerResult.agent;
+  }
   /**
    * Authenticate with the server after connection.
    *
@@ -4054,20 +4159,15 @@ var AgentConnection = class _AgentConnection {
    *
    * @example
    * ```typescript
-   * const agent = new AgentConnection(stream, { name: 'MyAgent' });
+   * const result = await agent.connectOnly();
    *
-   * // First connect to get auth requirements
-   * const connectResult = await agent.connectOnly();
-   *
-   * if (connectResult.authRequired) {
+   * if (result.authRequired) {
    *   const authResult = await agent.authenticate({
-   *     method: 'api-key',
-   *     token: process.env.AGENT_API_KEY,
+   *     method: result.authRequired.methods[0],
+   *     token: myCredential,
    *   });
-   *
    *   if (authResult.success) {
-   *     // Now register the agent
-   *     await agent.register({ name: 'MyAgent', role: 'worker' });
+   *     await agent.register();
    *   }
    * }
    * ```