cowork-os 0.3.21 → 0.3.25

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

@@ -40,6 +40,9 @@ const fs = __importStar(require("fs"));
 const crypto = __importStar(require("crypto"));
 const repositories_1 = require("../database/repositories");
 const ActivityRepository_1 = require("../activity/ActivityRepository");
+const AgentRoleRepository_1 = require("../agents/AgentRoleRepository");
+const MentionRepository_1 = require("../agents/MentionRepository");
+const agent_dispatch_1 = require("../agents/agent-dispatch");
 const types_1 = require("../../shared/types");
 const executor_1 = require("./executor");
 const queue_manager_1 = require("./queue-manager");
@@ -48,6 +51,9 @@ const MemoryService_1 = require("../memory/MemoryService");
 // Memory management constants
 const MAX_CACHED_EXECUTORS = 10; // Maximum number of completed task executors to keep in memory
 const EXECUTOR_CACHE_TTL_MS = 30 * 60 * 1000; // 30 minutes - time before completed executors are cleaned up
+// Activity throttling constants
+const ACTIVITY_THROTTLE_WINDOW_MS = 2000; // 2 seconds - window for deduping similar activities
+const THROTTLED_ACTIVITY_TYPES = new Set(['tool_call', 'file_created', 'file_modified', 'file_deleted']);
 /**
  * AgentDaemon is the core orchestrator that manages task execution
  * It coordinates between the database, task executors, and UI
@@ -58,6 +64,12 @@ class AgentDaemon extends events_1.EventEmitter {
         this.dbManager = dbManager;
         this.activeTasks = new Map();
         this.pendingApprovals = new Map();
+        // Activity throttle: Map<taskId:eventType, lastTimestamp>
+        this.activityThrottle = new Map();
+        this.pendingRetries = new Map();
+        this.retryCounts = new Map();
+        this.maxTaskRetries = 2;
+        this.retryDelayMs = 30 * 1000;
         const db = dbManager.getDatabase();
         this.taskRepo = new repositories_1.TaskRepository(db);
         this.eventRepo = new repositories_1.TaskEventRepository(db);
@@ -65,6 +77,8 @@ class AgentDaemon extends events_1.EventEmitter {
         this.approvalRepo = new repositories_1.ApprovalRepository(db);
         this.artifactRepo = new repositories_1.ArtifactRepository(db);
         this.activityRepo = new ActivityRepository_1.ActivityRepository(db);
+        this.agentRoleRepo = new AgentRoleRepository_1.AgentRoleRepository(db);
+        this.mentionRepo = new MentionRepository_1.MentionRepository(db);
         // Initialize queue manager with callbacks
         this.queueManager = new queue_manager_1.TaskQueueManager({
             startTaskImmediate: (task) => this.startTaskImmediate(task),
@@ -245,6 +259,123 @@ class AgentDaemon extends events_1.EventEmitter {
         await this.startTask(task);
         return task;
     }
+    buildPlanSummary(plan) {
+        if (!plan)
+            return undefined;
+        const lines = [];
+        if (plan.description) {
+            lines.push(`Plan: ${plan.description}`);
+        }
+        if (plan.steps && plan.steps.length > 0) {
+            lines.push('Steps:');
+            const stepLines = plan.steps
+                .slice(0, 7)
+                .map((step) => `- ${step.description}`);
+            lines.push(...stepLines);
+            if (plan.steps.length > 7) {
+                lines.push(`- …and ${plan.steps.length - 7} more steps`);
+            }
+        }
+        return lines.length > 0 ? lines.join('\n') : undefined;
+    }
+    emitActivityEvent(activity) {
+        const windows = electron_1.BrowserWindow.getAllWindows();
+        windows.forEach(window => {
+            try {
+                if (!window.isDestroyed() && window.webContents && !window.webContents.isDestroyed()) {
+                    window.webContents.send(types_1.IPC_CHANNELS.ACTIVITY_EVENT, { type: 'created', activity });
+                }
+            }
+            catch (error) {
+                console.error('[AgentDaemon] Error sending activity IPC:', error);
+            }
+        });
+    }
+    emitMentionEvent(mention) {
+        const windows = electron_1.BrowserWindow.getAllWindows();
+        windows.forEach(window => {
+            try {
+                if (!window.isDestroyed() && window.webContents && !window.webContents.isDestroyed()) {
+                    window.webContents.send(types_1.IPC_CHANNELS.MENTION_EVENT, { type: 'created', mention });
+                }
+            }
+            catch (error) {
+                console.error('[AgentDaemon] Error sending mention IPC:', error);
+            }
+        });
+    }
+    /**
+     * Dispatch mentioned agent roles after the main plan is created.
+     * This avoids starting sub-agents before the task is clearly defined.
+     */
+    async dispatchMentionedAgents(taskId, plan) {
+        const task = this.taskRepo.findById(taskId);
+        if (!task || task.parentTaskId)
+            return;
+        const mentionedRoleIds = (task.mentionedAgentRoleIds || []).filter(Boolean);
+        if (mentionedRoleIds.length === 0)
+            return;
+        const activeRoles = this.agentRoleRepo.findAll(false).filter(role => role.isActive);
+        const mentionedRoles = activeRoles.filter(role => mentionedRoleIds.includes(role.id));
+        if (mentionedRoles.length === 0)
+            return;
+        const existingChildren = this.taskRepo.findByParent(taskId);
+        const assignedRoleIds = new Set(existingChildren
+            .map(child => child.assignedAgentRoleId)
+            .filter((id) => typeof id === 'string' && id.length > 0));
+        const rolesToDispatch = mentionedRoles.filter(role => !assignedRoleIds.has(role.id));
+        if (rolesToDispatch.length === 0)
+            return;
+        const planSummary = this.buildPlanSummary(plan);
+        for (const role of rolesToDispatch) {
+            const childPrompt = (0, agent_dispatch_1.buildAgentDispatchPrompt)(role, { title: task.title, prompt: task.prompt }, planSummary ? { planSummary } : undefined);
+            const childTask = await this.createChildTask({
+                title: `@${role.displayName}: ${task.title}`,
+                prompt: childPrompt,
+                workspaceId: task.workspaceId,
+                parentTaskId: task.id,
+                agentType: 'sub',
+                agentConfig: {
+                    ...(role.modelKey ? { modelKey: role.modelKey } : {}),
+                    ...(role.personalityId ? { personalityId: role.personalityId } : {}),
+                    retainMemory: false,
+                },
+            });
+            this.taskRepo.update(childTask.id, {
+                assignedAgentRoleId: role.id,
+                boardColumn: 'todo',
+            });
+            const dispatchActivity = this.activityRepo.create({
+                workspaceId: task.workspaceId,
+                taskId: task.id,
+                agentRoleId: role.id,
+                actorType: 'system',
+                activityType: 'agent_assigned',
+                title: `Dispatched to ${role.displayName}`,
+                description: childTask.title,
+            });
+            this.emitActivityEvent(dispatchActivity);
+            const mention = this.mentionRepo.create({
+                workspaceId: task.workspaceId,
+                taskId: task.id,
+                toAgentRoleId: role.id,
+                mentionType: 'request',
+                context: `New task: ${task.title}`,
+            });
+            this.emitMentionEvent(mention);
+            const mentionActivity = this.activityRepo.create({
+                workspaceId: task.workspaceId,
+                taskId: task.id,
+                agentRoleId: role.id,
+                actorType: 'user',
+                activityType: 'mention',
+                title: `@${role.displayName} mentioned`,
+                description: mention.context,
+                metadata: { mentionId: mention.id, mentionType: mention.mentionType },
+            });
+            this.emitActivityEvent(mentionActivity);
+        }
+    }
     /**
      * Cancel a running or queued task
      */
