fix: restore try/catch in updateProgress, add actor tool task statusMessage test

Author: MQ37

src/utils/progress.ts

@@ -28,29 +28,37 @@ export class ProgressTracker {
 
         // Send progress notification only if progressToken and sendNotification are available
         if (this.progressToken && this.sendNotification) {
-            const notification: ProgressNotification = {
-                method: 'notifications/progress' as const,
-                params: {
-                    progressToken: this.progressToken,
-                    progress: this.currentProgress,
-                    ...(message && { message }),
-                },
-                // Per MCP spec: progress notifications during task execution should include related-task metadata
-                ...(this.taskId && {
-                    _meta: {
-                        'io.modelcontextprotocol/related-task': {
-                            taskId: this.taskId,
-                        },
+            try {
+                const notification: ProgressNotification = {
+                    method: 'notifications/progress' as const,
+                    params: {
+                        progressToken: this.progressToken,
+                        progress: this.currentProgress,
+                        ...(message && { message }),
                     },
-                }),
-            };
+                    // Per MCP spec: progress notifications during task execution should include related-task metadata
+                    ...(this.taskId && {
+                        _meta: {
+                            'io.modelcontextprotocol/related-task': {
+                                taskId: this.taskId,
+                            },
+                        },
+                    }),
+                };
 
-            await this.sendNotification(notification);
+                await this.sendNotification(notification);
+            } catch {
+                // Silent fail - don't break execution
+            }
         }
 
         // Update task statusMessage if callback is provided
         if (this.onStatusMessage && message) {
-            await this.onStatusMessage(message);
+            try {
+                await this.onStatusMessage(message);
+            } catch {
+                // Silent fail - don't break execution
+            }
         }
     }
 

tests/integration/suite.ts

@@ -2411,7 +2411,7 @@ export function createIntegrationTestsSuite(
             expect(resultReceived).toBe(true);
         });
 
-        it.only('should propagate statusMessage to tasks/get and tasks/list for internal tools in task mode', async () => {
+        it('should propagate statusMessage to tasks/get and tasks/list for internal tools in task mode', async () => {
             client = await createClientFn({ tools: ['actors'] });
 
             const stream = client.experimental.tasks.callToolStream(
@@ -2467,6 +2467,52 @@ export function createIntegrationTestsSuite(
             expect(listTasksSawStatusMessage).toBe(true);
         });
 
+        it('should propagate statusMessage to tasks/get and tasks/list for actor tools in task mode', async () => {
+            client = await createClientFn({ tools: [RAG_WEB_BROWSER] });
+
+            const stream = client.experimental.tasks.callToolStream(
+                {
+                    name: actorNameToToolName(RAG_WEB_BROWSER),
+                    arguments: {
+                        query: 'https://apify.com',
+                    },
+                },
+                CallToolResultSchema,
+                {
+                    task: {
+                        ttl: 60000,
+                    },
+                },
+            );
+
+            let taskId: string | null = null;
+            let getTaskSawStatusMessage = false;
+            let listTasksSawStatusMessage = false;
+            for await (const message of stream) {
+                if (message.type === 'taskCreated') {
+                    taskId = message.task.taskId;
+                } else if (message.type === 'taskStatus') {
+                    if (message.task.statusMessage) {
+                        getTaskSawStatusMessage = true;
+
+                        if (!listTasksSawStatusMessage && taskId) {
+                            const currentTaskId = taskId;
+                            const tasksList = await client.experimental.tasks.listTasks();
+                            const ourTask = tasksList.tasks.find((t) => t.taskId === currentTaskId);
+                            if (ourTask?.statusMessage) {
+                                listTasksSawStatusMessage = true;
+                            }
+                        }
+                    }
+                } else if (message.type === 'error') {
+                    throw message.error;
+                }
+            }
+
+            expect(getTaskSawStatusMessage).toBe(true);
+            expect(listTasksSawStatusMessage).toBe(true);
+        });
+
         it.runIf(options.transport === 'stdio')('should use UI_MODE env var when CLI arg is not provided', async () => {
             client = await createClientFn({ useEnv: true, uiMode: 'openai' });
             const tools = await client.listTools();

tests/unit/utils.progress.test.ts

@@ -48,12 +48,12 @@ describe('ProgressTracker', () => {
         });
     });
 
-    it('should propagate notification send errors to the caller', async () => {
+    it('should handle notification send errors gracefully', async () => {
         const mockSendNotification = vi.fn().mockRejectedValue(new Error('Network error'));
         const tracker = new ProgressTracker({ progressToken: 'test-token', sendNotification: mockSendNotification });
 
-        // Errors propagate so the caller (startActorRunUpdates interval) can catch them
-        await expect(tracker.updateProgress('Test')).rejects.toThrow('Network error');
+        // Should not throw
+        await expect(tracker.updateProgress('Test')).resolves.toBeUndefined();
         expect(mockSendNotification).toHaveBeenCalled();
     });
 });