cowork-os 0.3.21 → 0.3.25

package/dist/electron/electron/ipc/handlers.js

@@ -44,6 +44,7 @@ const path = __importStar(require("path"));
 const fs = __importStar(require("fs/promises"));
 const fsSync = __importStar(require("fs"));
 const mammoth_1 = __importDefault(require("mammoth"));
+const mime_types_1 = __importDefault(require("mime-types"));
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const pdfParseModule = require('pdf-parse');
 // Handle both ESM default export and CommonJS module.exports
@@ -57,6 +58,7 @@ const TaskLabelRepository_1 = require("../database/TaskLabelRepository");
 const WorkingStateRepository_1 = require("../agents/WorkingStateRepository");
 const context_policy_1 = require("../gateway/context-policy");
 const types_1 = require("../../shared/types");
+const llm_provider_catalog_1 = require("../../shared/llm-provider-catalog");
 const os = __importStar(require("os"));
 const llm_1 = require("../agent/llm");
 const search_1 = require("../agent/search");
@@ -66,6 +68,19 @@ const validation_1 = require("../utils/validation");
 const guardrail_manager_1 = require("../guardrails/guardrail-manager");
 const appearance_manager_1 = require("../settings/appearance-manager");
 const personality_manager_1 = require("../settings/personality-manager");
+const notion_manager_1 = require("../settings/notion-manager");
+const notion_api_1 = require("../utils/notion-api");
+const box_manager_1 = require("../settings/box-manager");
+const onedrive_manager_1 = require("../settings/onedrive-manager");
+const google_drive_manager_1 = require("../settings/google-drive-manager");
+const dropbox_manager_1 = require("../settings/dropbox-manager");
+const sharepoint_manager_1 = require("../settings/sharepoint-manager");
+const box_api_1 = require("../utils/box-api");
+const onedrive_api_1 = require("../utils/onedrive-api");
+const google_drive_api_1 = require("../utils/google-drive-api");
+const dropbox_api_1 = require("../utils/dropbox-api");
+const sharepoint_api_1 = require("../utils/sharepoint-api");
+const connector_oauth_1 = require("../mcp/oauth/connector-oauth");
 const normalizeMentionToken = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, '');
 const buildAgentMentionIndex = (roles) => {
     const index = new Map();
@@ -124,7 +139,8 @@ const scoreAgentForTask = (role, text) => {
     }
     return score;
 };
-const selectBestAgentsForTask = (text, roles) => {
+const MAX_AUTO_AGENTS = 4;
+const selectBestAgentsForTask = (text, roles, maxAgents = MAX_AUTO_AGENTS) => {
     if (roles.length === 0)
         return roles;
     const scored = roles
@@ -140,24 +156,23 @@ const selectBestAgentsForTask = (text, roles) => {
         const threshold = Math.max(1, maxScore - 2);
         const selected = withScore
             .filter((entry) => entry.score >= threshold)
-            .slice(0, 4)
+            .slice(0, maxAgents)
             .map((entry) => entry.role);
-        return selected.length > 0 ? selected : withScore.slice(0, 3).map((entry) => entry.role);
+        return selected.length > 0 ? selected : withScore.slice(0, maxAgents).map((entry) => entry.role);
     }
     const leads = roles
         .filter((role) => role.autonomyLevel === 'lead')
         .sort((a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0));
     if (leads.length > 0) {
-        return leads.slice(0, 3);
+        return leads.slice(0, maxAgents);
     }
-    return roles.slice(0, Math.min(3, roles.length));
+    return roles.slice(0, Math.min(maxAgents, roles.length));
 };
 const extractMentionedRoles = (text, roles) => {
     const normalizedText = text.toLowerCase();
-    const useSmartSelection = /\B@everybody\b/.test(normalizedText);
-    if (/\B@all\b/.test(normalizedText) || /\B@everyone\b/.test(normalizedText)) {
-        return roles;
-    }
+    const useSmartSelection = /\B@everybody\b/.test(normalizedText) ||
+        /\B@all\b/.test(normalizedText) ||
+        /\B@everyone\b/.test(normalizedText);
     const index = buildAgentMentionIndex(roles);
     const matches = new Map();
     const regex = /@([a-zA-Z0-9][a-zA-Z0-9 _-]{0,50})/g;
@@ -172,11 +187,15 @@ const extractMentionedRoles = (text, roles) => {
     }
     if (matches.size > 0) {
         if (useSmartSelection) {
-            const selected = selectBestAgentsForTask(text, roles);
             const merged = new Map();
-            selected.forEach((role) => merged.set(role.id, role));
             matches.forEach((role) => merged.set(role.id, role));
-            return Array.from(merged.values());
+            const selected = selectBestAgentsForTask(text, roles, MAX_AUTO_AGENTS);
+            selected.forEach((role) => {
+                if (merged.size < MAX_AUTO_AGENTS) {
+                    merged.set(role.id, role);
+                }
+            });
+            return Array.from(merged.values()).slice(0, MAX_AUTO_AGENTS);
         }
         return Array.from(matches.values());
     }
@@ -189,64 +208,10 @@ const extractMentionedRoles = (text, roles) => {
         }
     });
     if (useSmartSelection) {
-        return selectBestAgentsForTask(text, roles);
+        return selectBestAgentsForTask(text, roles, MAX_AUTO_AGENTS);
     }
     return Array.from(matches.values());
 };
-const buildSoulSummary = (soul) => {
-    if (!soul)
-        return null;
-    try {
-        const parsed = JSON.parse(soul);
-        const parts = [];
-        if (typeof parsed.name === 'string')
-            parts.push(`Name: ${parsed.name}`);
-        if (typeof parsed.role === 'string')
-            parts.push(`Role: ${parsed.role}`);
-        if (typeof parsed.personality === 'string')
-            parts.push(`Personality: ${parsed.personality}`);
-        if (typeof parsed.communicationStyle === 'string')
-            parts.push(`Style: ${parsed.communicationStyle}`);
-        if (Array.isArray(parsed.focusAreas))
-            parts.push(`Focus: ${parsed.focusAreas.join(', ')}`);
-        if (Array.isArray(parsed.strengths))
-            parts.push(`Strengths: ${parsed.strengths.join(', ')}`);
-        if (parts.length === 0) {
-            return null;
-        }
-        return parts.join('\n');
-    }
-    catch {
-        return soul;
-    }
-};
-const buildAgentDispatchPrompt = (role, parentTask) => {
-    const lines = [
-        `You are ${role.displayName}${role.description ? ` — ${role.description}` : ''}.`,
-    ];
-    if (role.capabilities && role.capabilities.length > 0) {
-        lines.push(`Capabilities: ${role.capabilities.join(', ')}`);
-    }
-    if (role.systemPrompt) {
-        lines.push('System guidance:');
-        lines.push(role.systemPrompt);
-    }
-    const soulSummary = buildSoulSummary(role.soul || undefined);
-    if (soulSummary) {
-        lines.push('Role notes:');
-        lines.push(soulSummary);
-    }
-    lines.push('');
-    lines.push(`Parent task: ${parentTask.title}`);
-    lines.push('Request:');
-    lines.push(parentTask.prompt);
-    lines.push('');
-    lines.push('Deliverables:');
-    lines.push('- Provide a concise summary of your findings.');
-    lines.push('- Call out risks or open questions.');
-    lines.push('- Recommend next steps.');
-    return lines.join('\n');
-};
 const x_manager_1 = require("../settings/x-manager");
 const x_cli_1 = require("../utils/x-cli");
 const custom_skill_loader_1 = require("../agent/custom-skill-loader");
