cowork-os 0.3.21 → 0.3.25

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

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicCompatibleProvider = void 0;
+const ANTHROPIC_VERSION = '2023-06-01';
+function joinUrl(baseUrl, path) {
+    const trimmedBase = baseUrl.replace(/\/+$/, '');
+    const trimmedPath = path.startsWith('/') ? path : `/${path}`;
+    return `${trimmedBase}${trimmedPath}`;
+}
+class AnthropicCompatibleProvider {
+    constructor(options) {
+        this.type = options.type;
+        this.apiKey = options.apiKey;
+        this.baseUrl = options.baseUrl;
+        this.defaultModel = options.defaultModel;
+        this.providerName = options.providerName;
+    }
+    async createMessage(request) {
+        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(() => ({}));
+                throw new Error(`${this.providerName} API error: ${response.status} ${response.statusText}` +
+                    (errorData.error?.message ? ` - ${errorData.error.message}` : ''));
+            }
+            const data = await response.json();
+            return this.convertResponse(data);
+        }
+        catch (error) {
+            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() {
+        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(() => ({}));
+                return {
+                    success: false,
+                    error: errorData.error?.message || `HTTP ${response.status}: ${response.statusText}`,
+                };
+            }
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || `Failed to connect to ${this.providerName} API`,
+            };
+        }
+    }
+    convertMessages(messages) {
+        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',
+                        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,
+                };
+            }
+            return {
+                type: 'text',
+                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,
+        };
+    }
+    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.AnthropicCompatibleProvider = AnthropicCompatibleProvider;

package/dist/electron/electron/agent/llm/azure-openai-provider.js

