cowork-os 0.3.21

package/dist/electron/electron/agent/llm/anthropic-provider.js

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicProvider = void 0;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+/**
+ * Anthropic API provider implementation
+ */
+class AnthropicProvider {
+    constructor(config) {
+        this.type = 'anthropic';
+        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 sdk_1.default({ apiKey });
+    }
+    async createMessage(request) {
+        // 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) {
+            // 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() {
+        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) {
+            return {
+                success: false,
+                error: error.message || 'Failed to connect to Anthropic API',
+            };
+        }
+    }
+    convertMessages(messages) {
+        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',
+                        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',
+                        id: item.id,
+                        name: item.name,
+                        input: item.input,
+                    };
+                }
+                return {
+                    type: 'text',
+                    text: item.text,
+                };
+            });
+            return {
+                role: msg.role,
+                content,
+            };
+        });
+    }
+    convertTools(tools) {
+        return tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            input_schema: tool.input_schema,
+        }));
+    }
+    convertResponse(response) {
+        const content = response.content
+            .filter((block) => block.type === 'text' || block.type === 'tool_use')
+            .map((block) => {
+            if (block.type === 'tool_use') {
+                return {
+                    type: 'tool_use',
+                    id: block.id,
+                    name: block.name,
+                    input: block.input,
+                };
+            }
+            // Type guard: at this point block must be a TextBlock
+            return {
+                type: 'text',
+                text: block.text,
+            };
+        });
+        return {
+            content,
+            stopReason: this.mapStopReason(response.stop_reason),
+            usage: {
+                inputTokens: response.usage.input_tokens,
+                outputTokens: response.usage.output_tokens,
+            },
+        };
+    }
+    mapStopReason(reason) {
+        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';
+        }
+    }
+}
+exports.AnthropicProvider = AnthropicProvider;

package/dist/electron/electron/agent/llm/bedrock-provider.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BedrockProvider = void 0;
+const client_bedrock_runtime_1 = require("@aws-sdk/client-bedrock-runtime");
+const credential_provider_ini_1 = require("@aws-sdk/credential-provider-ini");
+/**
+ * AWS Bedrock provider implementation
+ * Uses the Converse API for AI models
+ */
+class BedrockProvider {
+    constructor(config) {
+        this.type = 'bedrock';
+        const clientConfig = {
+            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 = (0, credential_provider_ini_1.fromIni)({ profile: config.awsProfile });
+        }
+        // Otherwise, let the SDK use default credential chain
+        // (environment variables, IAM role, etc.)
+        this.client = new client_bedrock_runtime_1.BedrockRuntimeClient(clientConfig);
+    }
+    async createMessage(request) {
+        const messages = this.convertMessages(request.messages);
+        const system = this.convertSystem(request.system);
+        const toolConfig = request.tools ? this.convertTools(request.tools) : undefined;
+        const command = new client_bedrock_runtime_1.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) {
+            // 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() {
+        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 client_bedrock_runtime_1.ConverseCommand({
+                modelId: this.model,
+                messages: [
+                    {
+                        role: 'user',
+                        content: [{ text: 'Hi' }],
+                    },
+                ],
+                inferenceConfig: {
+                    maxTokens: 10,
+                },
+            });
+            await this.client.send(command);
+            return { success: true };
+        }
+        catch (error) {
+            // 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,
+            };
+        }
+    }
+    convertSystem(system) {
+        return [{ text: system }];
+    }
+    convertMessages(messages) {
+        return messages.map((msg) => {
+            const content = [];
+            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,
+            };
+        });
+    }
+    convertTools(tools) {
+        return {
+            tools: tools.map((tool) => ({
+                toolSpec: {
+                    name: tool.name,
+                    description: tool.description,
+                    inputSchema: {
+                        json: tool.input_schema,
+                    },
+                },
+            })),
+        };
+    }
+    convertResponse(response) {
+        const content = [];
+        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,
+        };
+    }
+    mapStopReason(reason) {
+        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';
+        }
+    }
+}
+exports.BedrockProvider = BedrockProvider;