@@ -263,6 +228,7 @@ const voice_settings_manager_1 = require("../voice/voice-settings-manager");
 const VoiceService_1 = require("../voice/VoiceService");
 // Global notification service instance
 let notificationService = null;
+const resolveCustomProviderId = (providerType) => providerType === 'kimi-coding' ? 'kimi-code' : providerType;
 /**
  * Get the notification service instance
  */
@@ -286,6 +252,9 @@ rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.LLM_GET_OLLAMA_MODELS,
 rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.LLM_GET_GEMINI_MODELS, rate_limiter_1.RATE_LIMIT_CONFIGS.standard);
 rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.LLM_GET_OPENROUTER_MODELS, rate_limiter_1.RATE_LIMIT_CONFIGS.standard);
 rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.LLM_GET_BEDROCK_MODELS, rate_limiter_1.RATE_LIMIT_CONFIGS.standard);
+rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.LLM_GET_GROQ_MODELS, rate_limiter_1.RATE_LIMIT_CONFIGS.standard);
+rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.LLM_GET_XAI_MODELS, rate_limiter_1.RATE_LIMIT_CONFIGS.standard);
+rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.LLM_GET_KIMI_MODELS, rate_limiter_1.RATE_LIMIT_CONFIGS.standard);
 rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.SEARCH_SAVE_SETTINGS, rate_limiter_1.RATE_LIMIT_CONFIGS.limited);
 rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.SEARCH_TEST_PROVIDER, rate_limiter_1.RATE_LIMIT_CONFIGS.expensive);
 rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.GATEWAY_ADD_CHANNEL, rate_limiter_1.RATE_LIMIT_CONFIGS.limited);
@@ -543,6 +512,131 @@ async function setupIpcHandlers(dbManager, agentDaemon, gateway) {
             return { success: false, error: `Failed to read file: ${error.message}` };
         }
     });
