@multi-agent-protocol/sdk 0.1.5 → 0.1.6

package/dist/testing.cjs

@@ -4899,6 +4899,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.
    *
@@ -4995,6 +5041,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.
    *
@@ -5007,20 +5112,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();
    *   }
    * }
    * ```