cowork-os 0.3.21

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

@@ -0,0 +1,175 @@
+import Anthropic from '@anthropic-ai/sdk';
+import {
+  LLMProvider,
+  LLMProviderConfig,
+  LLMRequest,
+  LLMResponse,
+  LLMContent,
+  LLMMessage,
+  LLMTool,
+} from './types';
+
+/**
+ * Anthropic API provider implementation
+ */
+export class AnthropicProvider implements LLMProvider {
+  readonly type = 'anthropic' as const;
+  private client: Anthropic;
+
+  constructor(config: LLMProviderConfig) {
+    const apiKey = config.anthropicApiKey;
+    if (!apiKey) {
+      throw new Error('Anthropic API key is required. Configure it in Settings or get one from https://console.anthropic.com/');
+    }
+
+    this.client = new Anthropic({ apiKey });
+  }
+
+  async createMessage(request: LLMRequest): Promise<LLMResponse> {
+    // Convert our generic format to Anthropic format
+    const messages = this.convertMessages(request.messages);
+    const tools = request.tools ? this.convertTools(request.tools) : undefined;
+
+    try {
+      console.log(`[Anthropic] Calling API with model: ${request.model}`);
+      const response = await this.client.messages.create(
+        {
+          model: request.model,
+          max_tokens: request.maxTokens,
+          system: request.system,
+          messages,
+          ...(tools && { tools }),
+        },
+        // Pass abort signal to allow cancellation
+        request.signal ? { signal: request.signal } : undefined
+      );
+
+      return this.convertResponse(response);
+    } catch (error: any) {
+      // Handle abort errors gracefully
+      if (error.name === 'AbortError' || error.message?.includes('aborted')) {
+        console.log(`[Anthropic] Request aborted`);
+        throw new Error('Request cancelled');
+      }
+
+      console.error(`[Anthropic] API error:`, {
+        status: error.status,
+        message: error.message,
+        type: error.type || error.name,
+        headers: error.headers ? Object.fromEntries(error.headers) : undefined,
+      });
+      throw error;
+    }
+  }
+
+  async testConnection(): Promise<{ success: boolean; error?: string }> {
+    try {
+      // Send a minimal request to test the connection
+      await this.client.messages.create({
+        model: 'claude-3-5-haiku-20241022',
+        max_tokens: 10,
+        messages: [{ role: 'user', content: 'Hi' }],
+      });
+      return { success: true };
+    } catch (error: any) {
+      return {
+        success: false,
+        error: error.message || 'Failed to connect to Anthropic API',
+      };
+    }
+  }
+
+  private convertMessages(messages: LLMMessage[]): Anthropic.MessageParam[] {
+    return messages.map((msg) => {
+      if (typeof msg.content === 'string') {
+        return {
+          role: msg.role,
+          content: msg.content,
+        };
+      }
+
+      // Handle array content (tool results or mixed 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,
+      };
+    }) as Anthropic.MessageParam[];
+  }
+
+  private convertTools(tools: LLMTool[]): Anthropic.Tool[] {
+    return tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      input_schema: tool.input_schema,
+    }));
+  }
+
+  private convertResponse(response: Anthropic.Message): LLMResponse {
+    const content: LLMContent[] = response.content
+      .filter((block) => block.type === 'text' || block.type === 'tool_use')
+      .map((block) => {
+        if (block.type === 'tool_use') {
+          return {
+            type: 'tool_use' as const,
+            id: block.id,
+            name: block.name,
+            input: block.input as Record<string, any>,
+          };
+        }
+        // Type guard: at this point block must be a TextBlock
+        return {
+          type: 'text' as const,
+          text: (block as Anthropic.TextBlock).text,
+        };
+      });
+
+    return {
+      content,
+      stopReason: this.mapStopReason(response.stop_reason),
+      usage: {
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+      },
+    };
+  }
+
+  private mapStopReason(
+    reason: Anthropic.Message['stop_reason']
+  ): 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';
+    }
+  }
+}

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

