cowork-os 0.3.21 → 0.3.23

package/src/electron/agent/executor.ts

@@ -9,6 +9,7 @@ import {
   LLMProviderFactory,
   LLMMessage,
   LLMToolResult,
+  LLMToolUse,
 } from './llm';
 import {
   ContextManager,
@@ -21,6 +22,7 @@ import { calculateCost, formatCost } from './llm/pricing';
 import { getCustomSkillLoader } from './custom-skill-loader';
 import { MemoryService } from '../memory/MemoryService';
 import { InputSanitizer, OutputFilter } from './security';
+import { BuiltinToolsSettingsManager } from './tools/builtin-settings';
 
 class AwaitingUserInputError extends Error {
   constructor(message: string) {
@@ -35,7 +37,7 @@ const LLM_TIMEOUT_MS = 2 * 60 * 1000;
 // Per-step timeout (5 minutes max per step)
 const STEP_TIMEOUT_MS = 5 * 60 * 1000;
 
-// Per-tool execution timeout (45 seconds - balance responsiveness with heavier tools)
+// Default per-tool execution timeout (overrideable per tool)
 const TOOL_TIMEOUT_MS = 30 * 1000;
 
 // Maximum consecutive failures for the same tool before giving up
@@ -1014,6 +1016,7 @@ export class TaskExecutor {
   private modelKey: string;
   private conversationHistory: LLMMessage[] = [];
   private systemPrompt: string = '';
+  private lastUserMessage: string;
 
   // Plan revision tracking to prevent infinite revision loops
   private planRevisionCount: number = 0;
@@ -1040,6 +1043,7 @@ export class TaskExecutor {
     private workspace: Workspace,
     private daemon: AgentDaemon
   ) {
+    this.lastUserMessage = task.prompt;
     this.requiresTestRun = this.detectTestRequirement(`${task.title}\n${task.prompt}`);
     // Get base settings
     const settings = LLMProviderFactory.loadSettings();
@@ -1062,7 +1066,11 @@ export class TaskExecutor {
       settings.ollama?.model,
       settings.gemini?.model,
       settings.openrouter?.model,
-      settings.openai?.model
+      settings.openai?.model,
+      settings.groq?.model,
+      settings.xai?.model,
+      settings.kimi?.model,
+      settings.customProviders
     );
     this.modelKey = effectiveModelKey;
 
@@ -1220,6 +1228,23 @@ export class TaskExecutor {
     this.globalTurnCount++; // Track global turns across all steps
   }
 
+  private getToolTimeoutMs(toolName: string, input: unknown): number {
+    const settingsTimeout = BuiltinToolsSettingsManager.getToolTimeoutMs(toolName);
+    const normalizedSettingsTimeout = settingsTimeout && settingsTimeout > 0 ? settingsTimeout : null;
+
+    if (toolName === 'run_command') {
+      const inputTimeout = typeof (input as { timeout?: unknown })?.timeout === 'number'
+        ? (input as { timeout?: number }).timeout
+        : undefined;
+      if (typeof inputTimeout === 'number' && Number.isFinite(inputTimeout) && inputTimeout > 0) {
+        return Math.round(inputTimeout);
+      }
+      return normalizedSettingsTimeout ?? TOOL_TIMEOUT_MS;
+    }
+
+    return normalizedSettingsTimeout ?? TOOL_TIMEOUT_MS;
+  }
+
   /**
    * Check if a file operation should be blocked (redundant read or duplicate creation)
    * @returns Object with blocked flag, reason, and suggestion if blocked, plus optional cached result
@@ -1461,6 +1486,37 @@ export class TaskExecutor {
     return { input, modified: false };
   }
 
+  private async handleCanvasPushFallback(content: LLMToolUse, assistantText: string): Promise<void> {
+    if (content.name !== 'canvas_push') {
+      return;
+    }
+
+    const inputContent = content.input?.content;
+    const hasContent = typeof inputContent === 'string' && inputContent.trim().length > 0;
+    const filename = content.input?.filename;
+    const isHtmlTarget = !filename || filename === 'index.html';
+    if (hasContent || !isHtmlTarget) {
+      return;
+    }
+
+    const extracted = this.extractHtmlFromText(assistantText);
+    const generated = extracted || await this.generateCanvasHtml(this.lastUserMessage || this.task.prompt);
+    if (!generated) {
+      return;
+    }
+
+    content.input = {
+      ...(content.input || {}),
+      content: generated,
+    };
+    this.daemon.logEvent(this.task.id, 'parameter_inference', {
+      tool: content.name,
+      inference: extracted
+        ? 'Recovered HTML from assistant text'
+        : 'Auto-generated HTML from latest user request',
+    });
+  }
+
   /**
    * Get available tools, filtering out disabled ones
    * This prevents the LLM from trying to use tools that have been disabled by the circuit breaker
@@ -2954,6 +3010,8 @@ SCHEDULING & REMINDERS:
         // Compact messages if context is getting too large
         messages = this.contextManager.compactMessages(messages, systemPromptTokens);
 
+        const availableTools = this.getAvailableTools();
+
         // Use retry wrapper for resilient API calls
         const response = await this.callLLMWithRetry(
           () => withTimeout(
@@ -2961,7 +3019,7 @@ SCHEDULING & REMINDERS:
               model: this.modelId,
               maxTokens: 4096,
               system: this.systemPrompt,
-              tools: this.getAvailableTools(),
+              tools: availableTools,
               messages,
               signal: this.abortController.signal,
             }),
@@ -2984,6 +3042,10 @@ SCHEDULING & REMINDERS:
 
         // Log any text responses from the assistant and check if asking a question
         let assistantAskedQuestion = false;
+        const assistantText = (response.content || [])
+          .filter((item: any) => item.type === 'text' && item.text)
+          .map((item: any) => item.text)
+          .join('\n');
         if (response.content) {
           for (const content of response.content) {
             if (content.type === 'text' && content.text) {
@@ -3031,6 +3093,8 @@ SCHEDULING & REMINDERS:
         const toolResults: LLMToolResult[] = [];
         let hasDisabledToolAttempt = false;
         let hasDuplicateToolAttempt = false;
+        let hasUnavailableToolAttempt = false;
+        const availableToolNames = new Set(availableTools.map(tool => tool.name));
 
         for (const content of response.content || []) {
           if (content.type === 'tool_use') {
@@ -3056,6 +3120,40 @@ SCHEDULING & REMINDERS:
               continue;
             }
 
+            // Validate tool availability before attempting any inference
+            if (!availableToolNames.has(content.name)) {
+              console.log(`[TaskExecutor] Tool not available in this context: ${content.name}`);
+              this.daemon.logEvent(this.task.id, 'tool_error', {
+                tool: content.name,
+                error: 'Tool not available in current context or permissions',
+                blocked: true,
+              });
+              toolResults.push({
+                type: 'tool_result',
+                tool_use_id: content.id,
+                content: JSON.stringify({
+                  error: `Tool "${content.name}" is not available in this context. Please choose a different tool or check permissions/integrations.`,
+                  unavailable: true,
+                }),
+                is_error: true,
+              });
+              hasUnavailableToolAttempt = true;
+              continue;
+            }
+
+            // Infer missing parameters for weaker models (normalize inputs before deduplication)
+            const inference = this.inferMissingParameters(content.name, content.input);
+            if (inference.modified) {
+              content.input = inference.input;
+              this.daemon.logEvent(this.task.id, 'parameter_inference', {
+                tool: content.name,
+                inference: inference.inference,
+              });
+            }
+
+            // If canvas_push is missing content, try extracting HTML from assistant text or auto-generate
+            await this.handleCanvasPushFallback(content, assistantText);
+
             // Check for duplicate tool calls (prevents stuck loops)
             const duplicateCheck = this.toolCallDeduplicator.checkDuplicate(content.name, content.input);
             if (duplicateCheck.isDuplicate) {
@@ -3129,16 +3227,6 @@ SCHEDULING & REMINDERS:
               continue;
             }
 
-            // Infer missing parameters for weaker models
-            const inference = this.inferMissingParameters(content.name, content.input);
-            if (inference.modified) {
-              content.input = inference.input;
-              this.daemon.logEvent(this.task.id, 'parameter_inference', {
-                tool: content.name,
-                inference: inference.inference,
-              });
-            }
-
             this.daemon.logEvent(this.task.id, 'tool_call', {
               tool: content.name,
               input: content.input,
@@ -3146,12 +3234,13 @@ SCHEDULING & REMINDERS:
 
             try {
               // Execute tool with timeout to prevent hanging
+              const toolTimeoutMs = this.getToolTimeoutMs(content.name, content.input);
               const result = await withTimeout(
                 this.toolRegistry.executeTool(
                   content.name,
                   content.input as any
                 ),
-                TOOL_TIMEOUT_MS,
+                toolTimeoutMs,
                 `Tool ${content.name}`
               );
 
@@ -3266,7 +3355,7 @@ SCHEDULING & REMINDERS:
           // If all tool attempts were for disabled or duplicate tools, don't continue looping
           // This prevents infinite retry loops
           const allToolsFailed = toolResults.every(r => r.is_error);
-          if ((hasDisabledToolAttempt || hasDuplicateToolAttempt) && allToolsFailed) {
+          if ((hasDisabledToolAttempt || hasDuplicateToolAttempt || hasUnavailableToolAttempt) && allToolsFailed) {
             console.log('[TaskExecutor] All tool calls failed, were disabled, or duplicates - stopping iteration');
             if (hasDuplicateToolAttempt) {
               // Duplicate detection triggered - step is likely complete
@@ -3383,6 +3472,60 @@ SCHEDULING & REMINDERS:
     }
   }
 
+  private extractHtmlFromText(text: string): string | null {
+    if (!text) return null;
+    const fenceMatch = text.match(/```html([\s\S]*?)```/i);
+    const raw = fenceMatch ? fenceMatch[1].trim() : text;
+    const doctypeIndex = raw.indexOf('<!DOCTYPE html');
+    if (doctypeIndex >= 0) {
+      const endIndex = raw.lastIndexOf('</html>');
+      if (endIndex > doctypeIndex) {
+        return raw.slice(doctypeIndex, endIndex + '</html>'.length).trim();
+      }
+    }
+    const htmlIndex = raw.indexOf('<html');
+    if (htmlIndex >= 0) {
+      const endIndex = raw.lastIndexOf('</html>');
+      if (endIndex > htmlIndex) {
+        return raw.slice(htmlIndex, endIndex + '</html>'.length).trim();
+      }
+    }
+    return null;
+  }
+
+  private async generateCanvasHtml(prompt: string): Promise<string | null> {
+    const system = [
+      'You generate a single self-contained HTML document for an in-app canvas.',
+      'Output ONLY the HTML document (no markdown, no commentary).',
+      'Use inline CSS and JS. Do not reference external assets or remote URLs.',
+      'Keep it reasonably compact and interactive where appropriate.',
+    ].join(' ');
+
+    try {
+      const response = await this.provider.createMessage({
+        model: this.modelId,
+        maxTokens: 1800,
+        system,
+        messages: [
+          {
+            role: 'user',
+            content: `Build an interactive HTML demo for this request:\n${prompt}`,
+          },
+        ],
+      });
+
+      const text = (response.content || [])
+        .filter((c) => c.type === 'text')
+        .map((c) => c.text)
+        .join('\n');
+
+      return this.extractHtmlFromText(text);
+    } catch (error) {
+      console.error('[TaskExecutor] Failed to auto-generate canvas HTML:', error);
+      return null;
+    }
+  }
+
   /**
    * Send a follow-up message to continue the conversation
    */
@@ -3393,6 +3536,7 @@ SCHEDULING & REMINDERS:
     let resumeAttempted = false;
     this.waitingForUserInput = false;
     this.paused = false;
+    this.lastUserMessage = message;
     this.toolRegistry.setCanvasSessionCutoff(shouldStartNewCanvasSession ? Date.now() : null);
     this.daemon.updateTaskStatus(this.task.id, 'executing');
     this.daemon.logEvent(this.task.id, 'executing', { message: 'Processing follow-up message' });
@@ -3602,6 +3746,9 @@ SCHEDULING & REMINDERS:
         // Compact messages if context is getting too large
         messages = this.contextManager.compactMessages(messages, systemPromptTokens);
 
+        const availableTools = this.getAvailableTools();
+        const availableToolNames = new Set(availableTools.map(tool => tool.name));
+
         // Use retry wrapper for resilient API calls
         const response = await this.callLLMWithRetry(
           () => withTimeout(
@@ -3609,7 +3756,7 @@ SCHEDULING & REMINDERS:
               model: this.modelId,
               maxTokens: 4096,
               system: this.systemPrompt,
-              tools: this.getAvailableTools(),
+              tools: availableTools,
               messages,
               signal: this.abortController.signal,
             }),
@@ -3630,6 +3777,10 @@ SCHEDULING & REMINDERS:
         // Log any text responses from the assistant and check if asking a question
         let assistantAskedQuestion = false;
         let hasTextInThisResponse = false;
+        const assistantText = (response.content || [])
+          .filter((item: any) => item.type === 'text' && item.text)
+          .map((item: any) => item.text)
+          .join('\n');
         if (response.content) {
           for (const content of response.content) {
             if (content.type === 'text' && content.text && content.text.trim().length > 0) {
@@ -3679,6 +3830,7 @@ SCHEDULING & REMINDERS:
         const toolResults: LLMToolResult[] = [];
         let hasDisabledToolAttempt = false;
         let hasDuplicateToolAttempt = false;
+        let hasUnavailableToolAttempt = false;
 
         for (const content of response.content || []) {
           if (content.type === 'tool_use') {
@@ -3704,6 +3856,40 @@ SCHEDULING & REMINDERS:
               continue;
             }
 
+            // Validate tool availability before attempting any inference
+            if (!availableToolNames.has(content.name)) {
+              console.log(`[TaskExecutor] Tool not available in this context: ${content.name}`);
+              this.daemon.logEvent(this.task.id, 'tool_error', {
+                tool: content.name,
+                error: 'Tool not available in current context or permissions',
+                blocked: true,
+              });
+              toolResults.push({
+                type: 'tool_result',
+                tool_use_id: content.id,
+                content: JSON.stringify({
+                  error: `Tool "${content.name}" is not available in this context. Please choose a different tool or check permissions/integrations.`,
+                  unavailable: true,
+                }),
+                is_error: true,
+              });
+              hasUnavailableToolAttempt = true;
+              continue;
+            }
+
+            // Infer missing parameters for weaker models (normalize inputs before deduplication)
+            const inference = this.inferMissingParameters(content.name, content.input);
+            if (inference.modified) {
+              content.input = inference.input;
+              this.daemon.logEvent(this.task.id, 'parameter_inference', {
+                tool: content.name,
+                inference: inference.inference,
+              });
+            }
+
+            // If canvas_push is missing content, try extracting HTML from assistant text or auto-generate
+            await this.handleCanvasPushFallback(content, assistantText);
+
             // Check for duplicate tool calls (prevents stuck loops)
             const duplicateCheck = this.toolCallDeduplicator.checkDuplicate(content.name, content.input);
             if (duplicateCheck.isDuplicate) {
@@ -3775,16 +3961,6 @@ SCHEDULING & REMINDERS:
               continue;
             }
 
-            // Infer missing parameters for weaker models
-            const inference = this.inferMissingParameters(content.name, content.input);
-            if (inference.modified) {
-              content.input = inference.input;
-              this.daemon.logEvent(this.task.id, 'parameter_inference', {
-                tool: content.name,
-                inference: inference.inference,
-              });
-            }
-
             this.daemon.logEvent(this.task.id, 'tool_call', {
               tool: content.name,
               input: content.input,
@@ -3792,12 +3968,13 @@ SCHEDULING & REMINDERS:
 
             try {
               // Execute tool with timeout to prevent hanging
+              const toolTimeoutMs = this.getToolTimeoutMs(content.name, content.input);
               const result = await withTimeout(
                 this.toolRegistry.executeTool(
                   content.name,
                   content.input as any
                 ),
-                TOOL_TIMEOUT_MS,
+                toolTimeoutMs,
                 `Tool ${content.name}`
               );
 
@@ -3873,7 +4050,7 @@ SCHEDULING & REMINDERS:
 
           // If all tool attempts were for disabled or duplicate tools, don't continue looping
           const allToolsFailed = toolResults.every(r => r.is_error);
-          if ((hasDisabledToolAttempt || hasDuplicateToolAttempt) && allToolsFailed) {
+          if ((hasDisabledToolAttempt || hasDuplicateToolAttempt || hasUnavailableToolAttempt) && allToolsFailed) {
             console.log('[TaskExecutor] All tool calls failed, were disabled, or duplicates - stopping iteration');
             continueLoop = false;
           } else {

package/src/electron/agent/llm/anthropic-compatible-provider.ts

@@ -0,0 +1,214 @@
+import {
+  LLMProvider,
+  LLMProviderType,
+  LLMRequest,
+  LLMResponse,
+  LLMContent,
+  LLMMessage,
+  LLMTool,
+} from './types';
+
+const ANTHROPIC_VERSION = '2023-06-01';
+
+function joinUrl(baseUrl: string, path: string): string {
+  const trimmedBase = baseUrl.replace(/\/+$/, '');
+  const trimmedPath = path.startsWith('/') ? path : `/${path}`;
+  return `${trimmedBase}${trimmedPath}`;
+}
+
+export interface AnthropicCompatibleProviderOptions {
+  type: LLMProviderType;
+  providerName: string;
+  apiKey: string;
+  baseUrl: string;
+  defaultModel: string;
+}
+
+export class AnthropicCompatibleProvider implements LLMProvider {
+  readonly type: LLMProviderType;
+  private apiKey: string;
+  private baseUrl: string;
+  private defaultModel: string;
+  private providerName: string;
+
+  constructor(options: AnthropicCompatibleProviderOptions) {
+    this.type = options.type;
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl;
+    this.defaultModel = options.defaultModel;
+    this.providerName = options.providerName;
+  }
+
+  async createMessage(request: LLMRequest): Promise<LLMResponse> {
+    const messages = this.convertMessages(request.messages);
+    const tools = request.tools ? this.convertTools(request.tools) : undefined;
+    const model = request.model || this.defaultModel;
+
+    try {
+      console.log(`[${this.providerName}] Calling API with model: ${model}`);
+      const response = await fetch(joinUrl(this.baseUrl, '/messages'), {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.apiKey,
+          'anthropic-version': ANTHROPIC_VERSION,
+        },
+        body: JSON.stringify({
+          model,
+          max_tokens: request.maxTokens,
+          system: request.system,
+          messages,
+          ...(tools && { tools }),
+        }),
+        signal: request.signal,
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({})) as { error?: { message?: string } };
+        throw new Error(
+          `${this.providerName} API error: ${response.status} ${response.statusText}` +
+          (errorData.error?.message ? ` - ${errorData.error.message}` : '')
+        );
+      }
+
+      const data = await response.json() as any;
+      return this.convertResponse(data);
+    } catch (error: any) {
+      if (error.name === 'AbortError' || error.message?.includes('aborted')) {
+        console.log(`[${this.providerName}] Request aborted`);
+        throw new Error('Request cancelled');
+      }
+
+      console.error(`[${this.providerName}] API error:`, {
+        message: error.message,
+        status: error.status,
+      });
+      throw error;
+    }
+  }
+
+  async testConnection(): Promise<{ success: boolean; error?: string }> {
+    try {
+      const response = await fetch(joinUrl(this.baseUrl, '/messages'), {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.apiKey,
+          'anthropic-version': ANTHROPIC_VERSION,
+        },
+        body: JSON.stringify({
+          model: this.defaultModel,
+          max_tokens: 10,
+          messages: [{ role: 'user', content: 'Hi' }],
+        }),
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({})) as { error?: { message?: string } };
+        return {
+          success: false,
+          error: errorData.error?.message || `HTTP ${response.status}: ${response.statusText}`,
+        };
+      }
+
+      return { success: true };
+    } catch (error: any) {
+      return {
+        success: false,
+        error: error.message || `Failed to connect to ${this.providerName} API`,
+      };
+    }
+  }
+
+  private convertMessages(messages: LLMMessage[]): Array<{ role: string; content: any }> {
+    return messages.map((msg) => {
+      if (typeof msg.content === 'string') {
+        return {
+          role: msg.role,
+          content: msg.content,
+        };
+      }
+
+      const content = msg.content.map((item) => {
+        if (item.type === 'tool_result') {
+          return {
+            type: 'tool_result' as const,
+            tool_use_id: item.tool_use_id,
+            content: item.content,
+            ...(item.is_error && { is_error: true }),
+          };
+        }
+        if (item.type === 'tool_use') {
+          return {
+            type: 'tool_use' as const,
+            id: item.id,
+            name: item.name,
+            input: item.input,
+          };
+        }
+        return {
+          type: 'text' as const,
+          text: item.text,
+        };
+      });
+
+      return {
+        role: msg.role,
+        content,
+      };
+    });
+  }
+
+  private convertTools(tools: LLMTool[]): Array<{ name: string; description: string; input_schema: any }> {
+    return tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      input_schema: tool.input_schema,
+    }));
+  }
+
+  private convertResponse(response: any): LLMResponse {
+    const content: LLMContent[] = (response.content || [])
+      .filter((block: any) => block.type === 'text' || block.type === 'tool_use')
+      .map((block: any) => {
+        if (block.type === 'tool_use') {
+          return {
+            type: 'tool_use' as const,
+            id: block.id,
+            name: block.name,
+            input: block.input as Record<string, any>,
+          };
+        }
+        return {
+          type: 'text' as const,
+          text: block.text || '',
+        };
+      });
+
+    return {
+      content: content.length > 0 ? content : [{ type: 'text', text: '' }],
+      stopReason: this.mapStopReason(response.stop_reason),
+      usage: response.usage
+        ? {
+            inputTokens: response.usage.input_tokens || 0,
+            outputTokens: response.usage.output_tokens || 0,
+          }
+        : undefined,
+    };
+  }
+
+  private mapStopReason(reason?: string): LLMResponse['stopReason'] {
+    switch (reason) {
+      case 'end_turn':
+        return 'end_turn';
+      case 'tool_use':
+        return 'tool_use';
+      case 'max_tokens':
+        return 'max_tokens';
+      case 'stop_sequence':
+        return 'stop_sequence';
+      default:
+        return 'end_turn';
+    }
+  }
+}