@love-moon/conductor-sdk 0.2.31 → 0.2.32

package/dist/client.d.ts

@@ -47,6 +47,10 @@ export interface StopTaskEvent {
     requestId?: string;
     reason?: string;
 }
+export interface FlushPendingUpstreamEventsOptions {
+    timeoutMs?: number;
+    retryIntervalMs?: number;
+}
 export declare class ConductorClient {
     private readonly config;
     private readonly env;
@@ -68,6 +72,10 @@ export declare class ConductorClient {
     constructor(init: ConductorClientInit);
     static connect(options?: ConductorClientConnectOptions): Promise<ConductorClient>;
     close(): Promise<void>;
+    flushPendingUpstreamEvents(options?: FlushPendingUpstreamEventsOptions): Promise<{
+        flushed: boolean;
+        remaining: number;
+    }>;
     forceReconnect(reason?: string): Promise<void>;
     createTaskSession(payload: Record<string, any>): Promise<Record<string, any>>;
     sendMessage(taskId: string, content: string, metadata?: Record<string, any>): Promise<Record<string, any>>;

package/dist/client.js

@@ -91,10 +91,30 @@ export class ConductorClient {
         if (this.closed) {
             return;
         }
-        this.closed = true;
         this.clearDurableOutboxTimer();
+        await this.flushPendingUpstreamEvents({
+            timeoutMs: 2_000,
+            retryIntervalMs: 100,
+        });
+        this.closed = true;
         await this.wsClient.disconnect();
     }
+    async flushPendingUpstreamEvents(options = {}) {
+        const timeoutMs = Math.max(0, options.timeoutMs ?? 5_000);
+        const retryIntervalMs = Math.max(10, options.retryIntervalMs ?? 250);
+        const startedAt = Date.now();
+        while (true) {
+            await this.requestDurableOutboxFlush(true);
+            const remaining = this.upstreamOutbox.load().length;
+            if (remaining === 0) {
+                return { flushed: true, remaining: 0 };
+            }
+            if (Date.now() - startedAt >= timeoutMs) {
+                return { flushed: false, remaining };
+            }
+            await sleep(retryIntervalMs);
+        }
+    }
     async forceReconnect(reason = 'manual_reconnect') {
         if (typeof this.wsClient.forceReconnect === 'function') {
             await this.wsClient.forceReconnect(reason);

package/dist/ws/client.d.ts

@@ -41,6 +41,7 @@ export interface WebSocketDisconnectEvent {
 }
 export interface WebSocketClientOptions {
     reconnectDelay?: number;
+    duplicateHostReconnectDelay?: number;
     heartbeatInterval?: number;
     extraHeaders?: Record<string, string>;
     connectImpl?: ConnectImpl;
@@ -54,6 +55,7 @@ export declare class ConductorWebSocketClient {
     private readonly url;
     private readonly token;
     private readonly reconnectDelay;
+    private readonly duplicateHostReconnectDelay;
     private readonly heartbeatInterval;
     private readonly connectImpl;
     private readonly onConnected?;
@@ -83,6 +85,7 @@ export declare class ConductorWebSocketClient {
     private listenLoop;
     private heartbeatLoop;
     private handleConnectionLoss;
+    private getReconnectDelay;
     private dispatch;
     private notifyConnected;
     private notifyReconnected;

package/dist/ws/client.js

@@ -12,6 +12,7 @@ export class ConductorWebSocketClient {
     url;
     token;
     reconnectDelay;
+    duplicateHostReconnectDelay;
     heartbeatInterval;
     connectImpl;
     onConnected;
@@ -32,6 +33,7 @@ export class ConductorWebSocketClient {
         this.url = config.resolvedWebsocketUrl;
         this.token = config.agentToken;
         this.reconnectDelay = options.reconnectDelay ?? 10_000;
+        this.duplicateHostReconnectDelay = options.duplicateHostReconnectDelay ?? Math.max(this.reconnectDelay, 2_000);
         this.heartbeatInterval = options.heartbeatInterval ?? 20_000;
         this.extraHeaders = {
             'x-conductor-host': options.hostName ?? defaultHostName(),
@@ -184,8 +186,16 @@ export class ConductorWebSocketClient {
         this.conn = null;
         this.runtime = null;
         this.notifyDisconnected(this.buildDisconnectEvent(runtime));
+        await wait(this.getReconnectDelay(runtime), this.waitController.signal);
         await this.openConnection(true);
     }
+    getReconnectDelay(runtime) {
+        if (runtime?.closeCode === 4002 &&
+            String(runtime?.closeReason || '').trim().toLowerCase() === 'duplicate-host') {
+            return this.duplicateHostReconnectDelay;
+        }
+        return this.reconnectDelay;
+    }
     async dispatch(message) {
         const now = Date.now();
         if (this.runtime) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/conductor-sdk",
-  "version": "0.2.31",
+  "version": "0.2.32",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,5 +27,5 @@
     "typescript": "^5.6.3",
     "vitest": "^2.1.4"
   },
-  "gitCommitId": "7e0bd83"
+  "gitCommitId": "c749d4b"
 }