@love-moon/conductor-sdk 0.2.16 → 0.2.18

package/dist/backend/client.d.ts

@@ -4,6 +4,30 @@ export interface BackendClientOptions {
     fetchImpl?: FetchFn;
     timeoutMs?: number;
 }
+export type AgentCommitEvent = {
+    eventType: 'sdk_message';
+    taskId: string;
+    content: string;
+    metadata?: Record<string, unknown>;
+    messageId?: string | null;
+} | {
+    eventType: 'task_status_update';
+    taskId: string;
+    status: string;
+    summary?: string | null;
+    statusEventId?: string | null;
+} | {
+    eventType: 'agent_command_ack';
+    requestId: string;
+    taskId?: string | null;
+    accepted?: boolean;
+    commandEventType?: string | null;
+} | {
+    eventType: 'task_stop_ack';
+    taskId: string;
+    requestId: string;
+    accepted?: boolean;
+};
 export declare class BackendApiError extends Error {
     readonly statusCode?: number | undefined;
     readonly details?: unknown | undefined;
@@ -50,6 +74,7 @@ export declare class BackendApiClient {
         id?: string;
         projectId: string;
         title: string;
+        status?: string;
         backendType?: string;
         sessionId?: string | null;
         sessionFilePath?: string | null;
@@ -73,6 +98,39 @@ export declare class BackendApiClient {
         content: string;
         metadata?: Record<string, unknown>;
     }): Promise<any>;
+    commitAgentEvents(params: {
+        agentHost: string;
+        events: AgentCommitEvent[];
+    }): Promise<{
+        results: Array<Record<string, unknown>>;
+    }>;
+    commitSdkMessage(params: {
+        agentHost: string;
+        taskId: string;
+        content: string;
+        metadata?: Record<string, unknown>;
+        messageId?: string | null;
+    }): Promise<Record<string, unknown>>;
+    commitTaskStatusUpdate(params: {
+        agentHost: string;
+        taskId: string;
+        status: string;
+        summary?: string | null;
+        statusEventId?: string | null;
+    }): Promise<Record<string, unknown>>;
+    commitAgentCommandAck(params: {
+        agentHost: string;
+        requestId: string;
+        taskId?: string | null;
+        accepted?: boolean;
+        commandEventType?: string | null;
+    }): Promise<Record<string, unknown>>;
+    commitTaskStopAck(params: {
+        agentHost: string;
+        taskId: string;
+        requestId: string;
+        accepted?: boolean;
+    }): Promise<Record<string, unknown>>;
     matchProjectByPath(params: {
         hostname: string;
         path: string;

package/dist/backend/client.js

@@ -152,6 +152,108 @@ export class BackendApiClient {
         });
         return this.parseJson(response);
     }
+    async commitAgentEvents(params) {
+        const response = await this.request('POST', '/agent/events', {
+            body: JSON.stringify({
+                agent_host: params.agentHost,
+                events: params.events.map((event) => {
+                    if (event.eventType === 'sdk_message') {
+                        return {
+                            event_type: event.eventType,
+                            task_id: event.taskId,
+                            content: event.content,
+                            metadata: event.metadata,
+                            message_id: event.messageId ?? undefined,
+                        };
+                    }
+                    if (event.eventType === 'task_status_update') {
+                        return {
+                            event_type: event.eventType,
+                            task_id: event.taskId,
+                            status: event.status,
+                            summary: event.summary ?? undefined,
+                            status_event_id: event.statusEventId ?? undefined,
+                        };
+                    }
+                    if (event.eventType === 'task_stop_ack') {
+                        return {
+                            event_type: event.eventType,
+                            task_id: event.taskId,
+                            request_id: event.requestId,
+                            accepted: event.accepted !== false,
+                        };
+                    }
+                    return {
+                        event_type: event.eventType,
+                        request_id: event.requestId,
+                        task_id: event.taskId ?? undefined,
+                        accepted: event.accepted !== false,
+                        command_event_type: event.commandEventType ?? undefined,
+                    };
+                }),
+            }),
+        });
+        return this.parseJson(response);
+    }
+    async commitSdkMessage(params) {
+        const payload = await this.commitAgentEvents({
+            agentHost: params.agentHost,
+            events: [
+                {
+                    eventType: 'sdk_message',
+                    taskId: params.taskId,
+                    content: params.content,
+                    metadata: params.metadata,
+                    messageId: params.messageId,
+                },
+            ],
+        });
+        return (Array.isArray(payload.results) ? payload.results[0] : null) ?? {};
+    }
+    async commitTaskStatusUpdate(params) {
+        const payload = await this.commitAgentEvents({
+            agentHost: params.agentHost,
+            events: [
+                {
+                    eventType: 'task_status_update',
+                    taskId: params.taskId,
+                    status: params.status,
+                    summary: params.summary,
+                    statusEventId: params.statusEventId,
+                },
+            ],
+        });
+        return (Array.isArray(payload.results) ? payload.results[0] : null) ?? {};
+    }
+    async commitAgentCommandAck(params) {
+        const payload = await this.commitAgentEvents({
+            agentHost: params.agentHost,
+            events: [
+                {
+                    eventType: 'agent_command_ack',
+                    requestId: params.requestId,
+                    taskId: params.taskId,
+                    accepted: params.accepted,
+                    commandEventType: params.commandEventType,
+                },
+            ],
+        });
+        return (Array.isArray(payload.results) ? payload.results[0] : null) ?? {};
+    }
+    async commitTaskStopAck(params) {
+        const payload = await this.commitAgentEvents({
+            agentHost: params.agentHost,
+            events: [
+                {
+                    eventType: 'task_stop_ack',
+                    taskId: params.taskId,
+                    requestId: params.requestId,
+                    accepted: params.accepted,
+                },
+            ],
+        });
+        return (Array.isArray(payload.results) ? payload.results[0] : null) ?? {};
+    }
     async matchProjectByPath(params) {
         const response = await this.request('POST', '/projects/match-path', {
             body: JSON.stringify(params),

package/dist/client.d.ts

@@ -1,9 +1,10 @@
 import { BackendApiClient } from './backend/index.js';
 import { ConductorConfig } from './config/index.js';
 import { MessageRouter } from './message/index.js';
+import { DownstreamCursorStore, DurableUpstreamOutboxStore } from './outbox/index.js';
 import { SessionDiskStore, SessionManager } from './session/index.js';
-import { ConductorWebSocketClient } from './ws/index.js';
-type BackendApiLike = Pick<BackendApiClient, 'listProjects' | 'createProject' | 'listTasks' | 'createTask' | 'updateTask' | 'matchProjectByPath' | 'getProject' | 'updateProject'>;
+import { ConductorWebSocketClient, WebSocketConnectedEvent, WebSocketDisconnectEvent } from './ws/index.js';
+type BackendApiLike = Pick<BackendApiClient, 'listProjects' | 'createProject' | 'listTasks' | 'createTask' | 'updateTask' | 'commitSdkMessage' | 'commitTaskStatusUpdate' | 'commitAgentCommandAck' | 'commitTaskStopAck' | 'matchProjectByPath' | 'getProject' | 'updateProject'>;
 type RealtimeClientLike = Pick<ConductorWebSocketClient, 'registerHandler' | 'connect' | 'disconnect' | 'sendJson'>;
 export interface ConductorClientConnectOptions {
     config?: ConductorConfig;
@@ -11,27 +12,31 @@ export interface ConductorClientConnectOptions {
     env?: Record<string, string | undefined>;
     extraEnv?: Record<string, string | undefined>;
     projectPath?: string;
+    deliveryScopeId?: string;
     backendApi?: BackendApiLike;
     wsClient?: RealtimeClientLike;
     sessionManager?: SessionManager;
     sessionStore?: SessionDiskStore;
     messageRouter?: MessageRouter;
+    upstreamOutbox?: DurableUpstreamOutboxStore;
+    downstreamCursorStore?: DownstreamCursorStore;
     agentHost?: string;
-    onConnected?: (event: {
-        isReconnect: boolean;
-    }) => void;
-    onDisconnected?: () => void;
+    onConnected?: (event: WebSocketConnectedEvent) => void;
+    onDisconnected?: (event: WebSocketDisconnectEvent) => void;
     onStopTask?: (event: StopTaskEvent) => Promise<void> | void;
 }
 interface ConductorClientInit {
     config: ConductorConfig;
     env: Record<string, string | undefined>;
     projectPath: string;
+    deliveryScopeId: string;
     backendApi: BackendApiLike;
     wsClient: RealtimeClientLike;
     sessionManager: SessionManager;
     sessionStore: SessionDiskStore;
     messageRouter: MessageRouter;
+    upstreamOutbox: DurableUpstreamOutboxStore;
+    downstreamCursorStore: DownstreamCursorStore;
     agentHost: string;
     onStopTask?: (event: StopTaskEvent) => Promise<void> | void;
 }
@@ -49,11 +54,15 @@ export declare class ConductorClient {
     private readonly sessions;
     private readonly sessionStore;
     private readonly messageRouter;
+    private upstreamOutbox;
+    private downstreamCursorStore;
     private readonly agentHost;
     private readonly onStopTask?;
+    private deliveryScopeId;
     private closed;
-    private pendingOutbound;
-    private readonly ACK_TIMEOUT_MS;
+    private durableOutboxFlushPromise;
+    private durableOutboxTimer;
+    private durableOutboxTimerDueAt;
     constructor(init: ConductorClientInit);
     static connect(options?: ConductorClientConnectOptions): Promise<ConductorClient>;
     close(): Promise<void>;
@@ -65,6 +74,10 @@ export declare class ConductorClient {
         active_tasks?: string[];
         source?: string;
         metadata?: Record<string, any>;
+        last_applied_cursor?: {
+            created_at: string;
+            request_id: string;
+        };
     }): Promise<Record<string, any>>;
     sendAgentCommandAck(payload: {
         request_id: string;
@@ -88,28 +101,22 @@ 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 extractDownstreamCommandContext;
+    private handleStopTaskCommand;
+    private invokeStopTaskHandler;
+    private persistAndCommitUpstreamEvent;
+    private requestDurableOutboxFlush;
+    private hasEarlierPendingSdkMessage;
+    private commitDurableUpstreamEvent;
+    private isRetryableUpstreamError;
+    private computeDurableOutboxRetryDelay;
+    private scheduleDurableOutboxFlush;
+    private clearDurableOutboxTimer;
     private sendEnvelope;
     private maybeAckInboundCommand;
-    private handleStopTaskEvent;
+    private promoteTaskDeliveryScope;
+    private setDeliveryScopeId;
+    private shouldAutoFlushDurableOutbox;
     private resolveHostname;
     private waitForTaskCreation;
     private readIntEnv;