@@ -0,0 +1,328 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AzureOpenAIProvider = void 0;
+const openai_compatible_1 = require("./openai-compatible");
+const DEFAULT_AZURE_API_VERSION = '2024-02-15-preview';
+const isToolResult = (item) => item?.type === 'tool_result';
+const isToolUse = (item) => item?.type === 'tool_use';
+const isTextContent = (item) => item?.type === 'text';
+class AzureOpenAIProvider {
+    constructor(config) {
+        this.type = 'azure';
+        const apiKey = config.azureApiKey?.trim();
+        const endpoint = config.azureEndpoint?.trim();
+        const deployment = config.azureDeployment?.trim();
+        if (!apiKey) {
+            throw new Error('Azure OpenAI API key is required. Configure it in Settings.');
+        }
+        if (!endpoint) {
+            throw new Error('Azure OpenAI endpoint is required. Configure it in Settings.');
+        }
+        if (!deployment) {
+            throw new Error('Azure OpenAI deployment name is required. Configure it in Settings.');
+        }
+        this.apiKey = apiKey;
+        this.endpoint = endpoint.replace(/\/+$/, '');
+        this.deployment = deployment;
+        this.apiVersion = config.azureApiVersion?.trim() || DEFAULT_AZURE_API_VERSION;
+    }
+    getChatCompletionsUrl() {
+        const deployment = encodeURIComponent(this.deployment);
+        const apiVersion = encodeURIComponent(this.apiVersion);
+        return `${this.endpoint}/openai/deployments/${deployment}/chat/completions?api-version=${apiVersion}`;
+    }
+    getResponsesUrl() {
+        return `${this.endpoint}/openai/v1/responses`;
+    }
+    isMaxTokensUnsupported(errorData) {
+        const message = errorData?.error?.message || '';
+        return /max_tokens/i.test(message) && /max_completion_tokens/i.test(message);
+    }
+    isChatCompletionUnsupported(errorData) {
+        const message = errorData?.error?.message || '';
+        return /chatcompletion/i.test(message) && /(does not work|not supported|unsupported)/i.test(message);
+    }
+    buildChatCompletionsBody(request, useMaxCompletionTokens) {
+        const messages = (0, openai_compatible_1.toOpenAICompatibleMessages)(request.messages, request.system);
+        const tools = request.tools ? (0, openai_compatible_1.toOpenAICompatibleTools)(request.tools) : undefined;
+        const tokenField = useMaxCompletionTokens ? 'max_completion_tokens' : 'max_tokens';
+        return {
+            model: request.model || this.deployment,
+            messages,
+            [tokenField]: request.maxTokens,
+            ...(tools && tools.length > 0 && { tools, tool_choice: 'auto' }),
+        };
+    }
+    buildResponsesInput(messages) {
+        const input = [];
+        for (const msg of messages) {
+            if (typeof msg.content === 'string') {
+                input.push({
+                    type: 'message',
+                    role: msg.role,
+                    content: [
+                        {
+                            type: msg.role === 'assistant' ? 'output_text' : 'input_text',
+                            text: msg.content,
+                        },
+                    ],
+                });
+                continue;
+            }
+            if (!Array.isArray(msg.content)) {
+                continue;
+            }
+            for (const item of msg.content) {
+                if (isToolResult(item)) {
+                    input.push({
+                        type: 'function_call_output',
+                        call_id: item.tool_use_id,
+                        output: typeof item.content === 'string' ? item.content : JSON.stringify(item.content ?? ''),
+                    });
+                }
+            }
+            const textBlocks = msg.content.filter(isTextContent);
+            if (textBlocks.length > 0) {
+                input.push({
+                    type: 'message',
+                    role: msg.role,
+                    content: textBlocks.map((block) => ({
+                        type: msg.role === 'assistant' ? 'output_text' : 'input_text',
+                        text: block.text,
+                    })),
+                });
+            }
+            if (msg.role === 'assistant') {
+                const toolUses = msg.content.filter(isToolUse);
+                for (const toolUse of toolUses) {
+                    input.push({
+                        type: 'function_call',
+                        call_id: toolUse.id,
+                        name: toolUse.name,
+                        arguments: JSON.stringify(toolUse.input ?? {}),
+                    });
+                }
+            }
+        }
+        return input;
+    }
+    toResponsesTools(tools) {
+        return tools.map((tool) => ({
+            type: 'function',
+            name: tool.name,
+            description: tool.description,
+            parameters: this.sanitizeSchemaForResponses(tool.input_schema),
+        }));
+    }
+    sanitizeSchemaForResponses(schema) {
+        if (!schema || typeof schema !== 'object') {
+            return schema;
+        }
+        const result = Array.isArray(schema) ? [...schema] : { ...schema };
+        if (result.properties && typeof result.properties === 'object') {
+            const sanitizedProperties = {};
+            for (const [key, value] of Object.entries(result.properties)) {
+                sanitizedProperties[key] = this.sanitizeSchemaForResponses(value);
+            }
+            result.properties = sanitizedProperties;
+        }
+        if (result.items) {
+            result.items = this.sanitizeSchemaForResponses(result.items);
+        }
+        if (result.type === 'array' && !result.items) {
+            result.items = { type: 'string' };
+        }
+        return result;
+    }
+    buildResponsesBody(request) {
+        const input = this.buildResponsesInput(request.messages);
+        const tools = request.tools ? this.toResponsesTools(request.tools) : undefined;
+        return {
+            model: request.model || this.deployment,
+            input,
+            ...(request.system ? { instructions: request.system } : {}),
+            max_output_tokens: request.maxTokens,
+            ...(tools && tools.length > 0 && { tools, tool_choice: 'auto' }),
+        };
+    }
+    async sendRequest(url, body, signal) {
+        return fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'api-key': this.apiKey,
+            },
+            body: JSON.stringify(body),
+            signal,
+        });
+    }
+    parseFunctionCallArguments(value) {
+        if (!value)
+            return {};
+        if (typeof value === 'object')
+            return value;
+        if (typeof value !== 'string')
+            return {};
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return {};
+        }
+    }
+    fromResponsesApiResponse(response) {
+        const content = [];
+        let sawToolCall = false;
+        if (Array.isArray(response?.output)) {
+            response.output.forEach((item, index) => {
+                if (item.type === 'message') {
+                    const blocks = Array.isArray(item.content) ? item.content : [];
+                    for (const block of blocks) {
+                        if (block.type === 'output_text' && typeof block.text === 'string') {
+                            content.push({ type: 'text', text: block.text });
+                        }
+                    }
+                }
+                else if (item.type === 'function_call') {
+                    sawToolCall = true;
+                    const id = item.call_id || item.id || `call_${index}`;
+                    content.push({
+                        type: 'tool_use',
+                        id,
+                        name: item.name,
+                        input: this.parseFunctionCallArguments(item.arguments),
+                    });
+                }
+            });
+        }
+        if (content.length === 0 && typeof response?.output_text === 'string') {
+            content.push({ type: 'text', text: response.output_text });
+        }
+        if (content.length === 0) {
+            content.push({ type: 'text', text: '' });
+        }
+        return {
+            content,
+            stopReason: sawToolCall ? 'tool_use' : 'end_turn',
+            usage: response?.usage
+                ? {
+                    inputTokens: response.usage.input_tokens ?? 0,
+                    outputTokens: response.usage.output_tokens ?? 0,
+                }
+                : undefined,
+        };
+    }
+    async createMessage(request) {
+        try {
+            const chatUrl = this.getChatCompletionsUrl();
+            const responsesUrl = this.getResponsesUrl();
+            const runResponses = async () => {
+                const response = await this.sendRequest(responsesUrl, this.buildResponsesBody(request), request.signal);
+                if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({}));
+                    throw new Error(`Azure OpenAI API error: ${response.status} ${response.statusText}` +
+                        (errorData.error?.message ? ` - ${errorData.error.message}` : ''));
+                }
+                const data = await response.json();
+                return this.fromResponsesApiResponse(data);
+            };
+            let response = await this.sendRequest(chatUrl, this.buildChatCompletionsBody(request, false), request.signal);
+            if (!response.ok) {
+                let errorData = await response.json().catch(() => ({}));
+                if (this.isChatCompletionUnsupported(errorData)) {
+                    return await runResponses();
+                }
+                if (this.isMaxTokensUnsupported(errorData)) {
+                    response = await this.sendRequest(chatUrl, this.buildChatCompletionsBody(request, true), request.signal);
+                    if (response.ok) {
+                        const data = await response.json();
+                        return (0, openai_compatible_1.fromOpenAICompatibleResponse)(data);
+                    }
+                    errorData = await response.json().catch(() => ({}));
+                    if (this.isChatCompletionUnsupported(errorData)) {
+                        return await runResponses();
+                    }
+                }
+                throw new Error(`Azure OpenAI API error: ${response.status} ${response.statusText}` +
+                    (errorData.error?.message ? ` - ${errorData.error.message}` : ''));
+            }
+            const data = await response.json();
+            return (0, openai_compatible_1.fromOpenAICompatibleResponse)(data);
+        }
+        catch (error) {
+            if (error.name === 'AbortError' || error.message?.includes('aborted')) {
+                console.log('[Azure OpenAI] Request aborted');
+                throw new Error('Request cancelled');
+            }
+            console.error('[Azure OpenAI] API error:', {
+                message: error.message,
+            });
+            throw error;
+        }
+    }
+    async testConnection() {
+        const testMaxTokens = 16;
+        try {
+            const chatUrl = this.getChatCompletionsUrl();
+            const responsesUrl = this.getResponsesUrl();
+            const runResponses = async () => {
+                const response = await this.sendRequest(responsesUrl, {
+                    model: this.deployment,
+                    input: [
+                        {
+                            type: 'message',
+                            role: 'user',
+                            content: [{ type: 'input_text', text: 'Hi' }],
+                        },
+                    ],
+                    max_output_tokens: testMaxTokens,
+                });
+                if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({}));
+                    return {
+                        success: false,
+                        error: errorData.error?.message || `HTTP ${response.status}: ${response.statusText}`,
+                    };
+                }
+                return { success: true };
+            };
+            let response = await this.sendRequest(chatUrl, {
+                model: this.deployment,
+                messages: [{ role: 'user', content: 'Hi' }],
+                max_tokens: testMaxTokens,
+            });
+            if (!response.ok) {
+                let errorData = await response.json().catch(() => ({}));
+                if (this.isChatCompletionUnsupported(errorData)) {
+                    return await runResponses();
+                }
+                if (this.isMaxTokensUnsupported(errorData)) {
+                    response = await this.sendRequest(chatUrl, {
+                        model: this.deployment,
+                        messages: [{ role: 'user', content: 'Hi' }],
+                        max_completion_tokens: testMaxTokens,
+                    });
+                    if (response.ok) {
+                        return { success: true };
+                    }
+                    errorData = await response.json().catch(() => ({}));
+                    if (this.isChatCompletionUnsupported(errorData)) {
+                        return await runResponses();
+                    }
+                }
+                return {
+                    success: false,
+                    error: errorData.error?.message || `HTTP ${response.status}: ${response.statusText}`,
+                };
+            }
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to connect to Azure OpenAI',
+            };
+        }
+    }
+}
+exports.AzureOpenAIProvider = AzureOpenAIProvider;

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

