@love-moon/conductor-sdk 0.1.3 → 0.2.0

package/dist/bin/mcp-server.js

@@ -97,6 +97,28 @@ async function main() {
                         required: ['task_id', 'content'],
                     },
                 },
+                {
+                    name: 'send_runtime_status',
+                    description: 'Send a runtime status update to a task',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            task_id: { type: 'string' },
+                            state: { type: 'string' },
+                            phase: { type: 'string' },
+                            source: { type: 'string' },
+                            reply_in_progress: { type: 'boolean' },
+                            status_line: { type: 'string' },
+                            status_done_line: { type: 'string' },
+                            reply_preview: { type: 'string' },
+                            reply_to: { type: 'string' },
+                            backend: { type: 'string' },
+                            thread_id: { type: 'string' },
+                            created_at: { type: 'string' },
+                        },
+                        required: ['task_id'],
+                    },
+                },
                 {
                     name: 'receive_messages',
                     description: 'Receive messages from a task',

package/dist/mcp/server.d.ts

@@ -24,6 +24,7 @@ export declare class MCPServer {
     handleRequest(toolName: string, payload: ToolRequest): Promise<ToolResponse>;
     private toolCreateTaskSession;
     private toolSendMessage;
+    private toolSendRuntimeStatus;
     private toolReceiveMessages;
     private toolAckMessages;
     private toolListProjects;

package/dist/mcp/server.js

@@ -16,6 +16,7 @@ export class MCPServer {
         this.tools = {
             create_task_session: this.toolCreateTaskSession,
             send_message: this.toolSendMessage,
+            send_runtime_status: this.toolSendRuntimeStatus,
             receive_messages: this.toolReceiveMessages,
             ack_messages: this.toolAckMessages,
             list_projects: this.toolListProjects,
@@ -82,6 +83,30 @@ export class MCPServer {
         });
         return { delivered: true };
     }
+    async toolSendRuntimeStatus(payload) {
+        const taskId = String(payload.task_id || '');
+        if (!taskId) {
+            throw new Error('task_id required');
+        }
+        await this.options.backendSender({
+            type: 'task_runtime_status',
+            payload: {
+                task_id: taskId,
+                state: payload.state,
+                phase: payload.phase,
+                source: payload.source,
+                reply_in_progress: payload.reply_in_progress,
+                status_line: payload.status_line,
+                status_done_line: payload.status_done_line,
+                reply_preview: payload.reply_preview,
+                reply_to: payload.reply_to,
+                backend: payload.backend,
+                thread_id: payload.thread_id,
+                created_at: payload.created_at,
+            },
+        });
+        return { delivered: true };
+    }
     async toolReceiveMessages(payload) {
         const taskId = String(payload.task_id || '');
         if (!taskId) {

package/dist/ws/client.d.ts

@@ -17,6 +17,10 @@ export interface WebSocketClientOptions {
     extraHeaders?: Record<string, string>;
     connectImpl?: ConnectImpl;
     hostName?: string;
+    onConnected?: (event: {
+        isReconnect: boolean;
+    }) => void;
+    onDisconnected?: () => void;
 }
 export declare class ConductorWebSocketClient {
     private readonly url;
@@ -24,6 +28,8 @@ export declare class ConductorWebSocketClient {
     private readonly reconnectDelay;
     private readonly heartbeatInterval;
     private readonly connectImpl;
+    private readonly onConnected?;
+    private readonly onDisconnected?;
     private readonly handlers;
     private readonly extraHeaders;
     private conn;
@@ -32,6 +38,7 @@ export declare class ConductorWebSocketClient {
     private heartbeatTask;
     private readonly lock;
     private waitController;
+    private hasConnectedAtLeastOnce;
     constructor(config: ConductorConfig, options?: WebSocketClientOptions);
     registerHandler(handler: WebSocketHandler): void;
     connect(): Promise<void>;
@@ -42,7 +49,10 @@ export declare class ConductorWebSocketClient {
     private cancelTasks;
     private listenLoop;
     private heartbeatLoop;
+    private handleConnectionLoss;
     private dispatch;
+    private notifyConnected;
+    private notifyDisconnected;
     private isConnectionClosed;
     private sendWithReconnect;
     private isNotOpenError;

package/dist/ws/client.js

@@ -14,6 +14,8 @@ export class ConductorWebSocketClient {
     reconnectDelay;
     heartbeatInterval;
     connectImpl;
+    onConnected;
+    onDisconnected;
     handlers = [];
     extraHeaders;
     conn = null;
@@ -22,16 +24,19 @@ export class ConductorWebSocketClient {
     heartbeatTask = null;
     lock = new AsyncLock();
     waitController = new AbortController();
+    hasConnectedAtLeastOnce = false;
     constructor(config, options = {}) {
         this.url = config.resolvedWebsocketUrl;
         this.token = config.agentToken;
-        this.reconnectDelay = options.reconnectDelay ?? 3000;
+        this.reconnectDelay = options.reconnectDelay ?? 10_000;
         this.heartbeatInterval = options.heartbeatInterval ?? 20_000;
         this.extraHeaders = {
             'x-conductor-host': options.hostName ?? defaultHostName(),
             ...(options.extraHeaders ?? {}),
         };
         this.connectImpl = options.connectImpl ?? defaultConnectImpl;
+        this.onConnected = options.onConnected;
+        this.onDisconnected = options.onDisconnected;
     }
     registerHandler(handler) {
         this.handlers.push(handler);
@@ -77,13 +82,16 @@ export class ConductorWebSocketClient {
                 try {
                     const headers = { Authorization: `Bearer ${this.token}`, ...this.extraHeaders };
                     this.conn = await this.connectImpl(this.url, { headers });
+                    const isReconnect = this.hasConnectedAtLeastOnce;
+                    this.hasConnectedAtLeastOnce = true;
+                    this.notifyConnected(isReconnect);
                     this.listenTask = this.listenLoop(this.conn);
                     this.heartbeatTask = this.heartbeatLoop(this.conn);
                     return;
                 }
                 catch (error) {
                     if (force) {
-                        console.warn(`[WebSocket] Connection failed, retrying in ${this.reconnectDelay}ms... (${error instanceof Error ? error.message : String(error)})`);
+                        console.warn(`[${formatBeijingTimestamp()}] [WebSocket] Connection failed, retrying in ${this.reconnectDelay}ms... (${error instanceof Error ? error.message : String(error)})`);
                     }
                     await wait(this.reconnectDelay, this.waitController.signal);
                 }
@@ -104,9 +112,7 @@ export class ConductorWebSocketClient {
             // Ignore errors; reconnection logic handles it.
         }
         finally {
-            if (!this.stop && conn === this.conn) {
-                await this.openConnection(true);
-            }
+            await this.handleConnectionLoss(conn);
         }
     }
     async heartbeatLoop(conn) {
@@ -122,11 +128,17 @@ export class ConductorWebSocketClient {
             }
         }
         finally {
-            if (!this.stop && conn === this.conn) {
-                await this.openConnection(true);
-            }
+            await this.handleConnectionLoss(conn);
         }
     }
+    async handleConnectionLoss(conn) {
+        if (this.stop || conn !== this.conn) {
+            return;
+        }
+        this.conn = null;
+        this.notifyDisconnected();
+        await this.openConnection(true);
+    }
     async dispatch(message) {
         let payload;
         try {
@@ -142,6 +154,28 @@ export class ConductorWebSocketClient {
             }
         }
     }
+    notifyConnected(isReconnect) {
+        if (!this.onConnected) {
+            return;
+        }
+        try {
+            this.onConnected({ isReconnect });
+        }
+        catch {
+            // Swallow callback errors to avoid impacting reconnect behavior.
+        }
+    }
+    notifyDisconnected() {
+        if (!this.onDisconnected) {
+            return;
+        }
+        try {
+            this.onDisconnected();
+        }
+        catch {
+            // Swallow callback errors to avoid impacting reconnect behavior.
+        }
+    }
     isConnectionClosed(conn) {
         if (!conn) {
             return true;
@@ -171,6 +205,10 @@ export class ConductorWebSocketClient {
                     throw error instanceof Error ? error : new Error(String(error));
                 }
                 attemptedReconnect = true;
+                if (this.conn === conn) {
+                    this.conn = null;
+                    this.notifyDisconnected();
+                }
                 await this.openConnection(true);
             }
         }
@@ -199,6 +237,9 @@ async function wait(ms, signal) {
         signal.addEventListener('abort', onAbort, { once: true });
     });
 }
+function formatBeijingTimestamp(date = new Date()) {
+    return date.toLocaleString('sv-SE', { timeZone: 'Asia/Shanghai', hour12: false }).replace(' ', 'T');
+}
 async function defaultConnectImpl(url, options) {
     const { default: WebSocket } = await import('ws');
     return new Promise((resolve, reject) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/conductor-sdk",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",