@@ -271,6 +402,44 @@ class AgentDaemon extends events_1.EventEmitter {
             message: 'Task was stopped by user',
         });
     }
+    /**
+     * Handle transient provider errors by scheduling a retry instead of failing.
+     * Returns true if a retry was scheduled, false if retries are exhausted.
+     */
+    handleTransientTaskFailure(taskId, reason, delayMs = this.retryDelayMs) {
+        const currentCount = this.retryCounts.get(taskId) ?? 0;
+        const nextCount = currentCount + 1;
+        if (nextCount > this.maxTaskRetries) {
+            return false;
+        }
+        this.retryCounts.set(taskId, nextCount);
+        if (this.pendingRetries.has(taskId)) {
+            return true;
+        }
+        // Mark as queued with a helpful message
+        this.taskRepo.update(taskId, {
+            status: 'queued',
+            error: `Transient provider error. Retry ${nextCount}/${this.maxTaskRetries} in ${Math.ceil(delayMs / 1000)}s.`,
+        });
+        this.logEvent(taskId, 'log', {
+            message: `Transient provider error detected. Scheduling retry ${nextCount}/${this.maxTaskRetries} in ${Math.ceil(delayMs / 1000)}s.`,
+            reason,
+        });
+        // Clear executor and free queue slot
+        this.activeTasks.delete(taskId);
+        this.queueManager.onTaskFinished(taskId);
+        const handle = setTimeout(async () => {
+            this.pendingRetries.delete(taskId);
+            const task = this.taskRepo.findById(taskId);
+            if (!task)
+                return;
+            if (task.status === 'cancelled' || task.status === 'completed')
+                return;
+            await this.startTask(task);
+        }, delayMs);
+        this.pendingRetries.set(taskId, handle);
+        return true;
+    }
     /**
      * Pause a running task
      */
@@ -485,6 +654,26 @@ class AgentDaemon extends events_1.EventEmitter {
         const task = this.taskRepo.findById(taskId);
         if (!task)
             return;
+        // Throttle high-frequency activity types to reduce database writes
+        if (THROTTLED_ACTIVITY_TYPES.has(type)) {
+            const throttleKey = `${taskId}:${type}`;
+            const now = Date.now();
+            const lastTime = this.activityThrottle.get(throttleKey);
+            if (lastTime && (now - lastTime) < ACTIVITY_THROTTLE_WINDOW_MS) {
+                // Skip this activity - too soon after the last one of the same type
+                return;
+            }
+            this.activityThrottle.set(throttleKey, now);
+            // Clean up old throttle entries periodically (keep map from growing unbounded)
+            if (this.activityThrottle.size > 1000) {
+                const cutoff = now - ACTIVITY_THROTTLE_WINDOW_MS * 10;
+                for (const [key, time] of this.activityThrottle) {
+                    if (time < cutoff) {
+                        this.activityThrottle.delete(key);
+                    }
+                }
+            }
+        }
         const activity = this.buildActivityFromEvent(task, type, payload);
         if (!activity)
             return;
@@ -652,19 +841,6 @@ class AgentDaemon extends events_1.EventEmitter {
                 return undefined;
         }
     }
-    emitActivityEvent(activity) {
-        const windows = electron_1.BrowserWindow.getAllWindows();
-        windows.forEach(window => {
-            try {
-                if (!window.isDestroyed() && window.webContents && !window.webContents.isDestroyed()) {
-                    window.webContents.send(types_1.IPC_CHANNELS.ACTIVITY_EVENT, { type: 'created', activity });
-                }
-            }
-            catch (error) {
-                console.error('[AgentDaemon] Error sending activity IPC:', error);
-            }
-        });
-    }
     /**
      * Register an artifact (file created during task execution)
      * This allows files like screenshots to be sent back to the user