@robosystems/core 0.11.2 → 0.11.3

package/task-monitoring/taskMonitor.js

@@ -1,4 +1,19 @@
 import * as SDK from '@robosystems/client';
+import { isTransientError, unwrapSdk } from '../lib/sdk-errors';
+/** Consecutive transient status-read failures tolerated before giving up. */
+const DEFAULT_MAX_CONSECUTIVE_ERRORS = 5;
+/** Upper bound on the backoff between status reads after a failure. */
+const MAX_ERROR_BACKOFF_MS = 30 * 1000;
+/** Statuses of an operation that has not finished (API `OperationStatus`). */
+const NON_TERMINAL_STATUSES = new Set([
+    'pending',
+    'running',
+    'awaiting_input',
+    'in_progress',
+    'retrying',
+]);
+/** Rejection message when watching stopped locally (`stopPolling`). */
+export const POLLING_CANCELLED = 'Task polling was cancelled';
 export class TaskMonitor {
     constructor() {
         this.activeTasks = new Map();
@@ -10,110 +25,139 @@ export class TaskMonitor {
         return TaskMonitor.instance;
     }
     async pollTask({ taskId, onProgress, onComplete, onError, pollInterval = 2000, maxAttempts = 150, // 5 minutes at 2s intervals
-     }) {
+    maxConsecutiveErrors = DEFAULT_MAX_CONSECUTIVE_ERRORS, }) {
         let attempts = 0;
+        let consecutiveErrors = 0;
         const abortController = new AbortController();
+        // One poller per task: a second pollTask for the same id replaces (and
+        // stops) the first, which could otherwise never be stopped.
+        this.stopPolling(taskId);
         this.activeTasks.set(taskId, abortController);
         return new Promise((resolve, reject) => {
+            let settled = false;
+            let timer = null;
+            const finish = (outcome) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                if (this.activeTasks.get(taskId) === abortController) {
+                    this.activeTasks.delete(taskId);
+                }
+                outcome();
+            };
+            const fail = (error, notify = true) => finish(() => {
+                if (notify)
+                    onError === null || onError === void 0 ? void 0 : onError(error.message);
+                reject(error);
+            });
+            // Stopping (unmount, explicit cancel) settles the promise at once, even
+            // while a status request is in flight — its answer is then ignored.
+            abortController.signal.addEventListener('abort', () => fail(new Error(POLLING_CANCELLED), false));
+            const schedule = (delay) => {
+                if (settled)
+                    return;
+                timer = setTimeout(poll, delay);
+            };
             const poll = async () => {
+                if (settled)
+                    return;
+                attempts++;
+                let status;
                 try {
-                    if (abortController.signal.aborted) {
-                        this.activeTasks.delete(taskId);
-                        reject(new Error('Task polling was cancelled'));
-                        return;
-                    }
-                    attempts++;
                     const response = await SDK.getOperationStatus({
                         path: { operation_id: taskId },
                     });
-                    if (!response.data) {
+                    if (settled)
+                        return;
+                    const data = unwrapSdk(response);
+                    if (!data) {
                         throw new Error('No data received from task status endpoint');
                     }
-                    const status = response.data;
-                    switch (status.status) {
-                        case 'pending':
-                        case 'in_progress':
-                        case 'retrying':
-                            onProgress === null || onProgress === void 0 ? void 0 : onProgress(status);
-                            if (attempts < maxAttempts && !abortController.signal.aborted) {
-                                setTimeout(poll, pollInterval);
-                            }
-                            else if (attempts >= maxAttempts) {
-                                this.activeTasks.delete(taskId);
-                                const timeoutError = new Error(`Task polling timeout after ${attempts} attempts`);
-                                onError === null || onError === void 0 ? void 0 : onError(timeoutError.message);
-                                reject(timeoutError);
-                            }
-                            break;
-                        case 'completed':
-                            this.activeTasks.delete(taskId);
-                            onComplete === null || onComplete === void 0 ? void 0 : onComplete(status.details || status);
-                            resolve(status);
-                            break;
-                        case 'failed': {
-                            this.activeTasks.delete(taskId);
-                            const failureError = new Error(status.message || 'Task failed without error message');
-                            onError === null || onError === void 0 ? void 0 : onError(failureError.message);
-                            reject(failureError);
-                            break;
-                        }
-                        case 'cancelled': {
-                            this.activeTasks.delete(taskId);
-                            const cancelError = new Error('Task was cancelled');
-                            onError === null || onError === void 0 ? void 0 : onError(cancelError.message);
-                            reject(cancelError);
-                            break;
-                        }
-                        default:
-                            // Handle unknown status as in_progress
-                            onProgress === null || onProgress === void 0 ? void 0 : onProgress(status);
-                            if (attempts < maxAttempts && !abortController.signal.aborted) {
-                                setTimeout(poll, pollInterval);
-                            }
-                            else if (attempts >= maxAttempts) {
-                                this.activeTasks.delete(taskId);
-                                const unknownError = new Error(`Unknown task status: ${status.status}`);
-                                onError === null || onError === void 0 ? void 0 : onError(unknownError.message);
-                                reject(unknownError);
-                            }
-                    }
+                    status = data;
+                    consecutiveErrors = 0;
                 }
                 catch (error) {
-                    this.activeTasks.delete(taskId);
-                    const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+                    if (settled)
+                        return;
+                    // A blip (network, 429, 5xx) says nothing about the task: keep
+                    // polling with backoff, and only give up after several in a row.
+                    if (isTransientError(error) &&
+                        ++consecutiveErrors < maxConsecutiveErrors) {
+                        console.warn('Task status read failed, retrying:', error);
+                        schedule(Math.min(pollInterval * 2 ** consecutiveErrors, MAX_ERROR_BACKOFF_MS));
+                        return;
+                    }
                     console.error('Task polling error:', error);
-                    onError === null || onError === void 0 ? void 0 : onError(errorMessage);
-                    reject(error);
+                    fail(error instanceof Error ? error : new Error('Unknown error occurred'));
+                    return;
+                }
+                switch (status.status) {
+                    case 'completed':
+                        finish(() => {
+                            onComplete === null || onComplete === void 0 ? void 0 : onComplete(status.details || status);
+                            resolve(status);
+                        });
+                        return;
+                    case 'failed':
+                        fail(new Error(status.message || 'Task failed without error message'));
+                        return;
+                    case 'cancelled':
+                        fail(new Error('Task was cancelled'));
+                        return;
+                    default:
+                        // Non-terminal: the API's pending / running / awaiting_input,
+                        // older in_progress / retrying, and any status added later.
+                        onProgress === null || onProgress === void 0 ? void 0 : onProgress(status);
+                        if (attempts >= maxAttempts) {
+                            fail(new Error(NON_TERMINAL_STATUSES.has(status.status)
+                                ? `Task is still ${status.status.replace(/_/g, ' ')} after ${attempts} checks. ` +
+                                    'It continues on the server; check back later.'
+                                : `Unknown task status: ${status.status}`));
+                            return;
+                        }
+                        schedule(pollInterval);
                 }
             };
             // Start polling
             poll();
         });
     }
+    /**
+     * Stop watching a task locally. The operation itself keeps running on the
+     * server — this is what leaving a page should do.
+     */
+    stopPolling(taskId) {
+        const abortController = this.activeTasks.get(taskId);
+        if (!abortController)
+            return false;
+        this.activeTasks.delete(taskId);
+        abortController.abort();
+        return true;
+    }
+    /**
+     * Cancel the operation on the server, then stop watching it. Only for an
+     * explicit user action. Returns false when the server refused — the task
+     * is then still being watched, and its real outcome still arrives.
+     */
     async cancelTask(taskId) {
         try {
-            // Cancel local polling
-            const abortController = this.activeTasks.get(taskId);
-            if (abortController) {
-                abortController.abort();
-                this.activeTasks.delete(taskId);
-            }
-            // Cancel task on server
-            await SDK.cancelOperation({
+            unwrapSdk(await SDK.cancelOperation({
                 path: { operation_id: taskId },
-            });
-            return true;
+            }));
         }
         catch (error) {
             console.error('Failed to cancel task:', error);
             return false;
         }
+        this.stopPolling(taskId);
+        return true;
     }
     cancelAllTasks() {
-        for (const [, abortController] of this.activeTasks.entries()) {
-            abortController.abort();
+        for (const taskId of Array.from(this.activeTasks.keys())) {
+            this.stopPolling(taskId);
         }
-        this.activeTasks.clear();
     }
     getActiveTasks() {
         return Array.from(this.activeTasks.keys());
@@ -127,6 +171,9 @@ export const pollTaskStatus = (options) => {
 export const cancelTask = (taskId) => {
     return taskMonitor.cancelTask(taskId);
 };
+export const stopPollingTask = (taskId) => {
+    return taskMonitor.stopPolling(taskId);
+};
 export const getActiveTasks = () => {
     return taskMonitor.getActiveTasks();
 };

package/task-monitoring/types.d.ts

@@ -7,7 +7,7 @@ export interface TaskStatusResponse {
     result?: any;
     error?: string;
 }
-export type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled' | 'retrying';
+export type TaskStatus = 'pending' | 'running' | 'awaiting_input' | 'in_progress' | 'retrying' | 'completed' | 'failed' | 'cancelled';
 export interface TaskPollingOptions {
     taskId: string;
     onProgress?: (status: TaskStatusResponse) => void;
@@ -15,6 +15,7 @@ export interface TaskPollingOptions {
     onError?: (error: string) => void;
     pollInterval?: number;
     maxAttempts?: number;
+    maxConsecutiveErrors?: number;
 }
 export interface TaskMonitorState {
     isLoading: boolean;