@love-moon/conductor-sdk 0.2.14 → 0.2.16

package/dist/client.d.ts

@@ -52,6 +52,8 @@ export declare class ConductorClient {
     private readonly agentHost;
     private readonly onStopTask?;
     private closed;
+    private pendingOutbound;
+    private readonly ACK_TIMEOUT_MS;
     constructor(init: ConductorClientInit);
     static connect(options?: ConductorClientConnectOptions): Promise<ConductorClient>;
     close(): Promise<void>;
@@ -86,6 +88,25 @@ export declare class ConductorClient {
     matchProjectByPath(payload?: Record<string, any>): Promise<Record<string, any>>;
     bindProjectPath(projectId: string, payload?: Record<string, any>): Promise<Record<string, any>>;
     private readonly handleBackendEvent;
+    /**
+     * Handle acknowledgment messages from backend for confirmable outbound messages
+     */
+    private handleAcknowledgment;
+    /**
+     * Send a confirmable message and wait for acknowledgment from backend.
+     * Implements reliable delivery with idempotency.
+     */
+    private sendConfirmable;
+    /**
+     * Actually send a confirmable message over websocket.
+     * Called initially and on reconnection.
+     */
+    private doSendConfirmable;
+    /**
+     * Flush all pending confirmable messages.
+     * Called after websocket reconnection.
+     */
+    private flushPendingOutbound;
     private sendEnvelope;
     private maybeAckInboundCommand;
     private handleStopTaskEvent;

package/dist/client.js

@@ -18,6 +18,8 @@ export class ConductorClient {
     agentHost;
     onStopTask;
     closed = false;
+    pendingOutbound = new Map();
+    ACK_TIMEOUT_MS = 30000; // 30 seconds timeout for acknowledgment
     constructor(init) {
         this.config = init.config;
         this.env = init.env;
@@ -45,6 +47,10 @@ export class ConductorClient {
                 hostName: agentHost,
                 onConnected: options.onConnected,
                 onDisconnected: options.onDisconnected,
+                onReconnected: () => {
+                    // Resend pending confirmable messages after reconnection
+                    void client.flushPendingOutbound();
+                },
             });
         const client = new ConductorClient({
             config,
@@ -145,15 +151,15 @@ export class ConductorClient {
         };
     }
     async sendMessage(taskId, content, metadata) {
-        await this.sendEnvelope({
-            type: 'sdk_message',
-            payload: {
-                task_id: taskId,
-                content,
-                metadata,
-            },
-        });
-        return { delivered: true };
+        const messageId = safeRandomUuid();
+        const payload = {
+            task_id: taskId,
+            content,
+            metadata,
+            message_id: messageId,
+        };
+        await this.sendConfirmable('sdk_message', payload, messageId);
+        return { delivered: true, message_id: messageId };
     }
     async sendTaskStatus(taskId, payload) {
         await this.sendEnvelope({
@@ -210,16 +216,14 @@ export class ConductorClient {
         if (!requestId) {
             throw new Error('request_id is required');
         }
-        await this.sendEnvelope({
-            type: 'agent_command_ack',
-            payload: {
-                request_id: requestId,
-                task_id: payload.task_id,
-                event_type: payload.event_type,
-                accepted: payload.accepted !== false,
-            },
-        });
-        return { delivered: true };
+        const envelopePayload = {
+            request_id: requestId,
+            task_id: payload.task_id,
+            event_type: payload.event_type,
+            accepted: payload.accepted !== false,
+        };
+        await this.sendConfirmable('agent_command_ack', envelopePayload, requestId);
+        return { delivered: true, request_id: requestId };
     }
     async sendTaskStopAck(payload) {
         const taskId = String(payload.task_id || '').trim();
@@ -418,6 +422,8 @@ export class ConductorClient {
         };
     }
     handleBackendEvent = async (payload) => {
+        // First handle acknowledgments for confirmable outbound messages
+        this.handleAcknowledgment(payload);
         const stopCommandAccepted = await this.handleStopTaskEvent(payload);
         await this.messageRouter.handleBackendEvent(payload);
         await this.maybeAckInboundCommand(payload, {
@@ -426,6 +432,126 @@ export class ConductorClient {
                 : undefined,
         });
     };
+    /**
+     * Handle acknowledgment messages from backend for confirmable outbound messages
+     */
+    handleAcknowledgment(payload) {
+        const eventType = typeof payload?.type === 'string' ? payload.type : '';
+        const data = payload?.payload && typeof payload.payload === 'object'
+            ? payload.payload
+            : null;
+        if (!data)
+            return;
+        if (eventType === 'message_recorded') {
+            // Acknowledgment for sdk_message
+            const messageId = typeof data.message_id === 'string' ? data.message_id : null;
+            if (messageId && this.pendingOutbound.has(messageId)) {
+                const pending = this.pendingOutbound.get(messageId);
+                if (pending.type === 'sdk_message') {
+                    this.pendingOutbound.delete(messageId);
+                    pending.resolve();
+                }
+            }
+        }
+        else if (eventType === 'agent_command_ack_recorded') {
+            // Acknowledgment for agent_command_ack
+            const requestId = typeof data.request_id === 'string' ? data.request_id : null;
+            if (requestId && this.pendingOutbound.has(requestId)) {
+                const pending = this.pendingOutbound.get(requestId);
+                if (pending.type === 'agent_command_ack') {
+                    this.pendingOutbound.delete(requestId);
+                    pending.resolve();
+                }
+            }
+        }
+    }
+    /**
+     * Send a confirmable message and wait for acknowledgment from backend.
+     * Implements reliable delivery with idempotency.
+     */
+    async sendConfirmable(type, payload, stableId) {
+        // Check if there's already a pending message with this stableId
+        const existingPending = this.pendingOutbound.get(stableId);
+        if (existingPending) {
+            // Return the existing promise to deduplicate in-flight requests
+            return new Promise((resolve, reject) => {
+                const checkResolved = () => {
+                    if (!this.pendingOutbound.has(stableId)) {
+                        resolve();
+                        return;
+                    }
+                    const pending = this.pendingOutbound.get(stableId);
+                    if (pending.retryCount > 100) { // Safety limit
+                        reject(new Error(`Message ${stableId} exceeded max retry attempts`));
+                        return;
+                    }
+                    setTimeout(checkResolved, 100);
+                };
+                checkResolved();
+            });
+        }
+        return new Promise((resolve, reject) => {
+            const now = Date.now();
+            const pendingMessage = {
+                type,
+                payload,
+                stableId,
+                firstSentAt: now,
+                lastSentAt: now,
+                retryCount: 0,
+                resolve,
+                reject,
+            };
+            this.pendingOutbound.set(stableId, pendingMessage);
+            // Send the message
+            void this.doSendConfirmable(stableId);
+            // Set timeout for acknowledgment
+            setTimeout(() => {
+                if (this.pendingOutbound.has(stableId)) {
+                    this.pendingOutbound.delete(stableId);
+                    reject(new Error(`Timeout waiting for acknowledgment of ${type} (${stableId})`));
+                }
+            }, this.ACK_TIMEOUT_MS);
+        });
+    }
+    /**
+     * Actually send a confirmable message over websocket.
+     * Called initially and on reconnection.
+     */
+    async doSendConfirmable(stableId) {
+        const pending = this.pendingOutbound.get(stableId);
+        if (!pending)
+            return; // Already acknowledged or timed out
+        try {
+            await this.sendEnvelope({
+                type: pending.type,
+                payload: pending.payload,
+            });
+            pending.lastSentAt = Date.now();
+            pending.retryCount++;
+        }
+        catch (error) {
+            // Send failed - message remains in pending queue for retry on reconnection
+            console.warn(`[sdk] Failed to send ${pending.type} (${stableId}): ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Flush all pending confirmable messages.
+     * Called after websocket reconnection.
+     */
+    async flushPendingOutbound() {
+        if (this.pendingOutbound.size === 0)
+            return;
+        console.log(`[sdk] Flushing ${this.pendingOutbound.size} pending confirmable messages after reconnection`);
+        const promises = [];
+        for (const [stableId, pending] of this.pendingOutbound) {
+            promises.push(this.doSendConfirmable(stableId));
+        }
+        // Wait for all sends to complete (but not for acknowledgments)
+        await Promise.all(promises).catch(() => {
+            // Errors are logged in doSendConfirmable, messages remain pending
+        });
+    }
     async sendEnvelope(envelope) {
         await this.wsClient.sendJson(envelope);
     }

package/dist/ws/client.d.ts

@@ -21,6 +21,7 @@ export interface WebSocketClientOptions {
         isReconnect: boolean;
     }) => void;
     onDisconnected?: () => void;
+    onReconnected?: () => void;
 }
 export declare class ConductorWebSocketClient {
     private readonly url;
@@ -30,6 +31,7 @@ export declare class ConductorWebSocketClient {
     private readonly connectImpl;
     private readonly onConnected?;
     private readonly onDisconnected?;
+    private readonly onReconnected?;
     private readonly handlers;
     private readonly extraHeaders;
     private conn;
@@ -52,6 +54,7 @@ export declare class ConductorWebSocketClient {
     private handleConnectionLoss;
     private dispatch;
     private notifyConnected;
+    private notifyReconnected;
     private notifyDisconnected;
     private isConnectionClosed;
     private sendWithReconnect;

package/dist/ws/client.js

@@ -16,6 +16,7 @@ export class ConductorWebSocketClient {
     connectImpl;
     onConnected;
     onDisconnected;
+    onReconnected;
     handlers = [];
     extraHeaders;
     conn = null;
@@ -37,6 +38,7 @@ export class ConductorWebSocketClient {
         this.connectImpl = options.connectImpl ?? defaultConnectImpl;
         this.onConnected = options.onConnected;
         this.onDisconnected = options.onDisconnected;
+        this.onReconnected = options.onReconnected;
     }
     registerHandler(handler) {
         this.handlers.push(handler);
@@ -85,6 +87,9 @@ export class ConductorWebSocketClient {
                     const isReconnect = this.hasConnectedAtLeastOnce;
                     this.hasConnectedAtLeastOnce = true;
                     this.notifyConnected(isReconnect);
+                    if (isReconnect) {
+                        this.notifyReconnected();
+                    }
                     this.listenTask = this.listenLoop(this.conn);
                     this.heartbeatTask = this.heartbeatLoop(this.conn);
                     return;
@@ -165,6 +170,17 @@ export class ConductorWebSocketClient {
             // Swallow callback errors to avoid impacting reconnect behavior.
         }
     }
+    notifyReconnected() {
+        if (!this.onReconnected) {
+            return;
+        }
+        try {
+            this.onReconnected();
+        }
+        catch {
+            // Swallow callback errors to avoid impacting reconnect behavior.
+        }
+    }
     notifyDisconnected() {
         if (!this.onDisconnected) {
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/conductor-sdk",
-  "version": "0.2.14",
+  "version": "0.2.16",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -26,5 +26,6 @@
     "@types/ws": "^8.5.12",
     "typescript": "^5.6.3",
     "vitest": "^2.1.4"
-  }
+  },
+  "gitCommitId": "13b4d6c"
 }