@@ -0,0 +1,236 @@
+import {
+  BedrockRuntimeClient,
+  BedrockRuntimeClientConfig,
+  ConverseCommand,
+  ContentBlock,
+  Message,
+  SystemContentBlock,
+  ToolConfiguration,
+  ToolInputSchema,
+  StopReason,
+} from '@aws-sdk/client-bedrock-runtime';
+import { fromIni } from '@aws-sdk/credential-provider-ini';
+import {
+  LLMProvider,
+  LLMProviderConfig,
+  LLMRequest,
+  LLMResponse,
+  LLMContent,
+  LLMMessage,
+  LLMTool,
+} from './types';
+
+/**
+ * AWS Bedrock provider implementation
+ * Uses the Converse API for AI models
+ */
+export class BedrockProvider implements LLMProvider {
+  readonly type = 'bedrock' as const;
+  private client: BedrockRuntimeClient;
+  private model: string;
+
+  constructor(config: LLMProviderConfig) {
+    const clientConfig: BedrockRuntimeClientConfig = {
+      region: config.awsRegion || 'us-east-1',
+    };
+
+    // Store the model for use in testConnection
+    this.model = config.model || 'anthropic.claude-3-5-sonnet-20241022-v2:0';
+
+    // Use explicit credentials if provided
+    if (config.awsAccessKeyId && config.awsSecretAccessKey) {
+      clientConfig.credentials = {
+        accessKeyId: config.awsAccessKeyId,
+        secretAccessKey: config.awsSecretAccessKey,
+        ...(config.awsSessionToken && { sessionToken: config.awsSessionToken }),
+      };
+    } else if (config.awsProfile) {
+      // Use fromIni to load credentials from a specific profile
+      // This avoids mutating process.env which could affect other code
+      clientConfig.credentials = fromIni({ profile: config.awsProfile });
+    }
+    // Otherwise, let the SDK use default credential chain
+    // (environment variables, IAM role, etc.)
+
+    this.client = new BedrockRuntimeClient(clientConfig);
+  }
+
+  async createMessage(request: LLMRequest): Promise<LLMResponse> {
+    const messages = this.convertMessages(request.messages);
+    const system = this.convertSystem(request.system);
+    const toolConfig = request.tools ? this.convertTools(request.tools) : undefined;
+
+    const command = new ConverseCommand({
+      modelId: request.model,
+      messages,
+      system,
+      inferenceConfig: {
+        maxTokens: request.maxTokens,
+      },
+      ...(toolConfig && { toolConfig }),
+    });
+
+    try {
+      console.log(`[Bedrock] Calling API with model: ${request.model}`);
+      const response = await this.client.send(
+        command,
+        // Pass abort signal to allow cancellation
+        request.signal ? { abortSignal: request.signal } : undefined
+      );
+      return this.convertResponse(response);
+    } catch (error: any) {
+      // Handle abort errors gracefully
+      if (error.name === 'AbortError' || error.message?.includes('aborted')) {
+        console.log(`[Bedrock] Request aborted`);
+        throw new Error('Request cancelled');
+      }
+
+      console.error(`[Bedrock] API error:`, {
+        name: error.name,
+        message: error.message,
+        code: error.$metadata?.httpStatusCode,
+        requestId: error.$metadata?.requestId,
+      });
+      throw error;
+    }
+  }
+
+  async testConnection(): Promise<{ success: boolean; error?: string }> {
+    try {
+      // Send a minimal request to test the connection using the configured model
+      console.log(`[Bedrock] Testing connection with model: ${this.model}`);
+      const command = new ConverseCommand({
+        modelId: this.model,
+        messages: [
+          {
+            role: 'user',
+            content: [{ text: 'Hi' }],
+          },
+        ],
+        inferenceConfig: {
+          maxTokens: 10,
+        },
+      });
+
+      await this.client.send(command);
+      return { success: true };
+    } catch (error: any) {
+      // Provide helpful error message for common issues
+      let errorMessage = error.message || 'Failed to connect to AWS Bedrock';
+
+      // Check for inference profile requirement
+      if (errorMessage.includes('inference profile')) {
+        errorMessage = `Model ${this.model} requires an inference profile. ` +
+          `Try selecting a different model or create an inference profile in AWS Console.`;
+      }
+
+      return {
+        success: false,
+        error: errorMessage,
+      };
+    }
+  }
+
+  private convertSystem(system: string): SystemContentBlock[] {
+    return [{ text: system }];
+  }
+
+  private convertMessages(messages: LLMMessage[]): Message[] {
+    return messages.map((msg) => {
+      const content: ContentBlock[] = [];
+
+      if (typeof msg.content === 'string') {
+        content.push({ text: msg.content });
+      } else {
+        for (const item of msg.content) {
+          if (item.type === 'text') {
+            content.push({ text: item.text });
+          } else if (item.type === 'tool_use') {
+            content.push({
+              toolUse: {
+                toolUseId: item.id,
+                name: item.name,
+                input: item.input,
+              },
+            });
+          } else if (item.type === 'tool_result') {
+            content.push({
+              toolResult: {
+                toolUseId: item.tool_use_id,
+                content: [{ text: item.content }],
+                status: item.is_error ? 'error' : 'success',
+              },
+            });
+          }
+        }
+      }
+
+      return {
+        role: msg.role,
+        content,
+      };
+    });
+  }
+
+  private convertTools(tools: LLMTool[]): ToolConfiguration {
+    return {
+      tools: tools.map((tool) => ({
+        toolSpec: {
+          name: tool.name,
+          description: tool.description,
+          inputSchema: {
+            json: tool.input_schema,
+          } as ToolInputSchema,
+        },
+      })),
+    };
+  }
+
+  private convertResponse(response: any): LLMResponse {
+    const content: LLMContent[] = [];
+
+    if (response.output?.message?.content) {
+      for (const block of response.output.message.content) {
+        if (block.text) {
+          content.push({
+            type: 'text',
+            text: block.text,
+          });
+        } else if (block.toolUse) {
+          content.push({
+            type: 'tool_use',
+            id: block.toolUse.toolUseId,
+            name: block.toolUse.name,
+            input: block.toolUse.input,
+          });
+        }
+      }
+    }
+
+    return {
+      content,
+      stopReason: this.mapStopReason(response.stopReason),
+      usage: response.usage
+        ? {
+            inputTokens: response.usage.inputTokens || 0,
+            outputTokens: response.usage.outputTokens || 0,
+          }
+        : undefined,
+    };
+  }
+
+  private mapStopReason(reason: StopReason | undefined): 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';
+    }
+  }
+}