cowork-os 0.3.25 → 0.3.27

package/dist/electron/electron/agent/daemon.js

@@ -182,6 +182,7 @@ class AgentDaemon extends events_1.EventEmitter {
                 error: error.message || 'Failed to initialize task executor',
                 completedAt: Date.now(),
             });
+            this.clearRetryState(task.id);
             this.logEvent(task.id, 'error', { error: error.message });
             // Notify queue manager so it can start next task
             this.queueManager.onTaskFinished(task.id);
@@ -204,6 +205,7 @@ class AgentDaemon extends events_1.EventEmitter {
                 error: error.message,
                 completedAt: Date.now(),
             });
+            this.clearRetryState(task.id);
             this.logEvent(task.id, 'error', { error: error.message });
             this.activeTasks.delete(task.id);
             // Notify queue manager so it can start next task
@@ -383,6 +385,7 @@ class AgentDaemon extends events_1.EventEmitter {
         // Check if task is queued (not yet started)
         if (this.queueManager.cancelQueuedTask(taskId)) {
             this.taskRepo.update(taskId, { status: 'cancelled', completedAt: Date.now() });
+            this.clearRetryState(taskId);
             this.logEvent(taskId, 'task_cancelled', {
                 message: 'Task removed from queue',
             });
@@ -398,6 +401,7 @@ class AgentDaemon extends events_1.EventEmitter {
         // (handles orphaned tasks that are in runningTaskIds but have no executor)
         this.queueManager.onTaskFinished(taskId);
         // Always emit cancelled event so UI updates
+        this.clearRetryState(taskId);
         this.logEvent(taskId, 'task_cancelled', {
             message: 'Task was stopped by user',
         });
@@ -431,10 +435,15 @@ class AgentDaemon extends events_1.EventEmitter {
         const handle = setTimeout(async () => {
             this.pendingRetries.delete(taskId);
             const task = this.taskRepo.findById(taskId);
-            if (!task)
+            if (!task) {
+                this.retryCounts.delete(taskId);
                 return;
-            if (task.status === 'cancelled' || task.status === 'completed')
+            }
+            if (task.status !== 'queued')
+                return;
+            if (this.activeTasks.has(taskId) || this.queueManager.isRunning(taskId) || this.queueManager.isQueued(taskId)) {
                 return;
+            }
             await this.startTask(task);
         }, delayMs);
         this.pendingRetries.set(taskId, handle);
@@ -904,6 +913,9 @@ class AgentDaemon extends events_1.EventEmitter {
      */
     updateTaskStatus(taskId, status) {
         this.taskRepo.update(taskId, { status });
+        if (status === 'completed' || status === 'failed' || status === 'cancelled') {
+            this.clearRetryState(taskId);
+        }
     }
     /**
      * Get task by ID
@@ -948,6 +960,14 @@ class AgentDaemon extends events_1.EventEmitter {
     updateTask(taskId, updates) {
         this.taskRepo.update(taskId, updates);
     }
+    clearRetryState(taskId) {
+        const pending = this.pendingRetries.get(taskId);
+        if (pending) {
+            clearTimeout(pending);
+            this.pendingRetries.delete(taskId);
+        }
+        this.retryCounts.delete(taskId);
+    }
     /**
      * Mark task as completed
      * Note: We keep the executor in memory for follow-up messages (with TTL-based cleanup)
@@ -957,6 +977,7 @@ class AgentDaemon extends events_1.EventEmitter {
             status: 'completed',
             completedAt: Date.now(),
         });
+        this.clearRetryState(taskId);
         // Mark executor as completed for TTL-based cleanup
         const cached = this.activeTasks.get(taskId);
         if (cached) {
@@ -1076,6 +1097,7 @@ class AgentDaemon extends events_1.EventEmitter {
             status: 'failed',
             error: 'Task timed out - exceeded maximum allowed execution time',
         });
+        this.clearRetryState(taskId);
         // Emit timeout event
         this.logEvent(taskId, 'step_timeout', {
             message: 'Task exceeded maximum execution time and was automatically cancelled',

package/dist/electron/electron/agent/executor.js

@@ -949,6 +949,7 @@ class TaskExecutor {
         this.lastNonVerificationOutput = null;
         this.toolResultMemoryLimit = 8;
         this.dispatchedMentionedAgents = false;
+        this.lastAssistantText = null;
         // Plan revision tracking to prevent infinite revision loops
         this.planRevisionCount = 0;
         this.maxPlanRevisions = 5;
@@ -1288,6 +1289,69 @@ class TaskExecutor {
      * This auto-fills parameters when the LLM fails to provide them but context is available
      */
     inferMissingParameters(toolName, input) {
+        if (toolName === 'create_document') {
+            let modified = false;
+            let inference = '';
+            input = input || {};
+            if (!input.filename) {
+                if (input.path) {
+                    input.filename = path.basename(String(input.path));
+                    modified = true;
+                    inference = 'Normalized path -> filename';
+                }
+                else if (input.name) {
+                    input.filename = String(input.name);
+                    modified = true;
+                    inference = 'Normalized name -> filename';
+                }
+            }
+            if (!input.format) {
+                const ext = input.filename ? path.extname(String(input.filename)).toLowerCase() : '';
+                if (ext === '.pdf') {
+                    input.format = 'pdf';
+                    modified = true;
+                    inference = `${inference ? `${inference}; ` : ''}Inferred format="pdf" from filename`;
+                }
+                else if (ext === '.docx') {
+                    input.format = 'docx';
+                    modified = true;
+                    inference = `${inference ? `${inference}; ` : ''}Inferred format="docx" from filename`;
+                }
+                else {
+                    input.format = 'docx';
+                    modified = true;
+                    inference = `${inference ? `${inference}; ` : ''}Defaulted format="docx"`;
+                }
+            }
+            if (!input.content) {
+                const fallback = this.getContentFallback();
+                if (fallback) {
+                    input.content = fallback;
+                    modified = true;
+                    inference = `${inference ? `${inference}; ` : ''}Inferred content from latest assistant output`;
+                }
+            }
+            return { input, modified, inference: modified ? inference : undefined };
+        }
+        if (toolName === 'write_file') {
+            let modified = false;
+            let inference = '';
+            input = input || {};
+            if (!input.path && input.filename) {
+                input.path = String(input.filename);
+                modified = true;
+                inference = 'Normalized filename -> path';
+            }
+            if (!input.content) {
+                const fallback = this.getContentFallback();
+                if (fallback) {
+                    input.content = fallback;
+                    modified = true;
+                    inference = `${inference ? `${inference}; ` : ''}Inferred content from latest assistant output`;
+                }
+            }
+            return { input, modified, inference: modified ? inference : undefined };
+        }
         // Handle edit_document - infer sourcePath from recently created documents
         if (toolName === 'edit_document') {
             let modified = false;
@@ -1388,6 +1452,44 @@ class TaskExecutor {
         }
         return { input, modified: false };
     }
+    getContentFallback() {
+        const candidates = [
+            this.lastAssistantText,
+            this.lastNonVerificationOutput,
+            this.lastAssistantOutput,
+        ];
+        const placeholders = new Set([
+            'I understand. Let me continue.',
+        ]);
+        for (const candidate of candidates) {
+            if (!candidate)
+                continue;
+            const trimmed = candidate.trim();
+            if (trimmed.length < 20)
+                continue;
+            if (placeholders.has(trimmed))
+                continue;
+            return trimmed;
+        }
+        return undefined;
+    }
+    getToolInputValidationError(toolName, input) {
+        if (toolName === 'create_document') {
+            if (!input?.filename)
+                return 'create_document requires a filename';
+            if (!input?.format)
+                return 'create_document requires a format (docx or pdf)';
+            if (!input?.content)
+                return 'create_document requires content';
+        }
+        if (toolName === 'write_file') {
+            if (!input?.path)
+                return 'write_file requires a path';
+            if (!input?.content)
+                return 'write_file requires content';
+        }
+        return null;
+    }
     async handleCanvasPushFallback(content, assistantText) {
         if (content.name !== 'canvas_push') {
             return;
@@ -3241,6 +3343,12 @@ SCHEDULING & REMINDERS:
                     .filter((item) => item.type === 'text' && item.text)
                     .map((item) => item.text)
                     .join('\n');
+                if (assistantText && assistantText.trim().length > 0) {
+                    this.lastAssistantText = assistantText.trim();
+                }
+                if (assistantText && assistantText.trim().length > 0) {
+                    this.lastAssistantText = assistantText.trim();
+                }
                 if (response.content) {
                     for (const content of response.content) {
                         if (content.type === 'text' && content.text) {
@@ -3350,6 +3458,25 @@ SCHEDULING & REMINDERS:
                         }
                         // If canvas_push is missing content, try extracting HTML from assistant text or auto-generate
                         await this.handleCanvasPushFallback(content, assistantText);
+                        const validationError = this.getToolInputValidationError(content.name, content.input);
+                        if (validationError) {
+                            this.daemon.logEvent(this.task.id, 'tool_warning', {
+                                tool: content.name,
+                                error: validationError,
+                                input: content.input,
+                            });
+                            toolResults.push({
+                                type: 'tool_result',
+                                tool_use_id: content.id,
+                                content: JSON.stringify({
+                                    error: validationError,
+                                    suggestion: 'Include all required fields in the tool call (e.g., content for create_document/write_file).',
+                                    invalid_input: true,
+                                }),
+                                is_error: true,
+                            });
+                            continue;
+                        }
                         // Check for duplicate tool calls (prevents stuck loops)
                         const duplicateCheck = this.toolCallDeduplicator.checkDuplicate(content.name, content.input);
                         if (duplicateCheck.isDuplicate) {
@@ -4097,6 +4224,25 @@ SCHEDULING & REMINDERS:
                         }
                         // If canvas_push is missing content, try extracting HTML from assistant text or auto-generate
                         await this.handleCanvasPushFallback(content, assistantText);
+                        const validationError = this.getToolInputValidationError(content.name, content.input);
+                        if (validationError) {
+                            this.daemon.logEvent(this.task.id, 'tool_warning', {
+                                tool: content.name,
+                                error: validationError,
+                                input: content.input,
+                            });
+                            toolResults.push({
+                                type: 'tool_result',
+                                tool_use_id: content.id,
+                                content: JSON.stringify({
+                                    error: validationError,
+                                    suggestion: 'Include all required fields in the tool call (e.g., content for create_document/write_file).',
+                                    invalid_input: true,
+                                }),
+                                is_error: true,
+                            });
+                            continue;
+                        }
                         // Check for duplicate tool calls (prevents stuck loops)
                         const duplicateCheck = this.toolCallDeduplicator.checkDuplicate(content.name, content.input);
                         if (duplicateCheck.isDuplicate) {

package/dist/electron/electron/agent/tools/builtin-settings.js

@@ -113,6 +113,8 @@ const TOOL_CATEGORIES = {
     box_action: 'webfetch',
     onedrive_action: 'webfetch',
     google_drive_action: 'webfetch',
+    gmail_action: 'webfetch',
+    calendar_action: 'webfetch',
     dropbox_action: 'webfetch',
     sharepoint_action: 'webfetch',
     // Browser tools

package/dist/electron/electron/agent/tools/gmail-tools.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GmailTools = void 0;
+const google_workspace_manager_1 = require("../../settings/google-workspace-manager");
+const gmail_api_1 = require("../../utils/gmail-api");
+function encodeMessage(raw) {
+    return Buffer.from(raw)
+        .toString('base64')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=+$/, '');
+}
+function buildRawEmail(input) {
+    const headers = [];
+    if (input.to)
+        headers.push(`To: ${input.to}`);
+    if (input.cc)
+        headers.push(`Cc: ${input.cc}`);
+    if (input.bcc)
+        headers.push(`Bcc: ${input.bcc}`);
+    if (input.subject)
+        headers.push(`Subject: ${input.subject}`);
+    headers.push('MIME-Version: 1.0');
+    headers.push('Content-Type: text/plain; charset="UTF-8"');
+    headers.push('Content-Transfer-Encoding: 7bit');
+    const body = input.body ?? '';
+    const message = `${headers.join('\r\n')}\r\n\r\n${body}`;
+    return encodeMessage(message);
+}
+class GmailTools {
+    constructor(workspace, daemon, taskId) {
+        this.workspace = workspace;
+        this.daemon = daemon;
+        this.taskId = taskId;
+    }
+    setWorkspace(workspace) {
+        this.workspace = workspace;
+    }
+    static isEnabled() {
+        return google_workspace_manager_1.GoogleWorkspaceSettingsManager.loadSettings().enabled;
+    }
+    formatAuthError(error) {
+        const message = String(error?.message ?? '');
+        const status = error?.status;
+        if (status === 401) {
+            return 'Google Workspace authorization failed (401). Reconnect in Settings > Integrations > Google Workspace.';
+        }
+        if (/token refresh failed|refresh token not configured|access token not configured|access token expired/i.test(message)) {
+            return `Google Workspace authorization error: ${message}`;
+        }
+        return null;
+    }
+    async requireApproval(summary, details) {
+        const approved = await this.daemon.requestApproval(this.taskId, 'external_service', summary, details);
+        if (!approved) {
+            throw new Error('User denied Gmail action');
+        }
+    }
+    async executeAction(input) {
+        const settings = google_workspace_manager_1.GoogleWorkspaceSettingsManager.loadSettings();
+        if (!settings.enabled) {
+            throw new Error('Google Workspace integration is disabled. Enable it in Settings > Integrations > Google Workspace.');
+        }
+        const action = input.action;
+        if (!action) {
+            throw new Error('Missing required "action" parameter');
+        }
+        let result;
+        try {
+            switch (action) {
+                case 'get_profile': {
+                    result = await (0, gmail_api_1.gmailRequest)(settings, {
+                        method: 'GET',
+                        path: '/users/me/profile',
+                    });
+                    break;
+                }
+                case 'list_messages': {
+                    result = await (0, gmail_api_1.gmailRequest)(settings, {
+                        method: 'GET',
+                        path: '/users/me/messages',
+                        query: {
+                            q: input.query,
+                            maxResults: input.page_size,
+                            pageToken: input.page_token,
+                            includeSpamTrash: input.include_spam_trash,
+                            labelIds: input.label_ids,
+                        },
+                    });
+                    break;
+                }
+                case 'get_message': {
+                    if (!input.message_id)
+                        throw new Error('Missing message_id for get_message');
+                    result = await (0, gmail_api_1.gmailRequest)(settings, {
+                        method: 'GET',
+                        path: `/users/me/messages/${input.message_id}`,
+                        query: {
+                            format: input.format,
+                            metadataHeaders: input.metadata_headers ? input.metadata_headers.join(',') : undefined,
+                        },
+                    });
+                    break;
+                }
+                case 'get_thread': {
+                    if (!input.thread_id)
+                        throw new Error('Missing thread_id for get_thread');
+                    result = await (0, gmail_api_1.gmailRequest)(settings, {
+                        method: 'GET',
+                        path: `/users/me/threads/${input.thread_id}`,
+                        query: {
+                            format: input.format,
+                            metadataHeaders: input.metadata_headers ? input.metadata_headers.join(',') : undefined,
+                        },
+                    });
+                    break;
+                }
+                case 'list_labels': {
+                    result = await (0, gmail_api_1.gmailRequest)(settings, {
+                        method: 'GET',
+                        path: '/users/me/labels',
+                    });
+                    break;
+                }
+                case 'send_message': {
+                    if (!input.raw && !input.to) {
+                        throw new Error('Missing to for send_message');
+                    }
+                    if (!input.raw && !input.body && !input.subject) {
+                        throw new Error('Missing body or subject for send_message');
+                    }
+                    await this.requireApproval('Send a Gmail message', {
+                        action: 'send_message',
+                        to: input.to,
+                        subject: input.subject,
+                    });
+                    const raw = input.raw || buildRawEmail(input);
+                    const payload = { raw };
+                    if (input.thread_id) {
+                        payload.threadId = input.thread_id;
+                    }
+                    result = await (0, gmail_api_1.gmailRequest)(settings, {
+                        method: 'POST',
+                        path: '/users/me/messages/send',
+                        body: payload,
+                    });
+                    break;
+                }
+                case 'trash_message': {
+                    if (!input.message_id)
+                        throw new Error('Missing message_id for trash_message');
+                    await this.requireApproval('Trash a Gmail message', {
+                        action: 'trash_message',
+                        message_id: input.message_id,
+                    });
+                    result = await (0, gmail_api_1.gmailRequest)(settings, {
+                        method: 'POST',
+                        path: `/users/me/messages/${input.message_id}/trash`,
+                    });
+                    break;
+                }
+                default:
+                    throw new Error(`Unsupported action: ${action}`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const authMessage = this.formatAuthError(error);
+            const finalMessage = authMessage ?? message;
+            this.daemon.logEvent(this.taskId, 'tool_error', {
+                tool: 'gmail_action',
+                action,
+                message: finalMessage,
+                status: error?.status,
+            });
+            if (authMessage) {
+                throw new Error(authMessage);
+            }
+            if (error instanceof Error) {
+                throw error;
+            }
+            throw new Error(message);
+        }
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'gmail_action',
+            action,
+            status: result?.status,
+            hasData: result?.data ? true : false,
+        });
+        return {
+            success: true,
+            action,
+            status: result?.status,
+            data: result?.data,
+            raw: result?.raw,
+        };
+    }
+}
+exports.GmailTools = GmailTools;