agent-relay-orchestrator 0.19.3 → 0.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.19.3",
+  "version": "0.21.0",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.10"
+    "agent-relay-sdk": "0.2.12"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/relay.ts

@@ -3,7 +3,7 @@ import type { ProviderProbeCache } from "./provider-probe";
 import { detectSelfSupervision } from "./self-supervision";
 import { GIT_SHA, ORCHESTRATOR_PROTOCOL_VERSION, VERSION, runtimeMetadata } from "./version";
 import type { WorkspaceMetadata, WorkspaceMode, ManagedSessionExitDiagnostics as SdkManagedSessionExitDiagnostics } from "agent-relay-sdk";
-import { RELAY_TOKEN_HEADER } from "agent-relay-sdk";
+import { ReconnectionManager, RelayHttpClient } from "agent-relay-sdk";
 
 export interface RelayClient {
   register(): Promise<void>;
@@ -58,10 +58,11 @@ export interface RelayCommand {
   status: string;
 }
 
-const BACKOFF_SCHEDULE_MS = [
-  30_000, 60_000, 120_000, 240_000, 480_000, 960_000,
-];
-const MAX_BACKOFF_MS = 3_600_000; // 1 hour
+// Reconnect backoff: 30s → 1m → 2m → … capped at 1h, with jitter. Replaces the
+// former fixed BACKOFF_SCHEDULE_MS staircase — see SDK ReconnectionManager.
+const RECONNECT_INITIAL_MS = 30_000;
+const RECONNECT_MAX_MS = 3_600_000; // 1 hour
+const RECONNECT_JITTER_MS = 1_000;
 
 export function buildRegistrationMeta(
   config: Pick<OrchestratorConfig, "tmuxPrefix">,
@@ -88,26 +89,17 @@ export function createRelayClient(config: OrchestratorConfig, probeCache: Provid
   const agentId = `orchestrator-${config.id}`;
   let heartbeatTimer: Timer | null = null;
   let connected = false;
-  let backoffIndex = 0;
+  const reconnectMgr = new ReconnectionManager({ initialMs: RECONNECT_INITIAL_MS, maxMs: RECONNECT_MAX_MS, jitterMs: RECONNECT_JITTER_MS });
   let cursorFloor = 0;
   let apiUrl: string | undefined;
-  let runtimeToken: string | undefined;
-
-  function headers(): Record<string, string> {
-    const h: Record<string, string> = { "Content-Type": "application/json" };
-    const token = runtimeToken ?? config.token;
-    if (token) h[RELAY_TOKEN_HEADER] = token;
-    return h;
-  }
+  // Shared transport: auth-header injection + timeout + typed errors. The
+  // orchestrator-control endpoints have no typed method, so route them through
+  // the generic request() escape hatch. setToken() swaps in the runtime token
+  // the relay mints at registration.
+  const http = new RelayHttpClient({ baseUrl: config.relayUrl, token: config.token });
 
   async function apiCall(method: string, path: string, body?: unknown): Promise<Response> {
-    const url = `${config.relayUrl}/api${path}`;
-    const res = await fetch(url, {
-      method,
-      headers: headers(),
-      body: body ? JSON.stringify(body) : undefined,
-    });
-    return res;
+    return http.request(method, `/api${path}`, body);
   }
 
   async function register(): Promise<void> {
@@ -135,9 +127,9 @@ export function createRelayClient(config: OrchestratorConfig, probeCache: Provid
       throw new Error(`Failed to register orchestrator: ${res.status} ${err}`);
     }
     const registered = await res.json().catch(() => null) as { runtimeToken?: { token?: string } } | null;
-    if (registered?.runtimeToken?.token) runtimeToken = registered.runtimeToken.token;
+    if (registered?.runtimeToken?.token) http.setToken(registered.runtimeToken.token);
     connected = true;
-    backoffIndex = 0;
+    reconnectMgr.reset();
 
     // Bootstrap message cursor
     const cursor = await apiCall("GET", "/messages/cursor");
@@ -168,7 +160,7 @@ export function createRelayClient(config: OrchestratorConfig, probeCache: Provid
       if (!connected) {
         console.error("[orchestrator] Reconnected to relay");
         connected = true;
-        backoffIndex = 0;
+        reconnectMgr.reset();
       }
     } catch (err) {
       if (connected) {
@@ -180,12 +172,9 @@ export function createRelayClient(config: OrchestratorConfig, probeCache: Provid
   }
 
   async function reconnect(): Promise<void> {
-    const delay = backoffIndex < BACKOFF_SCHEDULE_MS.length
-      ? BACKOFF_SCHEDULE_MS[backoffIndex]!
-      : MAX_BACKOFF_MS;
-    backoffIndex = Math.min(backoffIndex + 1, BACKOFF_SCHEDULE_MS.length);
-    console.error(`[orchestrator] Reconnecting in ${Math.round(delay / 1000)}s...`);
-    await new Promise((resolve) => setTimeout(resolve, delay));
+    const delayMs = reconnectMgr.nextDelay();
+    console.error(`[orchestrator] Reconnecting in ${Math.round(delayMs / 1000)}s...`);
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
     try {
       await register();
     } catch {