cowork-os 0.3.21 → 0.3.23

package/src/electron/agent/llm/types.ts

@@ -3,7 +3,9 @@
  * Allows switching between Anthropic API and AWS Bedrock
  */
 
-export type LLMProviderType = 'anthropic' | 'bedrock' | 'ollama' | 'gemini' | 'openrouter' | 'openai';
+import type { LLMProviderType } from '../../../shared/types';
+
+export type { LLMProviderType };
 
 export interface LLMProviderConfig {
   type: LLMProviderType;
@@ -24,11 +26,24 @@ export interface LLMProviderConfig {
   geminiApiKey?: string;
   // OpenRouter-specific
   openrouterApiKey?: string;
+  openrouterBaseUrl?: string;
   // OpenAI-specific
   openaiApiKey?: string;
   openaiAccessToken?: string; // OAuth access token
   openaiRefreshToken?: string; // OAuth refresh token
   openaiTokenExpiresAt?: number; // OAuth token expiry timestamp
+  // Groq-specific
+  groqApiKey?: string;
+  groqBaseUrl?: string;
+  // xAI-specific
+  xaiApiKey?: string;
+  xaiBaseUrl?: string;
+  // Kimi-specific
+  kimiApiKey?: string;
+  kimiBaseUrl?: string;
+  // Generic provider support
+  providerApiKey?: string;
+  providerBaseUrl?: string;
 }
 
 export interface LLMTool {
@@ -267,6 +282,80 @@ export const OPENAI_MODELS = {
 
 export type OpenAIModelKey = keyof typeof OPENAI_MODELS;
 
+/**
+ * Popular Groq models
+ */
+export const GROQ_MODELS = {
+  'llama-3.1-8b-instant': {
+    id: 'llama-3.1-8b-instant',
+    displayName: 'Llama 3.1 8B Instant',
+    description: 'Fast, cost-efficient Groq model',
+  },
+  'llama-3.3-70b-versatile': {
+    id: 'llama-3.3-70b-versatile',
+    displayName: 'Llama 3.3 70B Versatile',
+    description: 'Higher capability Groq model',
+  },
+} as const;
+
+export type GroqModelKey = keyof typeof GROQ_MODELS;
+
+/**
+ * Popular xAI (Grok) models
+ */
+export const XAI_MODELS = {
+  'grok-4': {
+    id: 'grok-4',
+    displayName: 'Grok 4',
+    description: 'Flagship model',
+  },
+  'grok-4-fast-non-reasoning': {
+    id: 'grok-4-fast-non-reasoning',
+    displayName: 'Grok 4 Fast (Non-Reasoning)',
+    description: 'Fast responses without explicit reasoning',
+  },
+  'grok-4-fast-reasoning': {
+    id: 'grok-4-fast-reasoning',
+    displayName: 'Grok 4 Fast (Reasoning)',
+    description: 'Faster model with reasoning support',
+  },
+} as const;
+
+export type XAIModelKey = keyof typeof XAI_MODELS;
+
+/**
+ * Kimi (Moonshot) models
+ */
+export const KIMI_MODELS = {
+  'kimi-k2.5': {
+    id: 'kimi-k2.5',
+    displayName: 'Kimi K2.5',
+    description: 'Latest Kimi K2.5 model',
+  },
+  'kimi-k2-0905-preview': {
+    id: 'kimi-k2-0905-preview',
+    displayName: 'Kimi K2.5 Preview',
+    description: 'Preview K2.5 model',
+  },
+  'kimi-k2-turbo-preview': {
+    id: 'kimi-k2-turbo-preview',
+    displayName: 'Kimi K2 Turbo (Preview)',
+    description: 'Faster K2 preview model',
+  },
+  'kimi-k2-thinking': {
+    id: 'kimi-k2-thinking',
+    displayName: 'Kimi K2 Thinking',
+    description: 'Reasoning-focused K2 model',
+  },
+  'kimi-k2-thinking-turbo': {
+    id: 'kimi-k2-thinking-turbo',
+    displayName: 'Kimi K2 Thinking Turbo',
+    description: 'Faster reasoning K2 model',
+  },
+} as const;
+
+export type KimiModelKey = keyof typeof KIMI_MODELS;
+
 /**
  * Popular Ollama models with their details
  * Users can use any model available on their Ollama server

package/src/electron/agent/llm/xai-provider.ts

@@ -0,0 +1,39 @@
+import { LLMProvider, LLMProviderConfig, LLMRequest, LLMResponse } from './types';
+import { OpenAICompatibleProvider } from './openai-compatible-provider';
+
+const XAI_BASE_URL = 'https://api.x.ai/v1';
+const DEFAULT_XAI_MODEL = 'grok-4-fast-non-reasoning';
+
+export class XAIProvider implements LLMProvider {
+  readonly type = 'xai' as const;
+  private client: OpenAICompatibleProvider;
+
+  constructor(config: LLMProviderConfig) {
+    const apiKey = config.xaiApiKey;
+    if (!apiKey) {
+      throw new Error('xAI API key is required. Configure it in Settings.');
+    }
+
+    const baseUrl = config.xaiBaseUrl || XAI_BASE_URL;
+
+    this.client = new OpenAICompatibleProvider({
+      type: 'xai',
+      providerName: 'xAI',
+      apiKey,
+      baseUrl,
+      defaultModel: config.model || DEFAULT_XAI_MODEL,
+    });
+  }
+
+  createMessage(request: LLMRequest): Promise<LLMResponse> {
+    return this.client.createMessage(request);
+  }
+
+  testConnection() {
+    return this.client.testConnection();
+  }
+
+  getAvailableModels() {
+    return this.client.getAvailableModels();
+  }
+}

package/src/electron/agent/tools/box-tools.ts

@@ -0,0 +1,239 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { Workspace } from '../../../shared/types';
+import { AgentDaemon } from '../daemon';
+import { BoxSettingsManager } from '../../settings/box-manager';
+import { boxRequest, boxUploadFile } from '../../utils/box-api';
+
+type BoxAction =
+  | 'get_current_user'
+  | 'search'
+  | 'get_file'
+  | 'get_folder'
+  | 'list_folder_items'
+  | 'create_folder'
+  | 'delete_file'
+  | 'delete_folder'
+  | 'upload_file';
+
+interface BoxActionInput {
+  action: BoxAction;
+  query?: string;
+  limit?: number;
+  offset?: number;
+  fields?: string;
+  type?: 'file' | 'folder' | 'web_link';
+  ancestor_folder_ids?: string;
+  file_extensions?: string;
+  content_types?: string;
+  scope?: string;
+  folder_id?: string;
+  file_id?: string;
+  parent_id?: string;
+  name?: string;
+  file_path?: string;
+}
+
+const DEFAULT_FOLDER_ID = '0';
+
+export class BoxTools {
+  constructor(
+    private workspace: Workspace,
+    private daemon: AgentDaemon,
+    private taskId: string
+  ) {}
+
+  setWorkspace(workspace: Workspace): void {
+    this.workspace = workspace;
+  }
+
+  static isEnabled(): boolean {
+    return BoxSettingsManager.loadSettings().enabled;
+  }
+
+  private async requireApproval(summary: string, details: Record<string, unknown>): Promise<void> {
+    const approved = await this.daemon.requestApproval(
+      this.taskId,
+      'external_service',
+      summary,
+      details
+    );
+
+    if (!approved) {
+      throw new Error('User denied Box action');
+    }
+  }
+
+  private resolveFilePath(inputPath: string): string {
+    if (!this.workspace.permissions.read) {
+      throw new Error('Read permission not granted for uploads');
+    }
+
+    const workspaceRoot = path.resolve(this.workspace.path);
+    const allowedPaths = this.workspace.permissions.allowedPaths || [];
+    const canReadOutside = this.workspace.isTemp || this.workspace.permissions.unrestrictedFileAccess;
+
+    const isPathAllowed = (absolutePath: string): boolean => {
+      if (allowedPaths.length === 0) return false;
+      const normalizedPath = path.normalize(absolutePath);
+      return allowedPaths.some((allowed) => {
+        const normalizedAllowed = path.normalize(allowed);
+        return normalizedPath === normalizedAllowed || normalizedPath.startsWith(normalizedAllowed + path.sep);
+      });
+    };
+
+    const candidate = path.isAbsolute(inputPath)
+      ? path.normalize(inputPath)
+      : path.resolve(workspaceRoot, inputPath);
+
+    const relative = path.relative(workspaceRoot, candidate);
+    const isInsideWorkspace = !(relative.startsWith('..') || path.isAbsolute(relative));
+    if (!isInsideWorkspace && !canReadOutside && !isPathAllowed(candidate)) {
+      throw new Error('File path must be inside the workspace or in Allowed Paths');
+    }
+    if (!fs.existsSync(candidate)) {
+      throw new Error(`File not found: ${inputPath}`);
+    }
+    const stats = fs.statSync(candidate);
+    if (!stats.isFile()) {
+      throw new Error(`Path is not a file: ${inputPath}`);
+    }
+    return candidate;
+  }
+
+  async executeAction(input: BoxActionInput): Promise<any> {
+    const settings = BoxSettingsManager.loadSettings();
+    if (!settings.enabled) {
+      throw new Error('Box integration is disabled. Enable it in Settings > Integrations > Box.');
+    }
+
+    const action = input.action;
+    if (!action) {
+      throw new Error('Missing required "action" parameter');
+    }
+
+    let result;
+
+    switch (action) {
+      case 'get_current_user': {
+        result = await boxRequest(settings, { method: 'GET', path: '/users/me' });
+        break;
+      }
+      case 'search': {
+        if (!input.query) throw new Error('Missing query for search');
+        result = await boxRequest(settings, {
+          method: 'GET',
+          path: '/search',
+          query: {
+            query: input.query,
+            limit: input.limit,
+            offset: input.offset,
+            fields: input.fields,
+            type: input.type,
+            ancestor_folder_ids: input.ancestor_folder_ids,
+            file_extensions: input.file_extensions,
+            content_types: input.content_types,
+            scope: input.scope,
+          },
+        });
+        break;
+      }
+      case 'get_file': {
+        if (!input.file_id) throw new Error('Missing file_id for get_file');
+        result = await boxRequest(settings, {
+          method: 'GET',
+          path: `/files/${input.file_id}`,
+          query: input.fields ? { fields: input.fields } : undefined,
+        });
+        break;
+      }
+      case 'get_folder': {
+        if (!input.folder_id) throw new Error('Missing folder_id for get_folder');
+        result = await boxRequest(settings, {
+          method: 'GET',
+          path: `/folders/${input.folder_id}`,
+          query: input.fields ? { fields: input.fields } : undefined,
+        });
+        break;
+      }
+      case 'list_folder_items': {
+        const folderId = input.folder_id || DEFAULT_FOLDER_ID;
+        result = await boxRequest(settings, {
+          method: 'GET',
+          path: `/folders/${folderId}/items`,
+          query: {
+            limit: input.limit,
+            offset: input.offset,
+            fields: input.fields,
+          },
+        });
+        break;
+      }
+      case 'create_folder': {
+        if (!input.name) throw new Error('Missing name for create_folder');
+        const parentId = input.parent_id || DEFAULT_FOLDER_ID;
+        await this.requireApproval('Create a Box folder', {
+          action: 'create_folder',
+          parent_id: parentId,
+          name: input.name,
+        });
+        result = await boxRequest(settings, {
+          method: 'POST',
+          path: '/folders',
+          body: {
+            name: input.name,
+            parent: { id: parentId },
+          },
+        });
+        break;
+      }
+      case 'delete_file': {
+        if (!input.file_id) throw new Error('Missing file_id for delete_file');
+        await this.requireApproval('Delete a Box file', { action: 'delete_file', file_id: input.file_id });
+        result = await boxRequest(settings, { method: 'DELETE', path: `/files/${input.file_id}` });
+        break;
+      }
+      case 'delete_folder': {
+        if (!input.folder_id) throw new Error('Missing folder_id for delete_folder');
+        await this.requireApproval('Delete a Box folder', { action: 'delete_folder', folder_id: input.folder_id });
+        result = await boxRequest(settings, { method: 'DELETE', path: `/folders/${input.folder_id}` });
+        break;
+      }
+      case 'upload_file': {
+        if (!input.file_path) throw new Error('Missing file_path for upload_file');
+        const parentId = input.parent_id || DEFAULT_FOLDER_ID;
+        const resolved = this.resolveFilePath(input.file_path);
+        const data = fs.readFileSync(resolved);
+        const fileName = input.name || path.basename(resolved);
+        await this.requireApproval(`Upload file to Box: ${fileName}`, {
+          action: 'upload_file',
+          parent_id: parentId,
+          file: fileName,
+        });
+        result = await boxUploadFile(settings, {
+          fileName,
+          parentId,
+          data,
+        });
+        break;
+      }
+      default:
+        throw new Error(`Unsupported action: ${action}`);
+    }
+
+    this.daemon.logEvent(this.taskId, 'tool_result', {
+      tool: 'box_action',
+      action,
+      status: result?.status,
+      hasData: result?.data ? true : false,
+    });
+
+    return {
+      success: true,
+      action,
+      status: result?.status,
+      data: result?.data,
+      raw: result?.raw,
+    };
+  }
+}

package/src/electron/agent/tools/builtin-settings.ts

@@ -44,6 +44,10 @@ export interface BuiltinToolsSettings {
   };
   // Individual tool overrides (tool name -> override)
   toolOverrides: Record<string, ToolOverride>;
+  // Per-tool timeout overrides in milliseconds (tool name -> timeout)
+  toolTimeouts: Record<string, number>;
+  // Per-tool auto-approval overrides (tool name -> enabled)
+  toolAutoApprove: Record<string, boolean>;
   // Version for migrations
   version: string;
 }
@@ -100,6 +104,8 @@ const DEFAULT_SETTINGS: BuiltinToolsSettings = {
     },
   },
   toolOverrides: {},
+  toolTimeouts: {},
+  toolAutoApprove: {},
   version: '1.0.0',
 };
 
@@ -113,6 +119,12 @@ const TOOL_CATEGORIES: Record<string, keyof BuiltinToolsSettings['categories']>
   edit_file: 'code',
   // Web fetch tools (high priority)
   web_fetch: 'webfetch',
+  notion_action: 'webfetch',
+  box_action: 'webfetch',
+  onedrive_action: 'webfetch',
+  google_drive_action: 'webfetch',
+  dropbox_action: 'webfetch',
+  sharepoint_action: 'webfetch',
   // Browser tools
   browser_navigate: 'browser',
   browser_screenshot: 'browser',
@@ -301,6 +313,8 @@ export class BuiltinToolsSettingsManager {
         ...settings.categories,
       },
       toolOverrides: settings.toolOverrides || {},
+      toolTimeouts: settings.toolTimeouts || {},
+      toolAutoApprove: settings.toolAutoApprove || {},
       version: settings.version || defaults.version,
     };
   }
@@ -353,6 +367,26 @@ export class BuiltinToolsSettingsManager {
     return TOOL_CATEGORIES[toolName] || null;
   }
 
+  /**
+   * Get per-tool timeout override (ms), if configured
+   */
+  static getToolTimeoutMs(toolName: string): number | null {
+    const settings = this.loadSettings();
+    const timeout = settings.toolTimeouts?.[toolName];
+    if (typeof timeout !== 'number' || !Number.isFinite(timeout) || timeout <= 0) {
+      return null;
+    }
+    return Math.round(timeout);
+  }
+
+  /**
+   * Check if a tool should be auto-approved
+   */
+  static getToolAutoApprove(toolName: string): boolean {
+    const settings = this.loadSettings();
+    return Boolean(settings.toolAutoApprove?.[toolName]);
+  }
+
   /**
    * Get all tool categories with their tools
    */

package/src/electron/agent/tools/dropbox-tools.ts

@@ -0,0 +1,237 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { Workspace } from '../../../shared/types';
+import { AgentDaemon } from '../daemon';
+import { DropboxSettingsManager } from '../../settings/dropbox-manager';
+import { dropboxRequest, dropboxContentUpload } from '../../utils/dropbox-api';
+
+type DropboxAction =
+  | 'get_current_user'
+  | 'list_folder'
+  | 'list_folder_continue'
+  | 'search'
+  | 'get_metadata'
+  | 'create_folder'
+  | 'delete_item'
+  | 'upload_file';
+
+interface DropboxActionInput {
+  action: DropboxAction;
+  path?: string;
+  query?: string;
+  limit?: number;
+  cursor?: string;
+  name?: string;
+  parent_path?: string;
+  file_path?: string;
+}
+
+export class DropboxTools {
+  constructor(
+    private workspace: Workspace,
+    private daemon: AgentDaemon,
+    private taskId: string
+  ) {}
+
+  setWorkspace(workspace: Workspace): void {
+    this.workspace = workspace;
+  }
+
+  static isEnabled(): boolean {
+    return DropboxSettingsManager.loadSettings().enabled;
+  }
+
+  private async requireApproval(summary: string, details: Record<string, unknown>): Promise<void> {
+    const approved = await this.daemon.requestApproval(
+      this.taskId,
+      'external_service',
+      summary,
+      details
+    );
+
+    if (!approved) {
+      throw new Error('User denied Dropbox action');
+    }
+  }
+
+  private resolveFilePath(inputPath: string): string {
+    if (!this.workspace.permissions.read) {
+      throw new Error('Read permission not granted for uploads');
+    }
+
+    const workspaceRoot = path.resolve(this.workspace.path);
+    const allowedPaths = this.workspace.permissions.allowedPaths || [];
+    const canReadOutside = this.workspace.isTemp || this.workspace.permissions.unrestrictedFileAccess;
+
+    const isPathAllowed = (absolutePath: string): boolean => {
+      if (allowedPaths.length === 0) return false;
+      const normalizedPath = path.normalize(absolutePath);
+      return allowedPaths.some((allowed) => {
+        const normalizedAllowed = path.normalize(allowed);
+        return normalizedPath === normalizedAllowed || normalizedPath.startsWith(normalizedAllowed + path.sep);
+      });
+    };
+
+    const candidate = path.isAbsolute(inputPath)
+      ? path.normalize(inputPath)
+      : path.resolve(workspaceRoot, inputPath);
+
+    const relative = path.relative(workspaceRoot, candidate);
+    const isInsideWorkspace = !(relative.startsWith('..') || path.isAbsolute(relative));
+    if (!isInsideWorkspace && !canReadOutside && !isPathAllowed(candidate)) {
+      throw new Error('File path must be inside the workspace or in Allowed Paths');
+    }
+    if (!fs.existsSync(candidate)) {
+      throw new Error(`File not found: ${inputPath}`);
+    }
+    const stats = fs.statSync(candidate);
+    if (!stats.isFile()) {
+      throw new Error(`Path is not a file: ${inputPath}`);
+    }
+    return candidate;
+  }
+
+  private normalizeDropboxPath(pathValue: string): string {
+    const trimmed = pathValue.trim();
+    if (!trimmed) return '';
+    return trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+  }
+
+  async executeAction(input: DropboxActionInput): Promise<any> {
+    const settings = DropboxSettingsManager.loadSettings();
+    if (!settings.enabled) {
+      throw new Error('Dropbox integration is disabled. Enable it in Settings > Integrations > Dropbox.');
+    }
+
+    const action = input.action;
+    if (!action) {
+      throw new Error('Missing required "action" parameter');
+    }
+
+    let result;
+
+    switch (action) {
+      case 'get_current_user': {
+        result = await dropboxRequest(settings, { method: 'POST', path: '/users/get_current_account' });
+        break;
+      }
+      case 'list_folder': {
+        const pathValue = input.path ? this.normalizeDropboxPath(input.path) : '';
+        result = await dropboxRequest(settings, {
+          method: 'POST',
+          path: '/files/list_folder',
+          body: {
+            path: pathValue,
+            recursive: false,
+            include_deleted: false,
+            include_has_explicit_shared_members: false,
+            include_mounted_folders: true,
+            limit: input.limit,
+          },
+        });
+        break;
+      }
+      case 'list_folder_continue': {
+        if (!input.cursor) throw new Error('Missing cursor for list_folder_continue');
+        result = await dropboxRequest(settings, {
+          method: 'POST',
+          path: '/files/list_folder/continue',
+          body: { cursor: input.cursor },
+        });
+        break;
+      }
+      case 'search': {
+        if (!input.query) throw new Error('Missing query for search');
+        result = await dropboxRequest(settings, {
+          method: 'POST',
+          path: '/files/search_v2',
+          body: {
+            query: input.query,
+            options: {
+              path: input.path ? this.normalizeDropboxPath(input.path) : undefined,
+              max_results: input.limit,
+            },
+          },
+        });
+        break;
+      }
+      case 'get_metadata': {
+        if (!input.path) throw new Error('Missing path for get_metadata');
+        result = await dropboxRequest(settings, {
+          method: 'POST',
+          path: '/files/get_metadata',
+          body: {
+            path: this.normalizeDropboxPath(input.path),
+            include_media_info: false,
+            include_deleted: false,
+            include_has_explicit_shared_members: false,
+          },
+        });
+        break;
+      }
+      case 'create_folder': {
+        if (!input.path) throw new Error('Missing path for create_folder');
+        const folderPath = this.normalizeDropboxPath(input.path);
+        await this.requireApproval('Create a Dropbox folder', {
+          action: 'create_folder',
+          path: folderPath,
+        });
+        result = await dropboxRequest(settings, {
+          method: 'POST',
+          path: '/files/create_folder_v2',
+          body: {
+            path: folderPath,
+            autorename: true,
+          },
+        });
+        break;
+      }
+      case 'delete_item': {
+        if (!input.path) throw new Error('Missing path for delete_item');
+        const deletePath = this.normalizeDropboxPath(input.path);
+        await this.requireApproval('Delete a Dropbox item', {
+          action: 'delete_item',
+          path: deletePath,
+        });
+        result = await dropboxRequest(settings, {
+          method: 'POST',
+          path: '/files/delete_v2',
+          body: { path: deletePath },
+        });
+        break;
+      }
+      case 'upload_file': {
+        if (!input.file_path) throw new Error('Missing file_path for upload_file');
+        const resolved = this.resolveFilePath(input.file_path);
+        const data = fs.readFileSync(resolved);
+        const fileName = input.name || path.basename(resolved);
+        const targetPath = input.path
+          ? this.normalizeDropboxPath(input.path)
+          : this.normalizeDropboxPath(`${input.parent_path || ''}/${fileName}`);
+        await this.requireApproval(`Upload file to Dropbox: ${fileName}`, {
+          action: 'upload_file',
+          path: targetPath,
+        });
+        result = await dropboxContentUpload(settings, { path: targetPath, data });
+        break;
+      }
+      default:
+        throw new Error(`Unsupported action: ${action}`);
+    }
+
+    this.daemon.logEvent(this.taskId, 'tool_result', {
+      tool: 'dropbox_action',
+      action,
+      status: result?.status,
+      hasData: result?.data ? true : false,
+    });
+
+    return {
+      success: true,
+      action,
+      status: result?.status,
+      data: result?.data,
+      raw: result?.raw,
+    };
+  }
+}