@love-moon/conductor-sdk 0.2.10 → 0.2.12

package/dist/client.d.ts

@@ -21,6 +21,7 @@ export interface ConductorClientConnectOptions {
         isReconnect: boolean;
     }) => void;
     onDisconnected?: () => void;
+    onStopTask?: (event: StopTaskEvent) => Promise<void> | void;
 }
 interface ConductorClientInit {
     config: ConductorConfig;
@@ -32,6 +33,12 @@ interface ConductorClientInit {
     sessionStore: SessionDiskStore;
     messageRouter: MessageRouter;
     agentHost: string;
+    onStopTask?: (event: StopTaskEvent) => Promise<void> | void;
+}
+export interface StopTaskEvent {
+    taskId: string;
+    requestId?: string;
+    reason?: string;
 }
 export declare class ConductorClient {
     private readonly config;
@@ -43,6 +50,7 @@ export declare class ConductorClient {
     private readonly sessionStore;
     private readonly messageRouter;
     private readonly agentHost;
+    private readonly onStopTask?;
     private closed;
     constructor(init: ConductorClientInit);
     static connect(options?: ConductorClientConnectOptions): Promise<ConductorClient>;
@@ -62,6 +70,11 @@ export declare class ConductorClient {
         event_type?: string;
         accepted?: boolean;
     }): Promise<Record<string, any>>;
+    sendTaskStopAck(payload: {
+        task_id: string;
+        request_id: string;
+        accepted?: boolean;
+    }): Promise<Record<string, any>>;
     receiveMessages(taskId: string, limit?: number): Promise<Record<string, any>>;
     ackMessages(taskId: string, ackToken?: string | null): Promise<Record<string, any> | undefined>;
     listProjects(): Promise<Record<string, any>>;
@@ -73,6 +86,7 @@ export declare class ConductorClient {
     private readonly handleBackendEvent;
     private sendEnvelope;
     private maybeAckInboundCommand;
+    private handleStopTaskEvent;
     private resolveHostname;
     private waitForTaskCreation;
     private readIntEnv;

package/dist/client.js

@@ -1,6 +1,7 @@
 import crypto from 'node:crypto';
 import { BackendApiClient } from './backend/index.js';
 import { loadConfig } from './config/index.js';
+import { getPlanLimitMessageFromError } from './limits/index.js';
 import { MessageRouter } from './message/index.js';
 import { SessionDiskStore, SessionManager, currentHostname, currentSessionId } from './session/index.js';
 import { ConductorWebSocketClient } from './ws/index.js';
@@ -15,6 +16,7 @@ export class ConductorClient {
     sessionStore;
     messageRouter;
     agentHost;
+    onStopTask;
     closed = false;
     constructor(init) {
         this.config = init.config;
@@ -26,6 +28,7 @@ export class ConductorClient {
         this.sessionStore = init.sessionStore;
         this.messageRouter = init.messageRouter;
         this.agentHost = init.agentHost;
+        this.onStopTask = init.onStopTask;
         this.wsClient.registerHandler(this.handleBackendEvent);
     }
     static async connect(options = {}) {
@@ -53,6 +56,7 @@ export class ConductorClient {
             sessionStore,
             messageRouter,
             agentHost,
+            onStopTask: options.onStopTask,
         });
         await client.wsClient.connect();
         return client;
@@ -73,22 +77,31 @@ export class ConductorClient {
         const taskId = String(payload.task_id || safeRandomUuid());
         const sessionId = String(payload.session_id || taskId);
         await this.sessions.addSession(taskId, sessionId, projectId);
-        await this.backendApi.createTask({
-            id: taskId,
-            projectId,
-            title,
-            backendType: typeof payload.backend_type === 'string'
-                ? payload.backend_type
-                : typeof payload.backendType === 'string'
-                    ? payload.backendType
-                    : undefined,
-            initialContent: typeof payload.prefill === 'string' ? payload.prefill : undefined,
-            agentHost: typeof payload.agent_host === 'string'
-                ? payload.agent_host
-                : typeof payload.agentHost === 'string'
-                    ? payload.agentHost
-                    : this.agentHost,
-        });
+        try {
+            await this.backendApi.createTask({
+                id: taskId,
+                projectId,
+                title,
+                backendType: typeof payload.backend_type === 'string'
+                    ? payload.backend_type
+                    : typeof payload.backendType === 'string'
+                        ? payload.backendType
+                        : undefined,
+                initialContent: typeof payload.prefill === 'string' ? payload.prefill : undefined,
+                agentHost: typeof payload.agent_host === 'string'
+                    ? payload.agent_host
+                    : typeof payload.agentHost === 'string'
+                        ? payload.agentHost
+                        : this.agentHost,
+            });
+        }
+        catch (error) {
+            const limitMessage = getPlanLimitMessageFromError(error);
+            if (limitMessage) {
+                throw new Error(limitMessage, error instanceof Error ? { cause: error } : undefined);
+            }
+            throw error;
+        }
         await this.waitForTaskCreation(projectId, taskId);
         const projectPath = typeof payload.project_path === 'string' && payload.project_path
             ? payload.project_path
@@ -177,6 +190,25 @@ export class ConductorClient {
         });
         return { delivered: true };
     }
+    async sendTaskStopAck(payload) {
+        const taskId = String(payload.task_id || '').trim();
+        const requestId = String(payload.request_id || '').trim();
+        if (!taskId) {
+            throw new Error('task_id is required');
+        }
+        if (!requestId) {
+            throw new Error('request_id is required');
+        }
+        await this.sendEnvelope({
+            type: 'task_stop_ack',
+            payload: {
+                task_id: taskId,
+                request_id: requestId,
+                accepted: payload.accepted !== false,
+            },
+        });
+        return { delivered: true };
+    }
     async receiveMessages(taskId, limit = 20) {
         const messages = await this.sessions.popMessages(taskId, limit);
         return formatMessagesResponse(messages);
@@ -278,15 +310,20 @@ export class ConductorClient {
         };
     }
     handleBackendEvent = async (payload) => {
+        const stopCommandAccepted = await this.handleStopTaskEvent(payload);
         await this.messageRouter.handleBackendEvent(payload);
-        await this.maybeAckInboundCommand(payload);
+        await this.maybeAckInboundCommand(payload, {
+            accepted: typeof stopCommandAccepted === 'boolean'
+                ? stopCommandAccepted
+                : undefined,
+        });
     };
     async sendEnvelope(envelope) {
         await this.wsClient.sendJson(envelope);
     }
-    async maybeAckInboundCommand(payload) {
+    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 !== 'stop_task') {
             return;
         }
         const data = payload?.payload && typeof payload.payload === 'object'
@@ -304,7 +341,7 @@ export class ConductorClient {
                 request_id: requestId,
                 task_id: typeof data.task_id === 'string' ? data.task_id : undefined,
                 event_type: eventType,
-                accepted: true,
+                accepted: typeof options.accepted === 'boolean' ? options.accepted : true,
             });
         }
         catch (error) {
@@ -312,6 +349,52 @@ export class ConductorClient {
             console.warn(`[sdk] failed to ack inbound command ${requestId}: ${message}`);
         }
     }
+    async handleStopTaskEvent(payload) {
+        if (typeof payload?.type !== 'string' || payload.type !== 'stop_task') {
+            return undefined;
+        }
+        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() : '';
+        if (!taskId) {
+            return false;
+        }
+        let accepted = false;
+        if (this.onStopTask) {
+            try {
+                await this.onStopTask({
+                    taskId,
+                    requestId: requestId || undefined,
+                    reason: reason || undefined,
+                });
+                accepted = true;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.warn(`[sdk] stop_task callback failed for task ${taskId}: ${message}`);
+            }
+        }
+        if (requestId) {
+            try {
+                await this.sendTaskStopAck({
+                    task_id: taskId,
+                    request_id: requestId,
+                    accepted,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.warn(`[sdk] failed to send task_stop_ack for task ${taskId}: ${message}`);
+            }
+        }
+        return accepted;
+    }
     resolveHostname() {
         const records = this.sessionStore.load();
         for (const record of records) {

package/dist/index.d.ts

@@ -5,3 +5,4 @@ export * from './session/index.js';
 export * from './message/index.js';
 export * from './client.js';
 export * from './context/index.js';
+export * from './limits/index.js';

package/dist/index.js

@@ -5,3 +5,4 @@ export * from './session/index.js';
 export * from './message/index.js';
 export * from './client.js';
 export * from './context/index.js';
+export * from './limits/index.js';

package/dist/limits/index.d.ts

@@ -0,0 +1 @@
+export * from './plan_limits.js';

package/dist/limits/index.js

@@ -0,0 +1 @@
+export * from './plan_limits.js';

package/dist/limits/plan_limits.d.ts

@@ -0,0 +1,3 @@
+export declare function getPlanLimitMessageFromDetails(details: unknown): string | null;
+export declare function getPlanLimitMessageFromError(error: unknown): string | null;
+export declare function getPlanLimitMessageFromRealtimeEvent(event: unknown): string | null;

package/dist/limits/plan_limits.js

@@ -0,0 +1,80 @@
+const PLAN_LIMIT_MESSAGES = {
+    manual_fire_active_task: 'Free plan limit reached: only 1 active fire task is allowed.',
+    app_active_task: 'Free plan limit reached: only 1 active app task is allowed.',
+    daemon_active_connection: 'Free plan limit reached: only 1 active daemon connection is allowed.',
+};
+function normalizeText(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const text = value.trim();
+    return text ? text : null;
+}
+function getMessageByLimitType(limitType) {
+    const normalized = limitType.trim().toLowerCase();
+    if (normalized in PLAN_LIMIT_MESSAGES) {
+        return PLAN_LIMIT_MESSAGES[normalized];
+    }
+    if (normalized === 'free_daemon_connection' || normalized === 'free-daemon-limit') {
+        return PLAN_LIMIT_MESSAGES.daemon_active_connection;
+    }
+    return null;
+}
+function inferFromText(raw) {
+    const text = normalizeText(raw);
+    if (!text) {
+        return null;
+    }
+    const lower = text.toLowerCase();
+    if (lower.includes('one active manual fire task')) {
+        return PLAN_LIMIT_MESSAGES.manual_fire_active_task;
+    }
+    if (lower.includes('one active app task')) {
+        return PLAN_LIMIT_MESSAGES.app_active_task;
+    }
+    if (lower.includes('one active daemon connection')) {
+        return PLAN_LIMIT_MESSAGES.daemon_active_connection;
+    }
+    if (lower.includes('free plan task limit reached')) {
+        return 'Free plan task limit reached: only 1 active fire task and 1 active app task are allowed.';
+    }
+    return null;
+}
+export function getPlanLimitMessageFromDetails(details) {
+    if (!details) {
+        return null;
+    }
+    if (typeof details === 'string') {
+        return inferFromText(details);
+    }
+    if (typeof details !== 'object') {
+        return null;
+    }
+    const payload = details;
+    const byType = normalizeText(payload.limit_type);
+    if (byType) {
+        const mapped = getMessageByLimitType(byType);
+        if (mapped) {
+            return mapped;
+        }
+    }
+    return inferFromText(payload.message) ?? inferFromText(payload.error);
+}
+export function getPlanLimitMessageFromError(error) {
+    if (!error || typeof error !== 'object') {
+        return null;
+    }
+    const payload = error;
+    return (getPlanLimitMessageFromDetails(payload.details) ??
+        inferFromText(payload.message));
+}
+export function getPlanLimitMessageFromRealtimeEvent(event) {
+    if (!event || typeof event !== 'object') {
+        return null;
+    }
+    const payload = event;
+    if (typeof payload.type === 'string' && payload.type !== 'error') {
+        return null;
+    }
+    return getPlanLimitMessageFromDetails(payload.payload);
+}

package/package.json

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