@linkedclaw/consumer-runtime 0.9.1 → 0.9.2

package/dist/index.d.ts

@@ -6,9 +6,18 @@ interface HireParams {
     maxMessages?: number;
     referredBy?: string;
     autoActivate?: boolean;
-    /** Override the default relay URL. The ACP endpoint is derived by replacing the trailing `/ws`. */
+    /** Override the default relay URL (defaults to the cloud relay /ws endpoint). */
     relayUrl?: string;
-    /** API key + agent ID needed for the ACP IDENTIFY frame. */
+    /**
+     * Try /acp (OpenClaw sub-agent bridge) before /ws. Default false — mirrors
+     * `SkillConfig.try_acp = False` on the provider side (upstream commit
+     * 2dbc36c). Native providers register on /ws and are reachable there; only
+     * opt in when the target is an ACP-routed agent (OpenClaw sub-agent). When
+     * opted in, falls back to /ws if /acp connect fails or the recipient is
+     * absent from /acp's connection table.
+     */
+    tryAcp?: boolean;
+    /** API key + agent ID for the IDENTIFY frame. */
     apiKey: string;
     agentId: string;
 }
@@ -28,10 +37,14 @@ declare class RequesterFlows {
         sort?: string;
     }): Promise<Agent[]>;
     /**
-     * Open a session. Performs HTTP create → ACP WS handshake (SESSION_CREATE/ACCEPT) → HTTP activate.
-     * Default 30s wait for SESSION_ACCEPT.
+     * Open a session. HTTP create → WS handshake (SESSION_CREATE/ACCEPT) → done.
+     *
+     * Default transport is /ws — native providers register there
+     * (`SkillConfig.try_acp=False` upstream default). Set `tryAcp: true` to try
+     * /acp first; on opt-in, falls back to /ws when the recipient isn't on /acp.
      */
     hire(params: HireParams): Promise<HireResult>;
+    private attemptHandshake;
     send(sessionId: string, payload: Record<string, unknown> | string, seq: number): Promise<{
         accepted?: boolean;
     }>;

package/dist/index.js

@@ -4,12 +4,18 @@ import {
 } from "@linkedclaw/consumer";
 import { MessageType } from "@linkedclaw/provider";
 import WebSocket from "ws";
-var ACP_TIMEOUT_MS = 3e4;
+var ACP_CONNECT_TIMEOUT_MS = 2e3;
+var SESSION_ACCEPT_TIMEOUT_MS = 3e4;
 var SessionRejectedError = class extends Error {
   constructor(reason) {
     super(`session rejected: ${reason}`);
   }
 };
