@love-moon/conductor-sdk 0.2.38 → 0.2.40

package/dist/client.d.ts

@@ -26,6 +26,8 @@ export interface ConductorClientConnectOptions {
     onDisconnected?: (event: WebSocketDisconnectEvent) => void;
     onPong?: (event: WebSocketPongEvent) => void;
     onStopTask?: (event: StopTaskEvent) => Promise<void> | void;
+    onInterruptTurn?: (event: InterruptTurnEvent) => Promise<boolean | void> | boolean | void;
+    onRefreshSession?: (event: RefreshSessionEvent) => Promise<boolean | void> | boolean | void;
 }
 interface ConductorClientInit {
     config: ConductorConfig;
@@ -41,12 +43,27 @@ interface ConductorClientInit {
     downstreamCursorStore: DownstreamCursorStore;
     agentHost: string;
     onStopTask?: (event: StopTaskEvent) => Promise<void> | void;
+    onInterruptTurn?: (event: InterruptTurnEvent) => Promise<boolean | void> | boolean | void;
+    onRefreshSession?: (event: RefreshSessionEvent) => Promise<boolean | void> | boolean | void;
 }
 export interface StopTaskEvent {
     taskId: string;
     requestId?: string;
     reason?: string;
 }
+export interface InterruptTurnEvent {
+    taskId: string;
+    requestId?: string;
+    reason?: string;
+    targetReplyTo: string;
+}
+export interface RefreshSessionEvent {
+    taskId: string;
+    requestId?: string;
+    reason?: string;
+    sessionId: string;
+    sessionFilePath?: string;
+}
 export interface FlushPendingUpstreamEventsOptions {
     timeoutMs?: number;
     retryIntervalMs?: number;
@@ -64,6 +81,8 @@ export declare class ConductorClient {
     private downstreamCursorStore;
     private readonly agentHost;
     private readonly onStopTask?;
+    private readonly onInterruptTurn?;
+    private readonly onRefreshSession?;
     private deliveryScopeId;
     private closed;
     private durableOutboxFlushPromise;
@@ -116,6 +135,10 @@ export declare class ConductorClient {
     private extractDownstreamCommandContext;
     private handleStopTaskCommand;
     private invokeStopTaskHandler;
+    private handleInterruptTurnCommand;
+    private handleRefreshSessionCommand;
+    private invokeInterruptTurnHandler;
+    private invokeRefreshSessionHandler;
     private persistAndCommitUpstreamEvent;
     private requestDurableOutboxFlush;
     private hasEarlierPendingSdkMessage;

package/dist/client.js

@@ -23,6 +23,8 @@ export class ConductorClient {
     downstreamCursorStore;
     agentHost;
     onStopTask;
+    onInterruptTurn;
+    onRefreshSession;
     deliveryScopeId;
     closed = false;
     durableOutboxFlushPromise = null;
@@ -41,6 +43,8 @@ export class ConductorClient {
         this.downstreamCursorStore = init.downstreamCursorStore;
         this.agentHost = init.agentHost;
         this.onStopTask = init.onStopTask;
+        this.onInterruptTurn = init.onInterruptTurn;
+        this.onRefreshSession = init.onRefreshSession;
         this.deliveryScopeId = init.deliveryScopeId;
         this.wsClient.registerHandler(this.handleBackendEvent);
     }
@@ -83,6 +87,8 @@ export class ConductorClient {
             downstreamCursorStore,
             agentHost,
             onStopTask: options.onStopTask,
+            onInterruptTurn: options.onInterruptTurn,
+            onRefreshSession: options.onRefreshSession,
         });
         await client.wsClient.connect();
         if (client.shouldAutoFlushDurableOutbox()) {
@@ -533,6 +539,21 @@ export class ConductorClient {
         };
     }
     handleBackendEvent = async (payload) => {
+        if (typeof payload?.type === 'string' && payload.type === 'refresh_session') {
+            void this.handleRefreshSessionCommand(payload).catch((error) => {
+                const data = payload?.payload && typeof payload.payload === 'object'
+                    ? payload.payload
+                    : null;
+                const taskId = typeof data?.task_id === 'string' ? data.task_id.trim() : '';
+                const message = error instanceof Error ? error.message : String(error);
+                console.warn(`[sdk] refresh_session dispatch failed${taskId ? ` for task ${taskId}` : ''}: ${message}`);
+            });
+            return;
+        }
+        if (typeof payload?.type === 'string' && payload.type === 'interrupt_turn') {
+            await this.handleInterruptTurnCommand(payload);
+            return;
+        }
         const command = this.extractDownstreamCommandContext(payload);
         if (command?.eventType === 'stop_task') {
             await this.handleStopTaskCommand(payload, command);
@@ -630,6 +651,92 @@ export class ConductorClient {
             return false;
         }
     }
+    async handleInterruptTurnCommand(payload) {
+        const accepted = await this.invokeInterruptTurnHandler(payload);
+        await this.maybeAckInboundCommand(payload, { accepted });
+    }
+    async handleRefreshSessionCommand(payload) {
+        const accepted = await this.invokeRefreshSessionHandler(payload);
+        await this.maybeAckInboundCommand(payload, { accepted });
+    }
+    async invokeInterruptTurnHandler(payload) {
+        const data = payload?.payload && typeof payload.payload === 'object'
+            ? payload.payload
+            : null;
+        if (!data) {
+            return false;
+        }
+        const taskId = typeof data.task_id === 'string' ? data.task_id.trim() : '';
+        const requestId = typeof data.request_id === 'string' ? data.request_id.trim() : '';
+        const reason = typeof data.reason === 'string' ? data.reason.trim() : '';
+        const targetReplyTo = typeof data.target_reply_to === 'string'
+            ? data.target_reply_to.trim()
+            : typeof data.targetReplyTo === 'string'
+                ? data.targetReplyTo.trim()
+                : '';
+        if (!taskId || !targetReplyTo) {
+            return false;
+        }
+        if (!this.onInterruptTurn) {
+            return false;
+        }
+        try {
+            const accepted = await this.onInterruptTurn({
+                taskId,
+                requestId: requestId || undefined,
+                reason: reason || undefined,
+                targetReplyTo,
+            });
+            return accepted !== false;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`[sdk] interrupt_turn callback failed for task ${taskId}: ${message}`);
+            return false;
+        }
+    }
+    async invokeRefreshSessionHandler(payload) {
+        const data = payload?.payload && typeof payload.payload === 'object'
+            ? payload.payload
+            : null;
+        if (!data) {
+            return false;
+        }
+        const taskId = typeof data.task_id === 'string' ? data.task_id.trim() : '';
+        const requestId = typeof data.request_id === 'string' ? data.request_id.trim() : '';
+        const reason = typeof data.reason === 'string' ? data.reason.trim() : '';
+        const sessionId = typeof data.session_id === 'string'
+            ? data.session_id.trim()
+            : typeof data.sessionId === 'string'
+                ? data.sessionId.trim()
+                : '';
+        const sessionFilePath = typeof data.session_file_path === 'string'
+            ? data.session_file_path.trim()
+            : typeof data.sessionFilePath === 'string'
+                ? data.sessionFilePath.trim()
+                : '';
+        if (!taskId || !sessionId) {
+            return false;
+        }
+        if (!this.onRefreshSession) {
+            return false;
+        }
+        try {
+            const accepted = await this.onRefreshSession({
+                taskId,
+                requestId: requestId || undefined,
+                reason: reason || undefined,
+                sessionId,
+                sessionFilePath: sessionFilePath || undefined,
+            });
+            return accepted !== false;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`[sdk] refresh_session callback failed for task ${taskId}: ${message}`);
+            return false;
+        }
+    }
     async persistAndCommitUpstreamEvent(entry) {
         const stored = this.upstreamOutbox.upsert(entry);
         if (stored.eventType === 'sdk_message' && this.hasEarlierPendingSdkMessage(stored.stableId)) {
@@ -796,7 +903,10 @@ export class ConductorClient {
     }
     async maybeAckInboundCommand(payload, options = {}) {
         const eventType = typeof payload?.type === 'string' ? payload.type : '';
-        if (eventType !== 'task_user_message' && eventType !== 'task_action') {
+        if (eventType !== 'task_user_message' &&
+            eventType !== 'task_action' &&
+            eventType !== 'interrupt_turn' &&
+            eventType !== 'refresh_session') {
             return;
         }
         const data = payload?.payload && typeof payload.payload === 'object'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/conductor-sdk",
-  "version": "0.2.38",
+  "version": "0.2.40",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,5 +27,5 @@
     "typescript": "^5.6.3",
     "vitest": "^2.1.4"
   },
-  "gitCommitId": "6bf5515"
+  "gitCommitId": "e08f8b6"
 }