@@ -33,9 +33,10 @@ class BedrockProvider {
         this.client = new client_bedrock_runtime_1.BedrockRuntimeClient(clientConfig);
     }
     async createMessage(request) {
-        const messages = this.convertMessages(request.messages);
+        const toolNameMap = request.tools ? this.buildToolNameMap(request.tools) : undefined;
+        const messages = this.convertMessages(request.messages, toolNameMap);
         const system = this.convertSystem(request.system);
-        const toolConfig = request.tools ? this.convertTools(request.tools) : undefined;
+        const toolConfig = request.tools ? this.convertTools(request.tools, toolNameMap) : undefined;
         const command = new client_bedrock_runtime_1.ConverseCommand({
             modelId: request.model,
             messages,
@@ -50,7 +51,7 @@ class BedrockProvider {
             const response = await this.client.send(command, 
             // Pass abort signal to allow cancellation
             request.signal ? { abortSignal: request.signal } : undefined);
-            return this.convertResponse(response);
+            return this.convertResponse(response, toolNameMap);
         }
         catch (error) {
             // Handle abort errors gracefully
@@ -103,7 +104,7 @@ class BedrockProvider {
     convertSystem(system) {
         return [{ text: system }];
     }
-    convertMessages(messages) {
+    convertMessages(messages, toolNameMap) {
         return messages.map((msg) => {
             const content = [];
             if (typeof msg.content === 'string') {
@@ -115,10 +116,11 @@ class BedrockProvider {
                         content.push({ text: item.text });
                     }
                     else if (item.type === 'tool_use') {
+                        const mappedName = toolNameMap?.toProvider.get(item.name) || item.name;
                         content.push({
                             toolUse: {
                                 toolUseId: item.id,
-                                name: item.name,
+                                name: mappedName,
                                 input: item.input,
                             },
                         });
@@ -140,11 +142,11 @@ class BedrockProvider {
             };
         });
     }
-    convertTools(tools) {
+    convertTools(tools, toolNameMap) {
         return {
             tools: tools.map((tool) => ({
                 toolSpec: {
-                    name: tool.name,
+                    name: toolNameMap?.toProvider.get(tool.name) || tool.name,
                     description: tool.description,
                     inputSchema: {
                         json: tool.input_schema,
@@ -153,7 +155,7 @@ class BedrockProvider {
             })),
         };
     }
-    convertResponse(response) {
+    convertResponse(response, toolNameMap) {
         const content = [];
         if (response.output?.message?.content) {
             for (const block of response.output.message.content) {
@@ -164,10 +166,11 @@ class BedrockProvider {
                     });
                 }
                 else if (block.toolUse) {
+                    const mappedName = toolNameMap?.fromProvider.get(block.toolUse.name) || block.toolUse.name;
                     content.push({
                         type: 'tool_use',
                         id: block.toolUse.toolUseId,
-                        name: block.toolUse.name,
+                        name: mappedName,
                         input: block.toolUse.input,
                     });
                 }
@@ -184,6 +187,42 @@ class BedrockProvider {
                 : undefined,
         };
     }
+    buildToolNameMap(tools) {
+        const toProvider = new Map();
+        const fromProvider = new Map();
+        const used = new Set();
+        for (const tool of tools) {
+            let base = this.normalizeToolName(tool.name);
+            if (!base) {
+                base = `tool_${this.shortHash(tool.name)}`;
+            }
+            let candidate = base;
+            if (used.has(candidate)) {
+                const hashed = `${base}_${this.shortHash(tool.name)}`;
+                candidate = hashed;
+                let counter = 1;
+                while (used.has(candidate)) {
+                    candidate = `${hashed}_${counter++}`;
+                }
+            }
+            used.add(candidate);
+            toProvider.set(tool.name, candidate);
+            fromProvider.set(candidate, tool.name);
+        }
+        return { toProvider, fromProvider };
+    }
+    normalizeToolName(name) {
+        const sanitized = name.replace(/[^a-zA-Z0-9_-]/g, '_');
+        return BedrockProvider.toolNameRegex.test(sanitized) ? sanitized : '';
+    }
+    shortHash(input) {
+        let hash = 2166136261;
+        for (let i = 0; i < input.length; i++) {
+            hash ^= input.charCodeAt(i);
+            hash = Math.imul(hash, 16777619);
+        }
+        return (hash >>> 0).toString(36);
+    }
     mapStopReason(reason) {
         switch (reason) {
             case 'end_turn':
@@ -200,3 +239,4 @@ class BedrockProvider {
     }
 }
 exports.BedrockProvider = BedrockProvider;
+BedrockProvider.toolNameRegex = /^[a-zA-Z0-9_-]+$/;