+var TransportMissError = class extends Error {
+  constructor(reason) {
+    super(`transport miss: ${reason}`);
+  }
+};
 var RequesterFlows = class {
   constructor(client) {
     this.client = client;
@@ -19,8 +25,11 @@ var RequesterFlows = class {
     return this.client.discover({ capability, ...extra });
   }
   /**
-   * Open a session. Performs HTTP create → ACP WS handshake (SESSION_CREATE/ACCEPT) → HTTP activate.
-   * Default 30s wait for SESSION_ACCEPT.
+   * Open a session. HTTP create → WS handshake (SESSION_CREATE/ACCEPT) → done.
+   *
+   * Default transport is /ws — native providers register there
+   * (`SkillConfig.try_acp=False` upstream default). Set `tryAcp: true` to try
+   * /acp first; on opt-in, falls back to /ws when the recipient isn't on /acp.
    */
   async hire(params) {
     const session = await this.client.createSession({
@@ -31,22 +40,57 @@ var RequesterFlows = class {
     });
     if (params.autoActivate === false) return { session, activated: false };
     const relayUrl = params.relayUrl ?? DEFAULT_RELAY_URL;
-    const acpUrl = relayUrl.replace(/\/ws$/, "/acp");
-    const ws = new WebSocket(acpUrl);
+    try {
+      if (params.tryAcp) {
+        const acpUrl = relayUrl.replace(/\/ws$/, "/acp");
+        try {
+          await this.attemptHandshake(acpUrl, session.session_id, params, ACP_CONNECT_TIMEOUT_MS);
+        } catch (err) {
+          if (!(err instanceof TransportMissError)) throw err;
+          await this.attemptHandshake(relayUrl, session.session_id, params, SESSION_ACCEPT_TIMEOUT_MS);
+        }
+      } else {
+        await this.attemptHandshake(relayUrl, session.session_id, params, SESSION_ACCEPT_TIMEOUT_MS);
+      }
+    } catch (err) {
+      await this.client.endSession(session.session_id, {}).catch(() => {
+      });
+      if (err instanceof TransportMissError) {
+        throw new SessionRejectedError(`agent unreachable`);
+      }
+      throw err;
+    }
+    return { session, activated: true };
+  }
+  async attemptHandshake(url, sessionId, params, connectTimeoutMs) {
+    const ws = new WebSocket(url);
     try {
       await new Promise((resolve, reject) => {
-        ws.once("open", () => resolve());
-        ws.once("error", reject);
+        const timer = setTimeout(
+          () => reject(new TransportMissError("connect timeout")),
+          connectTimeoutMs
+        );
+        ws.once("open", () => {
+          clearTimeout(timer);
+          resolve();
+        });
+        ws.once("error", (err) => {
+          clearTimeout(timer);
+          reject(new TransportMissError(`connect failed: ${err.message}`));
+        });
       });
       ws.send(JSON.stringify({ type: MessageType.IDENTIFY, agent_id: params.agentId, token: params.apiKey }));
       ws.send(JSON.stringify({
         type: MessageType.SESSION_CREATE,
-        session_id: session.session_id,
+        session_id: sessionId,
         recipient: params.providerAgentId,
         capability: params.capability
       }));
       const reply = await new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error("ACP SESSION_ACCEPT timeout")), ACP_TIMEOUT_MS);
+        const timer = setTimeout(
+          () => reject(new Error("SESSION_ACCEPT timeout")),
+          SESSION_ACCEPT_TIMEOUT_MS
+        );
         ws.once("message", (data) => {
           clearTimeout(timer);
           resolve(JSON.parse(data.toString()));
@@ -56,17 +100,19 @@ var RequesterFlows = class {
           reject(err);
         });
       });
-      if (reply.type === MessageType.ERROR) throw new SessionRejectedError(reply.error ?? "relay error");
+      if (reply.type === MessageType.ERROR) {
+        const errMsg = reply.error ?? "relay error";
+        if (errMsg.includes("not connected")) throw new TransportMissError(errMsg);
+        throw new SessionRejectedError(errMsg);
+      }
       if (reply.type === MessageType.SESSION_REJECT) throw new SessionRejectedError(reply.reason ?? "rejected");
-      if (reply.type !== MessageType.SESSION_ACCEPT) throw new Error(`unexpected ACP reply: ${reply.type}`);
-    } catch (err) {
-      ws.close();
-      await this.client.endSession(session.session_id, {}).catch(() => {
-      });
-      throw err;
+      if (reply.type !== MessageType.SESSION_ACCEPT) throw new Error(`unexpected reply: ${reply.type}`);
+    } finally {
+      try {
+        ws.close();
+      } catch {
+      }
     }
-    ws.close();
-    return { session, activated: true };
   }
   send(sessionId, payload, seq) {
     const normalized = typeof payload === "string" ? { text: payload } : payload;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linkedclaw/consumer-runtime",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "Runtime helpers (RequesterFlows, ACP) for LinkedClaw consumer agents",
   "license": "Apache-2.0",
   "type": "module",
@@ -23,8 +23,8 @@
   "dependencies": {
     "ws": "^8.18.0",
     "zod": "^3.23.0",
-    "@linkedclaw/provider": "^0.9.1",
-    "@linkedclaw/consumer": "^0.9.1"
+    "@linkedclaw/consumer": "^0.9.1",
+    "@linkedclaw/provider": "^0.9.1"
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",