@harness-gw/sdk 0.6.0 → 0.7.0

package/README.md

@@ -63,7 +63,7 @@ You need a running harness. Hermes is the primary one; see
    docker run --rm \
      -v "$PWD/config.yaml:/run/harness-gw/config.yaml:ro" \
      -v "$PWD/hermes-token:/run/secrets/hermes-token:ro" \
-     ghcr.io/almogbaku/harness-gw:0.6.0 \
+     ghcr.io/almogbaku/harness-gw:0.7.0 \
      config check --config /run/harness-gw/config.yaml
    ```
 
@@ -73,7 +73,7 @@ You need a running harness. Hermes is the primary one; see
    docker run --rm -p 127.0.0.1:4100:4100 \
      -v "$PWD/config.yaml:/run/harness-gw/config.yaml:ro" \
      -v "$PWD/hermes-token:/run/secrets/hermes-token:ro" \
-     ghcr.io/almogbaku/harness-gw:0.6.0 \
+     ghcr.io/almogbaku/harness-gw:0.7.0 \
      serve --config /run/harness-gw/config.yaml
    ```
 

package/dist/client/index.js

@@ -278,6 +278,13 @@ class AgentUpdateError extends Error {
   }
 }
 
+class AcpConnectionClosedError extends Error {
+  constructor(message = "The ACP connection closed", options) {
+    super(message, options);
+    this.name = "AcpConnectionClosedError";
+  }
+}
+
 // client/limits.ts
 var HANDSHAKE_DEADLINE_MS = 1e4;
 var REQUEST_DEADLINE_MS = {
@@ -436,9 +443,6 @@ var SESSION_STATES = new Map([
   ["refused", "unavailable"],
   ["gone", "gone"]
 ]);
-function isTimeout(error) {
-  return error instanceof DOMException && error.name === "TimeoutError";
-}
 function agentUpdateError(error) {
   if (codeOf(error) === HGW_JSONRPC_ERRORS2.unsupported)
     return new AgentUpdateError("unsupported", "This runtime cannot store that Agent field");
@@ -482,6 +486,9 @@ function trackedInbound(stream, onReceived) {
     writable: stream.writable
   };
 }
+function closedUnder({ connection }, error) {
+  return connection.signal.aborted && error === connection.signal.reason;
+}
 function observedSocket(Socket, onOpen, onClose) {
   return class extends Socket {
     constructor(...args) {
@@ -705,6 +712,7 @@ function createAcpConnection(options) {
   let live;
   let recovering = false;
   let joinable = false;
+  let recovery;
   let invitation;
   let lastFocus;
   let silenceTimer = undefined;
@@ -817,18 +825,48 @@ function createAcpConnection(options) {
       return;
     sessions.get(notice.sessionId)?.owner?.actor.send({ type: "gone" });
   }
-  async function readyTransport() {
+  async function liveTransport() {
     start();
     if (inspecting)
       await inspecting;
-    const current = live;
-    if (ended || !current)
-      throw new Error("The ACP connection is not open");
+    if (ended || !live)
+      throw new AcpConnectionClosedError("The ACP connection is not open");
+    return live;
+  }
+  async function readyTransport() {
+    const current = await liveTransport();
     await current.ready;
     return current;
   }
-  async function request(tier, send) {
-    return requestOn(await readyTransport(), tier, send);
+  function recovered() {
+    start();
+    if (ended)
+      return Promise.reject(new AcpConnectionClosedError);
+    if (joinable)
+      return Promise.resolve();
+    recovery ??= Promise.withResolvers();
+    return recovery.promise;
+  }
+  async function request(tier, send, resend) {
+    const sessionId = resend === "read" ? undefined : resend?.sessionId;
+    for (;; ) {
+      if (sessionId !== undefined && sessions.has(sessionId))
+        await joined(sessionId);
+      else if (resend)
+        await recovered();
+      const transport = await liveTransport();
+      try {
+        await transport.ready;
+        return await requestOn(transport, tier, send);
+      } catch (error) {
+        if (!closedUnder(transport, error))
+          throw error;
+        const again = resend === "read" || sessionId !== undefined && sessions.has(sessionId);
+        if (!again)
+          throw new AcpConnectionClosedError(undefined, { cause: error });
+        await transport.connection.closed.catch((err) => logger.warn({ err }, "acp.connection.closed_with_error"));
+      }
+    }
   }
   async function requestOn({ connection }, tier, send, parent) {
     const deadline = new Deadline(REQUEST_DEADLINE_MS[tier], clock, parent);
@@ -845,21 +883,6 @@ function createAcpConnection(options) {
       throw error;
     }
   }
-  async function write(sessionId, tier, send) {
-    for (;; ) {
-      if (sessions.has(sessionId))
-        await joined(sessionId);
-      const transport = await readyTransport();
-      try {
-        return await requestOn(transport, tier, send);
-      } catch (error) {
-        const closedUnder = transport.connection.signal.aborted && !isTimeout(error) && sessions.has(sessionId);
-        if (!closedUnder)
-          throw error;
-        await transport.connection.closed.catch((err) => logger.warn({ err }, "acp.connection.closed_with_error"));
-      }
-    }
-  }
   function notifyAgent(send, sessionId) {
     (async () => {
       if (sessionId !== undefined && sessions.has(sessionId))
@@ -958,7 +981,7 @@ function createAcpConnection(options) {
     }
   }
   async function listAgents() {
-    const response = AgentsListEntriesSchema.parse(await request("short", (agent, options) => agent.request(HGW_METHODS2.agents.list, undefined, options)));
+    const response = AgentsListEntriesSchema.parse(await request("short", (agent, options) => agent.request(HGW_METHODS2.agents.list, undefined, options), "read"));
     return {
       ...response,
       agents: readEach(response.agents, HgwAgentsListResponseSchema2.shape.agents.element, (entry) => logger.warn({ id: loggedId(entry, "summary", "id") }, "agents.entry_skipped"))
@@ -1075,18 +1098,20 @@ function createAcpConnection(options) {
     });
   }
   async function resumePage(sessionId, cursor) {
-    await joined(sessionId);
     const open = sessions.get(sessionId);
     if (!open)
       throw notOpen();
-    const updates = [];
-    open.page = updates;
+    let updates = [];
     try {
-      const response = await request("medium", (agent, options) => agent.request(methods2.agent.session.resume, {
-        sessionId,
-        cwd: AGENT_CWD,
-        replayFrom: { type: HGW_REPLAY_BEFORE2, cursor }
-      }, options));
+      const response = await request("medium", (agent, options) => {
+        updates = [];
+        open.page = updates;
+        return agent.request(methods2.agent.session.resume, {
+          sessionId,
+          cwd: AGENT_CWD,
+          replayFrom: { type: HGW_REPLAY_BEFORE2, cursor }
+        }, options);
+      }, { sessionId });
       const { history } = HgwHistoryPageResponseMetaSchema2.parse(hgwMetaOf(response._meta));
       return { updates, history };
     } finally {
@@ -1103,6 +1128,8 @@ function createAcpConnection(options) {
     }
     joinable = true;
     setOutage(undefined);
+    recovery?.resolve();
+    recovery = undefined;
     const opened = [...sessions.keys()];
     for (const open of sessions.values())
       open.owner?.actor.send({ type: "ready" });
@@ -1204,13 +1231,15 @@ function createAcpConnection(options) {
     ended = true;
     setStatus("closed");
     setOutage(undefined);
-    failInitialized?.(new Error("The ACP connection closed"));
+    failInitialized?.(new AcpConnectionClosedError);
     failInitialized = undefined;
     settleInitialized = undefined;
+    recovery?.reject(new AcpConnectionClosedError);
+    recovery = undefined;
     for (const open of sessions.values()) {
       clock.clearTimeout(open.grace);
       open.owner?.dispose();
-      open.waiters?.reject(new Error("The ACP connection closed"));
+      open.waiters?.reject(new AcpConnectionClosedError);
     }
     sessions.clear();
     live?.connection.close();
@@ -1247,7 +1276,7 @@ function createAcpConnection(options) {
       const response = await request("short", (agent, options) => agent.request(methods2.agent.session.list, {
         ...cursor === undefined ? {} : { cursor },
         _meta: { [HGW_META_KEY2]: meta }
-      }, options));
+      }, options), "read");
       return {
         sessions: response.sessions,
         ...response.nextCursor ? { nextCursor: response.nextCursor } : {}
@@ -1255,8 +1284,10 @@ function createAcpConnection(options) {
     },
     async searchSessions(meta) {
       const response = SessionSearchEntriesSchema.parse(await request("short", (agent, options) => agent.request(HGW_METHODS2.sessions.search, {
-        _meta: { [HGW_META_KEY2]: HgwSessionSearchMetaSchema2.parse(meta) }
-      }, options)));
+        _meta: {
+          [HGW_META_KEY2]: HgwSessionSearchMetaSchema2.parse(meta)
+        }
+      }, options), "read"));
       return {
         ...response,
         sessions: readEach(response.sessions, HgwSessionSearchResponseSchema2.shape.sessions.element, (entry) => logger.warn({ id: loggedId(entry, "sessionId") }, "sessions.result_skipped"))
@@ -1275,14 +1306,14 @@ function createAcpConnection(options) {
         _meta: { [HGW_META_KEY2]: meta }
       };
       assertFrameFits(params);
-      const response = await write(sessionId, "long", (agent, options) => agent.request(methods2.agent.session.prompt, params, options));
+      const response = await request("long", (agent, options) => agent.request(methods2.agent.session.prompt, params, options), { sessionId });
       return { messageId: response.messageId };
     },
     cancel(sessionId) {
       notifyAgent((agent) => agent.notify(methods2.agent.session.cancel, { sessionId }), sessionId);
     },
     async setConfigOption(sessionId, configId, value) {
-      const response = await write(sessionId, "medium", (agent, options) => agent.request(methods2.agent.session.setConfigOption, { sessionId, configId, type: "id", value }, options));
+      const response = await request("medium", (agent, options) => agent.request(methods2.agent.session.setConfigOption, { sessionId, configId, type: "id", value }, options), { sessionId });
       return response.configOptions;
     },
     async deleteSession(sessionId) {
@@ -1293,7 +1324,7 @@ function createAcpConnection(options) {
     },
     async steer(steer) {
       assertFrameFits(steer);
-      return HgwSteerResponseSchema2.parse(await write(steer.sessionId, "medium", (agent, options) => agent.request(HGW_METHODS2.session.steer, steer, options)));
+      return HgwSteerResponseSchema2.parse(await request("medium", (agent, options) => agent.request(HGW_METHODS2.session.steer, steer, options), { sessionId: steer.sessionId }));
     },
     focus(sessionId, presence) {
       const report = {
@@ -2682,6 +2713,7 @@ class HgwRemoteClient {
   }
 }
 export {
+  AcpConnectionClosedError,
   AgentUpdateError,
   HgwClientError,
   HgwRemoteClient,

package/dist/client/types.d.ts

@@ -63,6 +63,13 @@ export type AcpSessionListener = {
     replay?: AcpSessionReplayListener;
     state?: (state: AcpSessionState) => void;
 };
+/**
+ * A read (`listAgents`, `listSessions`, `searchSessions`, `resumePage`) waits
+ * out a reconnect and goes out again on the transport that recovers, and a
+ * write for an opened Session once it has rejoined. Any other call a
+ * transport closes under, and every call once the connection has ended,
+ * rejects as `AcpConnectionClosedError`.
+ */
 export interface AcpConnection {
     readonly status: AcpConnectionStatus;
     /**

package/dist/client/workspace.d.ts

@@ -17,6 +17,15 @@ export declare class AgentUpdateError extends Error {
     readonly code: "unsupported" | "conflict";
     constructor(code: "unsupported" | "conflict", message: string);
 }
+/**
+ * The ACP connection is gone for a request: it has ended, no transport is open
+ * to send on, or a transport closed under a request it does not send again.
+ * `cause` holds what that transport closed with, which a failed socket leaves
+ * a DOM `Event`. Gateway refusals and timeouts reject as they come.
+ */
+export declare class AcpConnectionClosedError extends Error {
+    constructor(message?: string, options?: ErrorOptions);
+}
 export type SessionStatus = "idle" | "running" | "waiting-for-input" | "failed" | "unknown";
 export type ActivityBase = {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harness-gw/sdk",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "A gateway that puts Hermes, OpenClaw, and OpenCode behind one ACP WebSocket, and the browser client and protocol SDK for it.",
   "license": "Apache-2.0",
   "type": "module",