+    // File import handler - copy selected files into the workspace for attachment use
+    electron_1.ipcMain.handle('file:importToWorkspace', async (_, data) => {
+        const validated = (0, validation_1.validateInput)(validation_1.FileImportSchema, data, 'file import');
+        const workspace = workspaceRepo.findById(validated.workspaceId);
+        if (!workspace) {
+            throw new Error(`Workspace not found: ${validated.workspaceId}`);
+        }
+        if (!workspace.permissions.write) {
+            throw new Error('Write permission not granted for workspace');
+        }
+        const sanitizeFileName = (fileName) => {
+            const sanitized = fileName.replace(/[<>:"/\\|?*\x00-\x1F]/g, '_').trim();
+            return sanitized.length > 0 ? sanitized : 'file';
+        };
+        const ensureUniqueName = (dir, baseName, usedNames) => {
+            const ext = path.extname(baseName);
+            const stem = path.basename(baseName, ext);
+            let candidate = baseName;
+            let counter = 1;
+            while (usedNames.has(candidate) || fsSync.existsSync(path.join(dir, candidate))) {
+                candidate = `${stem}-${counter}${ext}`;
+                counter += 1;
+            }
+            usedNames.add(candidate);
+            return candidate;
+        };
+        let uploadRoot = null;
+        const usedNames = new Set();
+        const ensureUploadRoot = async () => {
+            if (uploadRoot)
+                return uploadRoot;
+            uploadRoot = path.join(workspace.path, '.cowork', 'uploads', `${Date.now()}`);
+            await fs.mkdir(uploadRoot, { recursive: true });
+            return uploadRoot;
+        };
+        const results = [];
+        for (const filePath of validated.files) {
+            const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(filePath);
+            const stats = await fs.stat(absolutePath);
+            if (!stats.isFile()) {
+                throw new Error(`Not a file: ${filePath}`);
+            }
+            const sizeCheck = guardrail_manager_1.GuardrailManager.isFileSizeExceeded(stats.size);
+            if (sizeCheck.exceeded) {
+                throw new Error(`File "${path.basename(filePath)}" is ${sizeCheck.sizeMB.toFixed(1)}MB and exceeds the ${sizeCheck.limitMB}MB limit.`);
+            }
+            const mimeType = (mime_types_1.default.lookup(absolutePath) || undefined);
+            if (isPathWithinWorkspace(absolutePath, workspace.path)) {
+                results.push({
+                    relativePath: path.relative(workspace.path, absolutePath),
+                    fileName: path.basename(absolutePath),
+                    size: stats.size,
+                    mimeType,
+                });
+                continue;
+            }
+            const safeName = sanitizeFileName(path.basename(absolutePath));
+            const targetRoot = await ensureUploadRoot();
+            const uniqueName = ensureUniqueName(targetRoot, safeName, usedNames);
+            const destination = path.join(targetRoot, uniqueName);
+            await fs.copyFile(absolutePath, destination);
+            results.push({
+                relativePath: path.relative(workspace.path, destination),
+                fileName: uniqueName,
+                size: stats.size,
+                mimeType,
+            });
+        }
+        return results;
+    });
+    // File import handler - save provided file data into the workspace (clipboard / drag data)
+    electron_1.ipcMain.handle('file:importDataToWorkspace', async (_, data) => {
+        const validated = (0, validation_1.validateInput)(validation_1.FileImportDataSchema, data, 'file import data');
+        const workspace = workspaceRepo.findById(validated.workspaceId);
+        if (!workspace) {
+            throw new Error(`Workspace not found: ${validated.workspaceId}`);
+        }
+        if (!workspace.permissions.write) {
+            throw new Error('Write permission not granted for workspace');
+        }
+        const sanitizeFileName = (fileName) => {
+            const sanitized = fileName.replace(/[<>:"/\\|?*\x00-\x1F]/g, '_').trim();
+            return sanitized.length > 0 ? sanitized : 'file';
+        };
+        const ensureExtension = (fileName, mimeType) => {
+            if (path.extname(fileName) || !mimeType)
+                return fileName;
+            const ext = mime_types_1.default.extension(mimeType);
+            return ext ? `${fileName}.${ext}` : fileName;
+        };
+        const ensureUniqueName = (dir, baseName, usedNames) => {
+            const ext = path.extname(baseName);
+            const stem = path.basename(baseName, ext);
+            let candidate = baseName;
+            let counter = 1;
+            while (usedNames.has(candidate) || fsSync.existsSync(path.join(dir, candidate))) {
+                candidate = `${stem}-${counter}${ext}`;
+                counter += 1;
+            }
+            usedNames.add(candidate);
+            return candidate;
+        };
+        const uploadRoot = path.join(workspace.path, '.cowork', 'uploads', `${Date.now()}`);
+        await fs.mkdir(uploadRoot, { recursive: true });
+        const usedNames = new Set();
+        const results = [];
+        for (const file of validated.files) {
+            const rawName = ensureExtension(sanitizeFileName(file.name), file.mimeType);
+            const uniqueName = ensureUniqueName(uploadRoot, rawName, usedNames);
+            const destination = path.join(uploadRoot, uniqueName);
+            const buffer = Buffer.from(file.data, 'base64');
+            const sizeCheck = guardrail_manager_1.GuardrailManager.isFileSizeExceeded(buffer.length);
+            if (sizeCheck.exceeded) {
+                throw new Error(`File "${rawName}" is ${sizeCheck.sizeMB.toFixed(1)}MB and exceeds the ${sizeCheck.limitMB}MB limit.`);
+            }
+            await fs.writeFile(destination, buffer);
+            results.push({
+                relativePath: path.relative(workspace.path, destination),
+                fileName: uniqueName,
+                size: buffer.length,
+                mimeType: file.mimeType,
+            });
+        }
+        return results;
+    });
     // Workspace handlers
     electron_1.ipcMain.handle(types_1.IPC_CHANNELS.WORKSPACE_CREATE, async (_, data) => {
         const validated = (0, validation_1.validateInput)(validation_1.WorkspaceCreateSchema, data, 'workspace');
@@ -572,7 +666,16 @@ async function setupIpcHandlers(dbManager, agentDaemon, gateway) {
         return getOrCreateTempWorkspace();
     });
     electron_1.ipcMain.handle(types_1.IPC_CHANNELS.WORKSPACE_SELECT, async (_, id) => {
-        return workspaceRepo.findById(id);
+        const workspace = workspaceRepo.findById(id);
+        if (workspace && workspace.id !== types_1.TEMP_WORKSPACE_ID) {
+            try {
+                workspaceRepo.updateLastUsedAt(workspace.id);
+            }
+            catch (error) {
+                console.warn('Failed to update workspace last used time:', error);
+            }
+        }
+        return workspace;
     });
     electron_1.ipcMain.handle(types_1.IPC_CHANNELS.WORKSPACE_UPDATE_PERMISSIONS, async (_, id, permissions) => {
         const workspace = workspaceRepo.findById(id);
@@ -583,6 +686,14 @@ async function setupIpcHandlers(dbManager, agentDaemon, gateway) {
         workspaceRepo.updatePermissions(id, updatedPermissions);
         return workspaceRepo.findById(id);
     });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.WORKSPACE_TOUCH, async (_, id) => {
+        const workspace = workspaceRepo.findById(id);
+        if (!workspace) {
+            throw new Error(`Workspace not found: ${id}`);
+        }
+        workspaceRepo.updateLastUsedAt(id);
+        return workspaceRepo.findById(id);
+    });
     // Task handlers
     electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_CREATE, async (_, data) => {
         checkRateLimit(types_1.IPC_CHANNELS.TASK_CREATE);
@@ -596,6 +707,37 @@ async function setupIpcHandlers(dbManager, agentDaemon, gateway) {
             budgetTokens,
             budgetCost,
         });
+        if (workspaceId !== types_1.TEMP_WORKSPACE_ID) {
+            try {
+                workspaceRepo.updateLastUsedAt(workspaceId);
+            }
+            catch (error) {
+                console.warn('Failed to update workspace last used time:', error);
+            }
+        }
+        // Capture mentioned agent roles for deferred dispatch (after main plan is created)
+        try {
+            const activeRoles = agentRoleRepo.findAll(false).filter((role) => role.isActive);
+            const mentionedRoles = extractMentionedRoles(`${title}\n${prompt}`, activeRoles);
+            const mentionedAgentRoleIds = mentionedRoles.map((role) => role.id);
+            if (mentionedAgentRoleIds.length > 0) {
+                taskRepo.update(task.id, { mentionedAgentRoleIds });
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error('Failed to record mentioned agents:', error);
+            // Notify user of dispatch failure via activity feed
+            const errorActivity = activityRepo.create({
+                workspaceId: task.workspaceId,
+                taskId: task.id,
+                actorType: 'system',
+                activityType: 'error',
+                title: 'Agent mention capture failed',
+                description: `Failed to record mentioned agents for deferred dispatch: ${errorMessage}`,
+            });
+            getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.ACTIVITY_EVENT, { type: 'created', activity: errorActivity });
+        }
         // Start task execution in agent daemon
         try {
             await agentDaemon.startTask(task);
@@ -608,68 +750,6 @@ async function setupIpcHandlers(dbManager, agentDaemon, gateway) {
             });
             throw new Error(error.message || 'Failed to start task. Please check your LLM provider settings.');
         }
-        // Dispatch to mentioned agents (e.g., "Please review @Vision @Loki")
-        try {
-            const activeRoles = agentRoleRepo.findAll(false).filter((role) => role.isActive);
-            const mentionedRoles = extractMentionedRoles(`${title}\n${prompt}`, activeRoles);
-            const dispatchRoles = mentionedRoles.length > 0 ? mentionedRoles : activeRoles;
-            if (dispatchRoles.length > 0) {
-                taskRepo.update(task.id, {
-                    mentionedAgentRoleIds: dispatchRoles.map((role) => role.id),
-                });
-                for (const role of dispatchRoles) {
-                    const childPrompt = buildAgentDispatchPrompt(role, task);
-                    const childTask = await agentDaemon.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,
-                        },
-                    });
-                    taskRepo.update(childTask.id, {
-                        assignedAgentRoleId: role.id,
-                        boardColumn: 'todo',
-                    });
-                    const dispatchActivity = activityRepo.create({
-                        workspaceId: task.workspaceId,
-                        taskId: task.id,
-                        agentRoleId: role.id,
-                        actorType: 'system',
-                        activityType: 'agent_assigned',
-                        title: `Dispatched to ${role.displayName}`,
-                        description: childTask.title,
-                    });
-                    getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.ACTIVITY_EVENT, { type: 'created', activity: dispatchActivity });
-                    const mention = mentionRepo.create({
-                        workspaceId: task.workspaceId,
-                        taskId: task.id,
-                        toAgentRoleId: role.id,
-                        mentionType: 'request',
-                        context: `New task: ${task.title}`,
-                    });
-                    getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.MENTION_EVENT, { type: 'created', mention });
-                    const mentionActivity = 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 },
-                    });
-                    getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.ACTIVITY_EVENT, { type: 'created', activity: mentionActivity });
-                }
-            }
-        }
-        catch (error) {
-            console.error('Failed to dispatch to mentioned agents:', error);
-        }
         return task;
     });
     electron_1.ipcMain.handle(types_1.IPC_CHANNELS.TASK_GET, async (_, id) => {
@@ -872,6 +952,26 @@ async function setupIpcHandlers(dbManager, agentDaemon, gateway) {
                 authMethod: existingSettings.openai.authMethod,
             };
         }
+        const normalizeAzureSettings = (incoming, existing) => {
+            if (!incoming && !existing)
+                return undefined;
+            const mergedDeployments = [
+                ...(incoming?.deployments || []),
+                ...(existing?.deployments || []),
+            ]
+                .map((entry) => entry.trim())
+                .filter(Boolean);
+            const deployment = (incoming?.deployment || existing?.deployment || mergedDeployments[0] || '').trim();
+            if (deployment && !mergedDeployments.includes(deployment)) {
+                mergedDeployments.unshift(deployment);
+            }
+            return {
+                ...(existing || {}),
+                ...(incoming || {}),
+                deployment: deployment || undefined,
+                deployments: mergedDeployments.length > 0 ? Array.from(new Set(mergedDeployments)) : undefined,
+            };
+        };
         llm_1.LLMProviderFactory.saveSettings({
             providerType: validated.providerType,
             modelKey: validated.modelKey,
@@ -881,12 +981,20 @@ async function setupIpcHandlers(dbManager, agentDaemon, gateway) {
             gemini: validated.gemini,
             openrouter: validated.openrouter,
             openai: openaiSettings,
+            azure: normalizeAzureSettings(validated.azure, existingSettings.azure),
+            groq: validated.groq,
+            xai: validated.xai,
+            kimi: validated.kimi,
+            customProviders: validated.customProviders ?? existingSettings.customProviders,
             // Preserve cached models from existing settings
             cachedGeminiModels: existingSettings.cachedGeminiModels,
             cachedOpenRouterModels: existingSettings.cachedOpenRouterModels,
             cachedOllamaModels: existingSettings.cachedOllamaModels,
             cachedBedrockModels: existingSettings.cachedBedrockModels,
             cachedOpenAIModels: existingSettings.cachedOpenAIModels,
+            cachedGroqModels: existingSettings.cachedGroqModels,
+            cachedXaiModels: existingSettings.cachedXaiModels,
+            cachedKimiModels: existingSettings.cachedKimiModels,
         });
         // Clear cache so next task uses new settings
         llm_1.LLMProviderFactory.clearCache();
@@ -902,9 +1010,12 @@ async function setupIpcHandlers(dbManager, agentDaemon, gateway) {
             openaiAccessToken = settings.openai?.accessToken;
             openaiRefreshToken = settings.openai?.refreshToken;
         }
+        const resolvedProviderType = resolveCustomProviderId(config.providerType);
+        const customProviderConfig = config.customProviders?.[resolvedProviderType] || config.customProviders?.[config.providerType];
+        const azureDeployment = config.azure?.deployment || config.azure?.deployments?.[0];
         const providerConfig = {
             type: config.providerType,
-            model: llm_1.LLMProviderFactory.getModelId(config.modelKey, config.providerType, config.ollama?.model, config.gemini?.model, config.openrouter?.model, config.openai?.model),
+            model: llm_1.LLMProviderFactory.getModelId(config.modelKey, config.providerType, config.ollama?.model, config.gemini?.model, config.openrouter?.model, config.openai?.model, azureDeployment, config.groq?.model, config.xai?.model, config.kimi?.model, config.customProviders),
             anthropicApiKey: config.anthropic?.apiKey,
             awsRegion: config.bedrock?.region,
             awsAccessKeyId: config.bedrock?.accessKeyId,
@@ -915,9 +1026,22 @@ async function setupIpcHandlers(dbManager, agentDaemon, gateway) {
             ollamaApiKey: config.ollama?.apiKey,
             geminiApiKey: config.gemini?.apiKey,
             openrouterApiKey: config.openrouter?.apiKey,
+            openrouterBaseUrl: config.openrouter?.baseUrl,
             openaiApiKey: config.openai?.apiKey,
             openaiAccessToken: openaiAccessToken,
             openaiRefreshToken: openaiRefreshToken,
+            azureApiKey: config.azure?.apiKey,
+            azureEndpoint: config.azure?.endpoint,
+            azureDeployment: azureDeployment,
+            azureApiVersion: config.azure?.apiVersion,
+            groqApiKey: config.groq?.apiKey,
+            groqBaseUrl: config.groq?.baseUrl,
+            xaiApiKey: config.xai?.apiKey,
+            xaiBaseUrl: config.xai?.baseUrl,
+            kimiApiKey: config.kimi?.apiKey,
+            kimiBaseUrl: config.kimi?.baseUrl,
+            providerApiKey: customProviderConfig?.apiKey,
+            providerBaseUrl: customProviderConfig?.baseUrl,
         };
         return llm_1.LLMProviderFactory.testProvider(providerConfig);
     });
@@ -936,132 +1060,230 @@ async function setupIpcHandlers(dbManager, agentDaemon, gateway) {
         // Get models based on the current provider type
         let models = [];
         let currentModel = settings.modelKey;
-        switch (settings.providerType) {
-            case 'anthropic':
-            case 'bedrock':
-                // Use Anthropic/Bedrock models from MODELS
-                models = Object.entries(llm_1.MODELS).map(([key, value]) => ({
-                    key,
-                    displayName: value.displayName,
-                    description: key.includes('opus') ? 'Most capable for complex work' :
-                        key.includes('sonnet') ? 'Balanced performance and speed' :
-                            'Fast and efficient',
-                }));
-                break;
-            case 'gemini': {
-                // For Gemini, use the specific model from settings (full model ID)
-                currentModel = settings.gemini?.model || 'gemini-2.0-flash';
-                // Use cached models if available, otherwise fall back to static list
-                const cachedGemini = llm_1.LLMProviderFactory.getCachedModels('gemini');
-                if (cachedGemini && cachedGemini.length > 0) {
-                    models = cachedGemini;
-                }
-                else {
-                    // Fall back to static models
-                    models = Object.values(llm_1.GEMINI_MODELS).map((value) => ({
-                        key: value.id,
+        const resolvedProviderType = resolveCustomProviderId(settings.providerType);
+        const customEntry = llm_provider_catalog_1.CUSTOM_PROVIDER_MAP.get(resolvedProviderType);
+        if (customEntry) {
+            const customConfig = settings.customProviders?.[resolvedProviderType] || settings.customProviders?.[settings.providerType];
+            currentModel = customConfig?.model || customEntry.defaultModel;
+            models = [
+                {
+                    key: currentModel,
+                    displayName: currentModel,
+                    description: customEntry.description || `${customEntry.name} model`,
+                },
+            ];
+        }
+        else {
+            switch (settings.providerType) {
+                case 'anthropic':
+                case 'bedrock':
+                    // Use Anthropic/Bedrock models from MODELS
+                    models = Object.entries(llm_1.MODELS).map(([key, value]) => ({
+                        key,
                         displayName: value.displayName,
-                        description: value.description,
+                        description: key.includes('opus') ? 'Most capable for complex work' :
+                            key.includes('sonnet') ? 'Balanced performance and speed' :
+                                'Fast and efficient',
                     }));
+                    break;
+                case 'gemini': {
+                    // For Gemini, use the specific model from settings (full model ID)
+                    currentModel = settings.gemini?.model || 'gemini-2.0-flash';
+                    // Use cached models if available, otherwise fall back to static list
+                    const cachedGemini = llm_1.LLMProviderFactory.getCachedModels('gemini');
+                    if (cachedGemini && cachedGemini.length > 0) {
+                        models = cachedGemini;
+                    }
+                    else {
+                        // Fall back to static models
+                        models = Object.values(llm_1.GEMINI_MODELS).map((value) => ({
+                            key: value.id,
+                            displayName: value.displayName,
+                            description: value.description,
+                        }));
+                    }
+                    // Ensure the currently selected model is in the list
+                    if (currentModel && !models.some(m => m.key === currentModel)) {
+                        models.unshift({
+                            key: currentModel,
+                            displayName: currentModel,
+                            description: 'Selected model',
+                        });
+                    }
+                    break;
                 }
-                // Ensure the currently selected model is in the list
-                if (currentModel && !models.some(m => m.key === currentModel)) {
-                    models.unshift({
-                        key: currentModel,
-                        displayName: currentModel,
-                        description: 'Selected model',
-                    });
+                case 'openrouter': {
+                    // For OpenRouter, use the specific model from settings (full model ID)
+                    currentModel = settings.openrouter?.model || 'anthropic/claude-3.5-sonnet';
+                    // Use cached models if available, otherwise fall back to static list
+                    const cachedOpenRouter = llm_1.LLMProviderFactory.getCachedModels('openrouter');
+                    if (cachedOpenRouter && cachedOpenRouter.length > 0) {
+                        models = cachedOpenRouter;
+                    }
+                    else {
+                        // Fall back to static models
+                        models = Object.values(llm_1.OPENROUTER_MODELS).map((value) => ({
+                            key: value.id,
+                            displayName: value.displayName,
+                            description: value.description,
+                        }));
+                    }
+                    // Ensure the currently selected model is in the list
+                    if (currentModel && !models.some(m => m.key === currentModel)) {
+                        models.unshift({
+                            key: currentModel,
+                            displayName: currentModel,
+                            description: 'Selected model',
+                        });
+                    }
+                    break;
                 }
-                break;
-            }
-            case 'openrouter': {
-                // For OpenRouter, use the specific model from settings (full model ID)
-                currentModel = settings.openrouter?.model || 'anthropic/claude-3.5-sonnet';
-                // Use cached models if available, otherwise fall back to static list
-                const cachedOpenRouter = llm_1.LLMProviderFactory.getCachedModels('openrouter');
-                if (cachedOpenRouter && cachedOpenRouter.length > 0) {
-                    models = cachedOpenRouter;
+                case 'ollama': {
+                    // For Ollama, use the specific model from settings
+                    currentModel = settings.ollama?.model || 'llama3.2';
+                    // Use cached models if available, otherwise fall back to static list
+                    const cachedOllama = llm_1.LLMProviderFactory.getCachedModels('ollama');
+                    if (cachedOllama && cachedOllama.length > 0) {
+                        models = cachedOllama;
+                    }
+                    else {
+                        // Fall back to static models
+                        models = Object.entries(llm_1.OLLAMA_MODELS).map(([key, value]) => ({
+                            key,
+                            displayName: value.displayName,
+                            description: `${value.size} parameter model`,
+                        }));
+                    }
+                    // Ensure the currently selected model is in the list
+                    if (currentModel && !models.some(m => m.key === currentModel)) {
+                        models.unshift({
+                            key: currentModel,
+                            displayName: currentModel,
+                            description: 'Selected model',
+                        });
+                    }
+                    break;
                 }
-                else {
-                    // Fall back to static models
-                    models = Object.values(llm_1.OPENROUTER_MODELS).map((value) => ({
-                        key: value.id,
-                        displayName: value.displayName,
-                        description: value.description,
+                case 'openai': {
+                    // For OpenAI, use the specific model from settings
+                    currentModel = settings.openai?.model || 'gpt-4o-mini';
+                    // Use cached models if available, otherwise fall back to static list
+                    const cachedOpenAI = llm_1.LLMProviderFactory.getCachedModels('openai');
+                    if (cachedOpenAI && cachedOpenAI.length > 0) {
+                        models = cachedOpenAI;
+                    }
+                    else {
+                        // Fall back to static models
+                        models = [
+                            { key: 'gpt-4o', displayName: 'GPT-4o', description: 'Most capable model for complex tasks' },
+                            { key: 'gpt-4o-mini', displayName: 'GPT-4o Mini', description: 'Fast and affordable for most tasks' },
+                            { key: 'gpt-4-turbo', displayName: 'GPT-4 Turbo', description: 'Previous generation flagship' },
+                            { key: 'gpt-3.5-turbo', displayName: 'GPT-3.5 Turbo', description: 'Fast and cost-effective' },
+                            { key: 'o1', displayName: 'o1', description: 'Advanced reasoning model' },
+                            { key: 'o1-mini', displayName: 'o1 Mini', description: 'Fast reasoning model' },
+                        ];
+                    }
+                    // Ensure the currently selected model is in the list
+                    if (currentModel && !models.some(m => m.key === currentModel)) {
+                        models.unshift({
+                            key: currentModel,
+                            displayName: currentModel,
+                            description: 'Selected model',
+                        });
+                    }
+                    break;
+                }
+                case 'azure': {
+                    const deployments = (settings.azure?.deployments || []).filter(Boolean);
+                    currentModel = settings.azure?.deployment || deployments[0] || 'deployment-name';
+                    models = deployments.map((deployment) => ({
+                        key: deployment,
+                        displayName: deployment,
+                        description: 'Azure OpenAI deployment',
                     }));
+                    if (currentModel && !models.some(m => m.key === currentModel)) {
+                        models.unshift({
+                            key: currentModel,
+                            displayName: currentModel,
+                            description: 'Selected model',
+                        });
+                    }
+                    break;
                 }
-                // Ensure the currently selected model is in the list
-                if (currentModel && !models.some(m => m.key === currentModel)) {
-                    models.unshift({
-                        key: currentModel,
-                        displayName: currentModel,
-                        description: 'Selected model',
-                    });
+                case 'groq': {
+                    currentModel = settings.groq?.model || 'llama-3.1-8b-instant';
+                    const cachedGroq = llm_1.LLMProviderFactory.getCachedModels('groq');
+                    if (cachedGroq && cachedGroq.length > 0) {
+                        models = cachedGroq;
+                    }
+                    else {
+                        models = Object.values(llm_1.GROQ_MODELS).map((value) => ({
+                            key: value.id,
+                            displayName: value.displayName,
+                            description: value.description,
+                        }));
+                    }
+                    if (currentModel && !models.some(m => m.key === currentModel)) {
+                        models.unshift({
+                            key: currentModel,
+                            displayName: currentModel,
+                            description: 'Selected model',
+                        });
+                    }
+                    break;
                 }
-                break;
-            }
-            case 'ollama': {
-                // For Ollama, use the specific model from settings
-                currentModel = settings.ollama?.model || 'llama3.2';
-                // Use cached models if available, otherwise fall back to static list
-                const cachedOllama = llm_1.LLMProviderFactory.getCachedModels('ollama');
-                if (cachedOllama && cachedOllama.length > 0) {
-                    models = cachedOllama;
+                case 'xai': {
+                    currentModel = settings.xai?.model || 'grok-4-fast-non-reasoning';
+                    const cachedXai = llm_1.LLMProviderFactory.getCachedModels('xai');
+                    if (cachedXai && cachedXai.length > 0) {
+                        models = cachedXai;
+                    }
+                    else {
+                        models = Object.values(llm_1.XAI_MODELS).map((value) => ({
+                            key: value.id,
+                            displayName: value.displayName,
+                            description: value.description,
+                        }));
+                    }
+                    if (currentModel && !models.some(m => m.key === currentModel)) {
+                        models.unshift({
+                            key: currentModel,
+                            displayName: currentModel,
+                            description: 'Selected model',
+                        });
+                    }
+                    break;
+                }
+                case 'kimi': {
+                    currentModel = settings.kimi?.model || 'kimi-k2.5';
+                    const cachedKimi = llm_1.LLMProviderFactory.getCachedModels('kimi');
+                    if (cachedKimi && cachedKimi.length > 0) {
+                        models = cachedKimi;
+                    }
+                    else {
+                        models = Object.values(llm_1.KIMI_MODELS).map((value) => ({
+                            key: value.id,
+                            displayName: value.displayName,
+                            description: value.description,
+                        }));
+                    }
+                    if (currentModel && !models.some(m => m.key === currentModel)) {
+                        models.unshift({
+                            key: currentModel,
+                            displayName: currentModel,
+                            description: 'Selected model',
+                        });
+                    }
+                    break;
                 }
-                else {
-                    // Fall back to static models
-                    models = Object.entries(llm_1.OLLAMA_MODELS).map(([key, value]) => ({
+                default:
+                    // Fallback to Anthropic models
+                    models = Object.entries(llm_1.MODELS).map(([key, value]) => ({
                         key,
                         displayName: value.displayName,
-                        description: `${value.size} parameter model`,
+                        description: 'Claude model',
                     }));
-                }
-                // Ensure the currently selected model is in the list
-                if (currentModel && !models.some(m => m.key === currentModel)) {
-                    models.unshift({
-                        key: currentModel,
-                        displayName: currentModel,
-                        description: 'Selected model',
-                    });
-                }
-                break;
-            }
-            case 'openai': {
-                // For OpenAI, use the specific model from settings
-                currentModel = settings.openai?.model || 'gpt-4o-mini';
-                // Use cached models if available, otherwise fall back to static list
-                const cachedOpenAI = llm_1.LLMProviderFactory.getCachedModels('openai');
-                if (cachedOpenAI && cachedOpenAI.length > 0) {
-                    models = cachedOpenAI;
-                }
-                else {
-                    // Fall back to static models
-                    models = [
-                        { key: 'gpt-4o', displayName: 'GPT-4o', description: 'Most capable model for complex tasks' },
-                        { key: 'gpt-4o-mini', displayName: 'GPT-4o Mini', description: 'Fast and affordable for most tasks' },
-                        { key: 'gpt-4-turbo', displayName: 'GPT-4 Turbo', description: 'Previous generation flagship' },
-                        { key: 'gpt-3.5-turbo', displayName: 'GPT-3.5 Turbo', description: 'Fast and cost-effective' },
-                        { key: 'o1', displayName: 'o1', description: 'Advanced reasoning model' },
-                        { key: 'o1-mini', displayName: 'o1 Mini', description: 'Fast reasoning model' },
-                    ];
-                }
-                // Ensure the currently selected model is in the list
-                if (currentModel && !models.some(m => m.key === currentModel)) {
-                    models.unshift({
-                        key: currentModel,
-                        displayName: currentModel,
-                        description: 'Selected model',
-                    });
-                }
-                break;
             }
-            default:
-                // Fallback to Anthropic models
-                models = Object.entries(llm_1.MODELS).map(([key, value]) => ({
-                    key,
-                    displayName: value.displayName,
-                    description: 'Claude model',
-                }));
         }
         return {
             currentProvider: settings.providerType,
@@ -1073,26 +1295,61 @@ async function setupIpcHandlers(dbManager, agentDaemon, gateway) {
     // Set the current model (persists selection across sessions)
     electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_SET_MODEL, async (_, modelKey) => {
         const settings = llm_1.LLMProviderFactory.loadSettings();
+        const resolvedProviderType = resolveCustomProviderId(settings.providerType);
         // Update the model key based on the current provider
-        switch (settings.providerType) {
-            case 'gemini':
-                settings.gemini = { ...settings.gemini, model: modelKey };
-                break;
-            case 'openrouter':
-                settings.openrouter = { ...settings.openrouter, model: modelKey };
-                break;
-            case 'ollama':
-                settings.ollama = { ...settings.ollama, model: modelKey };
-                break;
-            case 'openai':
-                settings.openai = { ...settings.openai, model: modelKey };
-                break;
-            case 'anthropic':
-            case 'bedrock':
-            default:
-                // For Anthropic/Bedrock, use the modelKey field
-                settings.modelKey = modelKey;
-                break;
+        if (llm_provider_catalog_1.CUSTOM_PROVIDER_IDS.has(resolvedProviderType)) {
+            const existing = settings.customProviders?.[resolvedProviderType] || {};
+            settings.customProviders = {
+                ...(settings.customProviders || {}),
+                [resolvedProviderType]: {
+                    ...existing,
+                    model: modelKey,
+                },
+            };
+        }
+        else {
+            switch (settings.providerType) {
+                case 'gemini':
+                    settings.gemini = { ...settings.gemini, model: modelKey };
+                    break;
+                case 'openrouter':
+                    settings.openrouter = { ...settings.openrouter, model: modelKey };
+                    break;
+                case 'ollama':
+                    settings.ollama = { ...settings.ollama, model: modelKey };
+                    break;
+                case 'openai':
+                    settings.openai = { ...settings.openai, model: modelKey };
+                    break;
+                case 'azure':
+                    {
+                        const existingDeployments = (settings.azure?.deployments || []).filter(Boolean);
+                        const nextDeployments = existingDeployments.includes(modelKey)
+                            ? existingDeployments
+                            : [modelKey, ...existingDeployments];
+                        settings.azure = {
+                            ...settings.azure,
+                            deployment: modelKey,
+                            deployments: nextDeployments.length > 0 ? nextDeployments : undefined,
+                        };
+                    }
+                    break;
+                case 'groq':
+                    settings.groq = { ...settings.groq, model: modelKey };
+                    break;
+                case 'xai':
+                    settings.xai = { ...settings.xai, model: modelKey };
+                    break;
+                case 'kimi':
+                    settings.kimi = { ...settings.kimi, model: modelKey };
+                    break;
+                case 'anthropic':
+                case 'bedrock':
+                default:
+                    // For Anthropic/Bedrock, use the modelKey field
+                    settings.modelKey = modelKey;
+                    break;
+            }
         }
         llm_1.LLMProviderFactory.saveSettings(settings);
         return { success: true };
@@ -1123,9 +1380,9 @@ async function setupIpcHandlers(dbManager, agentDaemon, gateway) {
         llm_1.LLMProviderFactory.saveCachedModels('gemini', cachedModels);
         return models;
     });
-    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_GET_OPENROUTER_MODELS, async (_, apiKey) => {
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_GET_OPENROUTER_MODELS, async (_, apiKey, baseUrl) => {
         checkRateLimit(types_1.IPC_CHANNELS.LLM_GET_OPENROUTER_MODELS);
-        const models = await llm_1.LLMProviderFactory.getOpenRouterModels(apiKey);
+        const models = await llm_1.LLMProviderFactory.getOpenRouterModels(apiKey, baseUrl);
         // Cache the models for use in config status
         const cachedModels = models.map(m => ({
             key: m.id,
@@ -1148,6 +1405,39 @@ async function setupIpcHandlers(dbManager, agentDaemon, gateway) {
         llm_1.LLMProviderFactory.saveCachedModels('openai', cachedModels);
         return models;
     });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_GET_GROQ_MODELS, async (_, apiKey, baseUrl) => {
+        checkRateLimit(types_1.IPC_CHANNELS.LLM_GET_GROQ_MODELS);
+        const models = await llm_1.LLMProviderFactory.getGroqModels(apiKey, baseUrl);
+        const cachedModels = models.map(m => ({
+            key: m.id,
+            displayName: m.name,
+            description: 'Groq model',
+        }));
+        llm_1.LLMProviderFactory.saveCachedModels('groq', cachedModels);
+        return models;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_GET_XAI_MODELS, async (_, apiKey, baseUrl) => {
+        checkRateLimit(types_1.IPC_CHANNELS.LLM_GET_XAI_MODELS);
+        const models = await llm_1.LLMProviderFactory.getXAIModels(apiKey, baseUrl);
+        const cachedModels = models.map(m => ({
+            key: m.id,
+            displayName: m.name,
+            description: 'xAI model',
+        }));
+        llm_1.LLMProviderFactory.saveCachedModels('xai', cachedModels);
+        return models;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_GET_KIMI_MODELS, async (_, apiKey, baseUrl) => {
+        checkRateLimit(types_1.IPC_CHANNELS.LLM_GET_KIMI_MODELS);
+        const models = await llm_1.LLMProviderFactory.getKimiModels(apiKey, baseUrl);
+        const cachedModels = models.map(m => ({
+            key: m.id,
+            displayName: m.name,
+            description: 'Kimi model',
+        }));
+        llm_1.LLMProviderFactory.saveCachedModels('kimi', cachedModels);
+        return models;
+    });
     // OpenAI OAuth handlers
     electron_1.ipcMain.handle(types_1.IPC_CHANNELS.LLM_OPENAI_OAUTH_START, async () => {
         checkRateLimit(types_1.IPC_CHANNELS.LLM_OPENAI_OAUTH_START);
@@ -1260,6 +1550,204 @@ async function setupIpcHandlers(dbManager, agentDaemon, gateway) {
             error: result.success ? undefined : result.error,
         };
     });
+    // Notion Settings handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.NOTION_GET_SETTINGS, async () => {
+        return notion_manager_1.NotionSettingsManager.loadSettings();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.NOTION_SAVE_SETTINGS, async (_, settings) => {
+        checkRateLimit(types_1.IPC_CHANNELS.NOTION_SAVE_SETTINGS);
+        const validated = (0, validation_1.validateInput)(validation_1.NotionSettingsSchema, settings, 'notion settings');
+        notion_manager_1.NotionSettingsManager.saveSettings(validated);
+        notion_manager_1.NotionSettingsManager.clearCache();
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.NOTION_TEST_CONNECTION, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.NOTION_TEST_CONNECTION);
+        const settings = notion_manager_1.NotionSettingsManager.loadSettings();
+        return (0, notion_api_1.testNotionConnection)(settings);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.NOTION_GET_STATUS, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.NOTION_GET_STATUS);
+        const settings = notion_manager_1.NotionSettingsManager.loadSettings();
+        if (!settings.apiKey) {
+            return { configured: false, connected: false };
+        }
+        if (!settings.enabled) {
+            return { configured: true, connected: false };
+        }
+        const result = await (0, notion_api_1.testNotionConnection)(settings);
+        return {
+            configured: true,
+            connected: result.success,
+            name: result.name,
+            error: result.success ? undefined : result.error,
+        };
+    });
+    // Box Settings handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.BOX_GET_SETTINGS, async () => {
+        return box_manager_1.BoxSettingsManager.loadSettings();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.BOX_SAVE_SETTINGS, async (_, settings) => {
+        checkRateLimit(types_1.IPC_CHANNELS.BOX_SAVE_SETTINGS);
+        const validated = (0, validation_1.validateInput)(validation_1.BoxSettingsSchema, settings, 'box settings');
+        box_manager_1.BoxSettingsManager.saveSettings(validated);
+        box_manager_1.BoxSettingsManager.clearCache();
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.BOX_TEST_CONNECTION, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.BOX_TEST_CONNECTION);
+        const settings = box_manager_1.BoxSettingsManager.loadSettings();
+        return (0, box_api_1.testBoxConnection)(settings);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.BOX_GET_STATUS, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.BOX_GET_STATUS);
+        const settings = box_manager_1.BoxSettingsManager.loadSettings();
+        if (!settings.accessToken) {
+            return { configured: false, connected: false };
+        }
+        if (!settings.enabled) {
+            return { configured: true, connected: false };
+        }
+        const result = await (0, box_api_1.testBoxConnection)(settings);
+        return {
+            configured: true,
+            connected: result.success,
+            name: result.name,
+            error: result.success ? undefined : result.error,
+        };
+    });
+    // OneDrive Settings handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.ONEDRIVE_GET_SETTINGS, async () => {
+        return onedrive_manager_1.OneDriveSettingsManager.loadSettings();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.ONEDRIVE_SAVE_SETTINGS, async (_, settings) => {
+        checkRateLimit(types_1.IPC_CHANNELS.ONEDRIVE_SAVE_SETTINGS);
+        const validated = (0, validation_1.validateInput)(validation_1.OneDriveSettingsSchema, settings, 'onedrive settings');
+        onedrive_manager_1.OneDriveSettingsManager.saveSettings(validated);
+        onedrive_manager_1.OneDriveSettingsManager.clearCache();
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.ONEDRIVE_TEST_CONNECTION, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.ONEDRIVE_TEST_CONNECTION);
+        const settings = onedrive_manager_1.OneDriveSettingsManager.loadSettings();
+        return (0, onedrive_api_1.testOneDriveConnection)(settings);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.ONEDRIVE_GET_STATUS, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.ONEDRIVE_GET_STATUS);
+        const settings = onedrive_manager_1.OneDriveSettingsManager.loadSettings();
+        if (!settings.accessToken) {
+            return { configured: false, connected: false };
+        }
+        if (!settings.enabled) {
+            return { configured: true, connected: false };
+        }
+        const result = await (0, onedrive_api_1.testOneDriveConnection)(settings);
+        return {
+            configured: true,
+            connected: result.success,
+            name: result.name,
+            error: result.success ? undefined : result.error,
+        };
+    });
+    // Google Drive Settings handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.GOOGLE_DRIVE_GET_SETTINGS, async () => {
+        return google_drive_manager_1.GoogleDriveSettingsManager.loadSettings();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.GOOGLE_DRIVE_SAVE_SETTINGS, async (_, settings) => {
+        checkRateLimit(types_1.IPC_CHANNELS.GOOGLE_DRIVE_SAVE_SETTINGS);
+        const validated = (0, validation_1.validateInput)(validation_1.GoogleDriveSettingsSchema, settings, 'google drive settings');
+        google_drive_manager_1.GoogleDriveSettingsManager.saveSettings(validated);
+        google_drive_manager_1.GoogleDriveSettingsManager.clearCache();
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.GOOGLE_DRIVE_TEST_CONNECTION, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.GOOGLE_DRIVE_TEST_CONNECTION);
+        const settings = google_drive_manager_1.GoogleDriveSettingsManager.loadSettings();
+        return (0, google_drive_api_1.testGoogleDriveConnection)(settings);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.GOOGLE_DRIVE_GET_STATUS, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.GOOGLE_DRIVE_GET_STATUS);
+        const settings = google_drive_manager_1.GoogleDriveSettingsManager.loadSettings();
+        if (!settings.accessToken) {
+            return { configured: false, connected: false };
+        }
+        if (!settings.enabled) {
+            return { configured: true, connected: false };
+        }
+        const result = await (0, google_drive_api_1.testGoogleDriveConnection)(settings);
+        return {
+            configured: true,
+            connected: result.success,
+            name: result.name,
+            error: result.success ? undefined : result.error,
+        };
+    });
+    // Dropbox Settings handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.DROPBOX_GET_SETTINGS, async () => {
+        return dropbox_manager_1.DropboxSettingsManager.loadSettings();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.DROPBOX_SAVE_SETTINGS, async (_, settings) => {
+        checkRateLimit(types_1.IPC_CHANNELS.DROPBOX_SAVE_SETTINGS);
+        const validated = (0, validation_1.validateInput)(validation_1.DropboxSettingsSchema, settings, 'dropbox settings');
+        dropbox_manager_1.DropboxSettingsManager.saveSettings(validated);
+        dropbox_manager_1.DropboxSettingsManager.clearCache();
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.DROPBOX_TEST_CONNECTION, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.DROPBOX_TEST_CONNECTION);
+        const settings = dropbox_manager_1.DropboxSettingsManager.loadSettings();
+        return (0, dropbox_api_1.testDropboxConnection)(settings);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.DROPBOX_GET_STATUS, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.DROPBOX_GET_STATUS);
+        const settings = dropbox_manager_1.DropboxSettingsManager.loadSettings();
+        if (!settings.accessToken) {
+            return { configured: false, connected: false };
+        }
+        if (!settings.enabled) {
+            return { configured: true, connected: false };
+        }
+        const result = await (0, dropbox_api_1.testDropboxConnection)(settings);
+        return {
+            configured: true,
+            connected: result.success,
+            name: result.name,
+            error: result.success ? undefined : result.error,
+        };
+    });
+    // SharePoint Settings handlers
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SHAREPOINT_GET_SETTINGS, async () => {
+        return sharepoint_manager_1.SharePointSettingsManager.loadSettings();
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SHAREPOINT_SAVE_SETTINGS, async (_, settings) => {
+        checkRateLimit(types_1.IPC_CHANNELS.SHAREPOINT_SAVE_SETTINGS);
+        const validated = (0, validation_1.validateInput)(validation_1.SharePointSettingsSchema, settings, 'sharepoint settings');
+        sharepoint_manager_1.SharePointSettingsManager.saveSettings(validated);
+        sharepoint_manager_1.SharePointSettingsManager.clearCache();
+        return { success: true };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SHAREPOINT_TEST_CONNECTION, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.SHAREPOINT_TEST_CONNECTION);
+        const settings = sharepoint_manager_1.SharePointSettingsManager.loadSettings();
+        return (0, sharepoint_api_1.testSharePointConnection)(settings);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SHAREPOINT_GET_STATUS, async () => {
+        checkRateLimit(types_1.IPC_CHANNELS.SHAREPOINT_GET_STATUS);
+        const settings = sharepoint_manager_1.SharePointSettingsManager.loadSettings();
+        if (!settings.accessToken) {
+            return { configured: false, connected: false };
+        }
+        if (!settings.enabled) {
+            return { configured: true, connected: false };
+        }
+        const result = await (0, sharepoint_api_1.testSharePointConnection)(settings);
+        return {
+            configured: true,
+            connected: result.success,
+            name: result.name,
+            error: result.success ? undefined : result.error,
+        };
+    });
     // Gateway / Channel handlers
     electron_1.ipcMain.handle(types_1.IPC_CHANNELS.GATEWAY_GET_CHANNELS, async () => {
         if (!gateway)
@@ -1679,7 +2167,8 @@ async function setupIpcHandlers(dbManager, agentDaemon, gateway) {
                 throw new Error('Agent role not found');
             }
         }
-        taskRepo.update(validatedTaskId, { assignedAgentRoleId: agentRoleId ?? undefined });
+        const taskUpdate = { assignedAgentRoleId: agentRoleId ?? undefined };
+        taskRepo.update(validatedTaskId, taskUpdate);
         const task = taskRepo.findById(validatedTaskId);
         if (task) {
             if (agentRoleId) {
@@ -2030,6 +2519,7 @@ function setupMCPHandlers() {
     rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.MCP_CONNECT_SERVER, rate_limiter_1.RATE_LIMIT_CONFIGS.expensive);
     rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.MCP_TEST_SERVER, rate_limiter_1.RATE_LIMIT_CONFIGS.expensive);
     rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.MCP_REGISTRY_INSTALL, rate_limiter_1.RATE_LIMIT_CONFIGS.expensive);
+    rate_limiter_1.rateLimiter.configure(types_1.IPC_CHANNELS.MCP_CONNECTOR_OAUTH_START, rate_limiter_1.RATE_LIMIT_CONFIGS.expensive);
     // Initialize MCP settings manager
     settings_1.MCPSettingsManager.initialize();
     // Get settings
@@ -2053,7 +2543,7 @@ function setupMCPHandlers() {
     electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_ADD_SERVER, async (_, serverConfig) => {
         checkRateLimit(types_1.IPC_CHANNELS.MCP_ADD_SERVER);
         const validated = (0, validation_1.validateInput)(validation_2.MCPServerConfigSchema, serverConfig, 'MCP server config');
-        const { id, ...configWithoutId } = validated;
+        const { id: _id, ...configWithoutId } = validated;
         return settings_1.MCPSettingsManager.addServer(configWithoutId);
     });
     // Update a server
@@ -2136,6 +2626,12 @@ function setupMCPHandlers() {
         const validatedId = (0, validation_1.validateInput)(validation_1.UUIDSchema, serverId, 'server ID');
         return MCPRegistryManager_1.MCPRegistryManager.updateServer(validatedId);
     });
+    // MCP Connector OAuth (Salesforce/Jira)
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_CONNECTOR_OAUTH_START, async (_, payload) => {
+        checkRateLimit(types_1.IPC_CHANNELS.MCP_CONNECTOR_OAUTH_START);
+        const validated = (0, validation_1.validateInput)(validation_1.MCPConnectorOAuthSchema, payload, 'connector oauth');
+        return (0, connector_oauth_1.startConnectorOAuth)(validated);
+    });
     // MCP Host handlers
     electron_1.ipcMain.handle(types_1.IPC_CHANNELS.MCP_HOST_START, async () => {
         const hostServer = MCPHostServer_1.MCPHostServer.getInstance();